#!/usr/bin/env python3
"""Read a binary FBX (Kaydara 7.x): skeleton, animation length and root joint.

Walks the node tree, collecting LimbNode/Root models as joints and the longest
KeyTime track as the timeline, then reads the `Connections` block to find which
joint sits at the top of the hierarchy. Frame rate is measured from the key
times themselves rather than assumed. Self-contained; no external deps.
"""
import os, struct, sys, zlib

SCALAR = {"Y": 2, "C": 1, "I": 4, "F": 4, "D": 8, "L": 8}
ELEM   = {"f": 4, "d": 8, "l": 8, "i": 4, "b": 1}
FBX_KTIME = 46186158000            # ktime units per second


def _parse(path):
    d = open(path, "rb").read()
    if d[:21] != b"Kaydara FBX Binary  \x00":
        raise ValueError("not a binary FBX")
    version = struct.unpack("<I", d[23:27])[0]
    u64 = version >= 7500
    NREC = 25 if u64 else 13
    joints, keytimes = [], []        # joints: (uid, name); keytimes: (n, type, slice)
    models, links = {}, []           # every Model uid -> name; child -> parent edges
    animated = []                    # object-property edges: curve node -> the model it drives

    def rd_prop(p):
        t = chr(d[p]); s = p; p += 1
        if t in SCALAR:
            p += SCALAR[t]; return p, (t, d[s + 1:p])
        if t in ELEM:
            length, enc, clen = struct.unpack("<III", d[p:p + 12]); p += 12
            body = clen if enc else length * ELEM[t]
            start = p; p += body
            return p, (t, b"", length, (start, body, enc))
        if t in "SR":
            ln = struct.unpack("<I", d[p:p + 4])[0]; p += 4
            val = d[p:p + ln]; p += ln
            return p, (t, val)
        raise ValueError("bad prop %r" % t)

    def rd_node(p):
        if u64: end, nprop, plen = struct.unpack("<QQQ", d[p:p + 24]); q = p + 24
        else:   end, nprop, plen = struct.unpack("<III", d[p:p + 12]); q = p + 12
        if end == 0 and nprop == 0 and plen == 0:
            return p + NREC
        nl = d[q]; q += 1; name = d[q:q + nl]; q += nl
        p = q; props = []
        for _ in range(nprop):
            p, pr = rd_prop(p); props.append(pr)
        if name == b"Model" and len(props) >= 3:
            uid = struct.unpack("<q", props[0][1])[0] if props[0][0] == "L" else 0
            nm = props[1][1].split(b"\x00\x01")[0].decode("utf-8", "replace")
            models[uid] = nm
            if props[2][1] in (b"LimbNode", b"Root"):
                joints.append((uid, nm))
        elif name == b"KeyTime" and props and len(props[0]) == 4:
            keytimes.append((props[0][2], props[0][0], props[0][3]))
        elif name == b"C" and len(props) >= 3 and props[0][1] in (b"OO", b"OP"):
            try:
                a = struct.unpack("<q", props[1][1])[0]
                b = struct.unpack("<q", props[2][1])[0]
            except (struct.error, TypeError):
                return end
            (links if props[0][1] == b"OO" else animated).append((a, b))
        while p < end:
            if d[p:p + NREC] == b"\x00" * NREC: p += NREC; break
            p = rd_node(p)
        return end

    p = 27
    while p < len(d) - 160:
        if d[p:p + NREC] == b"\x00" * NREC: break
        p = rd_node(p)
    return d, version, joints, keytimes, links, animated


ELEM_FMT = {"f": "f", "d": "d", "l": "q", "i": "i", "b": "b"}


def _timeline(d, keytimes):
    """Frames and frame rate, read off the longest key-time track.

    The track is decoded rather than counted so the spacing is measured: every
    clip in this library keys on a strict 1/30 s grid, and a clip that did not
    would report its own rate instead of inheriting an assumed one.
    """
    if not keytimes:
        return 0, 0.0
    n, t, (start, body, enc) = max(keytimes, key=lambda k: k[0])
    raw = d[start:start + body]
    try:
        if enc:
            raw = zlib.decompress(raw)
        vals = struct.unpack("<%d%s" % (n, ELEM_FMT[t]), raw[:n * ELEM[t]])
    except Exception:
        return n, 0.0
    steps = sorted({vals[i + 1] - vals[i] for i in range(len(vals) - 1)})
    step = steps[0] if steps else 0
    return n, round(FBX_KTIME / step, 3) if step else 0.0


def probe(path):
    d, version, joints, keytimes, links, animated = _parse(path)
    frames, fps = _timeline(d, keytimes)
    # The exporter types every node in the hierarchy as a `LimbNode`, mesh and
    # null containers included, so the topmost one is often `Null` or `U3DMesh 1`
    # rather than a bone. The root reported is instead the highest joint that
    # actually carries animation — the node a retargeter would drive — with the
    # largest subtree breaking ties. `joint_names` carries the full list.
    ids = {uid for uid, _ in joints}
    parent, children = {}, {}
    for child, par in links:
        if child in ids and child not in parent:
            parent[child] = par
            children.setdefault(par, []).append(child)

    def subtree(uid, seen=None):
        seen = seen or set()
        if uid in seen:
            return 0
        seen.add(uid)
        return 1 + sum(subtree(c, seen) for c in children.get(uid, ()))

    def depth(uid, seen=None):
        seen = seen or set()
        d = 0
        while uid in parent and uid not in seen:
            seen.add(uid); uid = parent[uid]; d += 1
        return d

    driven = {par for _, par in animated} & ids
    pool = driven or ids
    roots = sorted(((uid, nm) for uid, nm in joints if uid in pool),
                   key=lambda t: (depth(t[0]), -subtree(t[0])))
    names = [nm for _, nm in joints]
    return {
        "fbx_version": version,
        "num_joints": len(set(names)),
        "keyframes": frames,
        "fps": fps,
        "duration_sec": round((frames - 1) / fps, 4) if fps and frames > 1 else 0.0,
        "root_joint": roots[0][1] if roots else "",
        "num_animated": len(driven),
        "joints": sorted(set(names)),
        "joint_names": "|".join(sorted(set(names)))[:400],
    }


if __name__ == "__main__":
    for p in sys.argv[1:]:
        try:
            r = probe(p)
            print("%-34s ver=%s joints=%-4d keys=%-5d %-5s fps  %.2fs  root=%s" % (
                os.path.basename(p), r["fbx_version"], r["num_joints"],
                r["keyframes"], r["fps"], r["duration_sec"], r["root_joint"]))
        except Exception as e:
            print("%-34s ERROR %s" % (os.path.basename(p), str(e)[:60]))