#!/usr/bin/env python3
"""Build ../animation/: one flat folder, one file per distinct motion.

Files are named `<Species>-<Action>.fbx`, so the species travels with the file
rather than living in a directory: `Cat-Walk.fbx`, `Trex-Big_Roar_Step.fbx`.
The action never contains a hyphen, so `name.split("-", 1)` recovers both parts.

Every file here holds exactly one animation take, so a clip is a motion and
nothing else.

Starts from the names `normalize.py` recorded in `clips.csv` and drops two
kinds of redundancy:

1. `ALL.fbx`, the combined take that repeats every clip in its group, and
   `TPOSE.fbx`, the rest pose. Both are recognised by name, not by amplitude:
   most T-poses are perfectly flat and are dropped earlier as static, but one
   (`Tukan`) drifts by a degree or two and would otherwise pass for a clip. A
   threshold cannot separate the two — a genuine `Die_Loop` or `Sleep_Loop`
   moves no more than that drifting T-pose does — but the name settles it, since
   `TPOSE` is a reserved marker in `normalize.py` and never names a motion.
2. Clips that are the same motion exported twice. The source ships some groups
   in two batches — `Gazelle-Run.fbx` alongside a bare `run.fbx`, `PolarBearB-Idle.fbx`
   alongside `B idle 1.fbx` — and the second batch is often mislabelled
   (`die.fbx` actually holds the Fall motion). Candidates are found by comparing
   each animation curve's value range, then confirmed frame by frame, because
   the range test alone pairs up distinct motions that happen to span the same
   extents.

Which twin survives is decided in three steps. The shorter clip wins, since the
longer one carries a static tail. On a tie the clip from the group's primary
batch wins — the batch whose filenames carry the species prefix — because the
second batch is the one that abbreviates and, in several groups, mislabels. On
a tie there too the lower ordinal wins, so a group keeps `Attack_1` rather than
`Attack_2`.

Nothing here is re-exported. Every clip is a hardlink straight into
`Truebone_Z-OO/`, byte for byte, so the set costs almost no extra disk and no
clip carries a rig that a round trip through an editor has altered. A source file holding more than
one take is reported rather than repaired, and a take that exists only inside a
group's combined file stays there — `Lynx/Idle4` is the one such case.
"""
import csv, os, re, shutil, sys
HERE = os.path.dirname(os.path.abspath(__file__))
SCRIPTS = os.path.dirname(HERE)
ROOT = os.path.dirname(SCRIPTS)
sys.path[:0] = [HERE, os.path.join(SCRIPTS, "probes")]
from fbx_fingerprint import probe as fingerprint
from fbx_takes import probe as takes
from fbx_curves import same_motion
from normalize import infer_aliases, norm_species, _base_species, _alnum, RESERVED
from fbx_stacks import takes_with_motion

DST = os.path.join(ROOT, "animation")


def secondary_batch(rows):
    """The clip names whose source filename does not carry the species prefix.

    Groups shipped in two batches name them differently: `Gazelle-HeadPoke.fbx`
    against a bare `atk 1.fbx`, `POLARBEARB-Idle.fbx` against `B idle 1.fbx`.
    The prefixed batch is the primary one — the other abbreviates and, in
    several groups, mislabels. Used only to break ties between exact duplicates.
    """
    alias = infer_aliases(rows)
    out = set()
    for r in rows:
        if not r.get("normalized_name"):
            continue
        sp = norm_species(r["group"])
        stem = _alnum(os.path.splitext(os.path.basename(r["file"]))[0])
        cands = [_alnum(sp), _alnum(_base_species(sp))]
        a = alias.get((sp, r["format"]))
        if a:
            cands.append(a)
        if not any(c and stem.startswith(c) for c in cands):
            out.add(r["normalized_name"])
    return out


def main():
    rows = list(csv.DictReader(open(os.path.join(ROOT, "clips.csv"))))
    os.makedirs(DST, exist_ok=True)
    kept = []
    for r in sorted(rows, key=lambda r: r["file"]):
        name = r.get("normalized_name")
        if not name:
            continue
        if os.path.splitext(name)[0].split("-", 1)[1] in RESERVED:
            continue
        t = os.path.join(DST, name)
        if not os.path.exists(t):
            try: os.link(os.path.join(ROOT, r["file"]), t)
            except OSError: shutil.copy2(os.path.join(ROOT, r["file"]), t)
        kept.append(t)
    print("linked %d clips (%s excluded)" % (len(kept), ", ".join(sorted(RESERVED))))

    groups = {}
    for p in kept:
        r = fingerprint(p)
        mv = tuple(sorted((a, b) for a, b in r["ranges"] if b - a > 1e-6))
        if mv:
            species = os.path.basename(p).split("-", 1)[0]
            groups.setdefault((species, mv), []).append(p)

    second = secondary_batch(rows)

    def rank(p):
        action = os.path.splitext(os.path.basename(p))[0].split("-", 1)[1]
        m = re.search(r"_(\d+)$", action)
        return (takes(p)["total_sec"], os.path.basename(p) in second,
                int(m.group(1)) if m else 1, action, os.path.getsize(p))

    removed = 0
    for files in groups.values():
        if len(files) < 2:
            continue
        files.sort(key=rank)
        keep = files[0]
        for other in files[1:]:
            ok, _ = same_motion(keep, other)
            if ok:
                os.remove(other); removed += 1
                print("  duplicate of %s: removed %s"
                      % (os.path.relpath(keep, ROOT), os.path.relpath(other, ROOT)))
    print("removed %d duplicates -> %d files" % (removed, len(kept) - removed))

    # One action per clip is a property of the source, not something imposed here.
    # Reported, never repaired: rewriting a file would mean re-exporting it, and a
    # round trip through an editor rebuilds the rest pose from the first frame and
    # quietly moves the root bones.
    #
    # Counting stacks is not the same as counting actions. Four files pair the real
    # motion with an empty `Take 001` left behind by a C4D export — a stack with no
    # curves under it at all — so what matters is how many stacks carry animation.
    multi, shells = [], []
    for f in sorted(os.listdir(DST)):
        p = os.path.join(DST, f)
        n_stacks = takes(p)["num_takes"]
        n_real = takes_with_motion(p)
        if n_real > 1:
            multi.append((f, n_real))
        elif n_stacks > n_real:
            shells.append((f, n_stacks - n_real))
    if multi:
        print("WARNING: %d clip(s) carry more than one action:" % len(multi))
        for f, n in multi:
            print("   %-34s %d actions" % (f, n))
    else:
        print("every clip holds exactly one action")
    if shells:
        print("(%d also carry an empty leftover stack: %s)"
              % (len(shells), ", ".join(f for f, _ in shells)))


if __name__ == "__main__":
    main()