#!/usr/bin/env python3
"""Decide whether a binary FBX actually contains motion.

Keyframe *count* says nothing: a clip can carry 91 keys that all hold the same
value. This decodes the `KeyValueFloat` arrays of every animation curve (FBX
stores them zlib-compressed) and reports the largest peak-to-peak range found.
A file whose every curve is flat is static.
"""
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}
FMT    = {"f": "f", "d": "d", "l": "q", "i": "i", "b": "b"}


def probe(path, eps=1e-6):
    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
    curves = []          # (name, peak-to-peak range, n)

    def rd_prop(p, want_values):
        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:
            n, enc, clen = struct.unpack("<III", d[p:p + 12]); p += 12
            body = clen if enc else n * ELEM[t]
            raw = d[p:p + body]; p += body
            vals = None
            if want_values and n:
                try:
                    if enc: raw = zlib.decompress(raw)
                    vals = struct.unpack("<%d%s" % (n, FMT[t]), raw[:n * ELEM[t]])
                except Exception:
                    vals = None
            return p, (t, vals, n)
        if t in "SR":
            ln = struct.unpack("<I", d[p:p + 4])[0]; p += 4
            v = d[p:p + ln]; p += ln
            return p, (t, v)
        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
        want = name == b"KeyValueFloat"
        props = []
        for _ in range(nprop):
            p, pr = rd_prop(p, want); props.append(pr)
        if want and props and len(props[0]) == 3 and props[0][1]:
            v = props[0][1]
            curves.append((max(v) - min(v), len(v)))
        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)

    ranges = [r for r, _ in curves]
    return {
        "num_curves": len(curves),
        "max_range": max(ranges) if ranges else 0.0,
        "moving_curves": sum(1 for r in ranges if r > eps),
        "static": bool(ranges) and max(ranges) <= eps,
        "no_curves": not ranges,
    }


if __name__ == "__main__":
    for f in sys.argv[1:]:
        try:
            r = probe(f)
            print("%-40s curves=%-5d moving=%-5d max_range=%-12.6g %s" % (
                os.path.basename(f), r["num_curves"], r["moving_curves"],
                r["max_range"], "STATIC" if r["static"] else ("NO_CURVES" if r["no_curves"] else "")))
        except Exception as e:
            print("%-40s ERROR %s" % (os.path.basename(f), str(e)[:50]))