/**
 * hifi-cast-validate.ts — RENDER-VALIDATION PRE-FILTER for candidate hi-fi character GLBs.
 *
 * WHY THIS EXISTS (the lesson that bit us before): a downloaded character can pass a shallow
 * "is it rigged / does it have a humanoid mapping" proxy check and STILL render broken — legs
 * collapsed, arms contorted, the mesh folded into a knot — because the rig's bone orientation or
 * proportions don't survive retargeting. The only true acceptance gate is a GPU render + a human
 * looking at the pixels. This script does NOT replace that. It is a FAST, BROWSER-FREE,
 * GPU-FREE PRE-FILTER that rejects obviously-broken rigs (the ones that would waste a render) by:
 *
 *   1. Loading + grading the GLB (inferHumanoidRig on its bone names → gradeRig). Reports the
 *      body-acting grade, capabilities (legs/knees/ankles/feet), and mappedBoneCount.
 *   2. Building the STANDARD_LIBRARY_RIG → inferred-rig retarget map and reporting mapping
 *      coverage (how many standard bones land on this rig). Low coverage (<60%) ⇒ flag
 *      "retargeting will be poor — body acting won't transfer".
 *   3. Sampling a procedural TALK + WALK pose from the shared standard clip library, retargeting
 *      it onto this rig, running forward kinematics on a canonical rest skeleton, and CHECKING the
 *      resulting per-bone world positions for the EXACT failure signatures we saw:
 *        • legs collapsed (a foot ends up ABOVE the hips),
 *        • arms sagging / hands near the floor (a hand far below where a hand should sit),
 *        • any bone NaN / exploded (non-finite or absurd magnitude).
 *      Reports PASS (upright, legs below hips, hands at the sides) or FAIL (which signature).
 *   4. Writing a per-GLB JSON verdict to tests/reports/animation-studio/hifi-cast-validation.json.
 *
 * ⚠️  HONESTY: the FK check is a PROXY, not a render. It drives a *canonical* rest skeleton with the
 *     retargeted local rotations — it does NOT skin the actual mesh, does NOT use the GLB's real
 *     bind pose / bone lengths, and cannot see texture/weight/mesh problems. A rig can pass this FK
 *     pre-filter and still render wrong. FINAL ACCEPTANCE ALWAYS REQUIRES A REAL GPU RENDER +
 *     VISUAL REVIEW. The script prints this warning loudly.
 *
 * Does NOT touch product runtime (scene-player / animation-performance / render-live) and does NOT
 * render (no Playwright, no port). Read-only over the GLBs.
 *
 * Usage:
 *   tsx scripts/hifi-cast-validate.ts                # validate every GLB under public/hifi-cast/
 *                                                    # + the known richer aura-assets rigs
 *   tsx scripts/hifi-cast-validate.ts <glb> [<glb>…] # validate explicit GLB paths
 */

import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
import { dirname, relative, resolve } from "node:path";
import { fileURLToPath } from "node:url";

// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore — resolved at runtime to the freshly-built monorepo dist (has co-located .d.ts).
import {
  createHumanoidRetargetingMap,
  createStandardHumanoidClipDefinitions,
  gradeRig,
  HUMANOID_BONES,
  inferHumanoidRig,
  retargetHumanoidPose,
  STANDARD_LIBRARY_RIG,
  type AnimationPose,
  type AnimationPoseTransform,
  type HumanoidBoneName,
  type HumanoidRigDefinition,
  type RigGrade
} from "@aura3d/animation";

const __dirname = dirname(fileURLToPath(import.meta.url));
const TEMPLATE_DIR = resolve(__dirname, "..");
const HIFI_DIR = resolve(TEMPLATE_DIR, "public", "hifi-cast");
const AURA_ASSETS_DIR = resolve(TEMPLATE_DIR, "public", "aura-assets");
const REPORT_DIR = resolve(TEMPLATE_DIR, "tests", "reports", "animation-studio");
const REPORT_FILE = resolve(REPORT_DIR, "hifi-cast-validation.json");

/** Known richer-rig comparison assets pulled in alongside whatever lands in hifi-cast/. */
const COMPARISON_GLBS = ["rusty.catalog.glb", "luma.catalog.glb"];

/** Coverage below this means the standard performance vocabulary won't land — body acting fails. */
const POOR_COVERAGE_THRESHOLD = 0.6;

type Vec3 = readonly [number, number, number];
type Quat = readonly [number, number, number, number];

// ------------------------------------------------------------------------------------------------
// GLB parsing — read the skeleton joint node NAMES (what inference needs).
// ------------------------------------------------------------------------------------------------

interface GltfJson {
  nodes?: { name?: string; mesh?: number; children?: number[] }[];
  skins?: { joints?: number[] }[];
  animations?: { name?: string }[];
  meshes?: unknown[];
}

/** Parse just the JSON chunk of a .glb. Returns null when it isn't a binary glTF. */
function parseGlbJson(buf: Buffer): GltfJson | null {
  if (buf.length < 20 || buf.readUInt32LE(0) !== 0x46546c67) return null; // "glTF"
  const jsonLen = buf.readUInt32LE(12);
  try {
    return JSON.parse(buf.slice(20, 20 + jsonLen).toString("utf8")) as GltfJson;
  } catch {
    return null;
  }
}

/** Named skeleton joint nodes (falls back to all named nodes when there is no skin). */
function jointNodeNames(json: GltfJson): string[] {
  const nodes = json.nodes ?? [];
  const jointIdx = json.skins?.[0]?.joints ?? nodes.map((_, i) => i);
  return jointIdx
    .map((ni) => nodes[ni]?.name)
    .filter((n): n is string => typeof n === "string" && n.length > 0);
}

// ------------------------------------------------------------------------------------------------
// Canonical rest skeleton + FK (mirrors scripts/skeleton-overlay.ts — a neutral ~1.75m humanoid in
// metres, hips at ~0.95m). The FK proxy drives THIS canonical skeleton with the retargeted local
// rotations; it deliberately does not use the GLB's own bind pose (see the honesty note up top).
// ------------------------------------------------------------------------------------------------

interface RestBone {
  readonly parent: HumanoidBoneName | null;
  readonly offset: Vec3;
}

const REST_SKELETON: Readonly<Record<HumanoidBoneName, RestBone>> = {
  hips: { parent: null, offset: [0, 0.95, 0] },
  spine: { parent: "hips", offset: [0, 0.12, 0] },
  chest: { parent: "spine", offset: [0, 0.14, 0] },
  upperChest: { parent: "chest", offset: [0, 0.1, 0] },
  neck: { parent: "upperChest", offset: [0, 0.08, 0] },
  head: { parent: "neck", offset: [0, 0.12, 0] },
  leftShoulder: { parent: "upperChest", offset: [0.06, 0.05, 0] },
  leftUpperArm: { parent: "leftShoulder", offset: [0.14, 0, 0] },
  leftLowerArm: { parent: "leftUpperArm", offset: [0.26, 0, 0] },
  leftHand: { parent: "leftLowerArm", offset: [0.24, 0, 0] },
  rightShoulder: { parent: "upperChest", offset: [-0.06, 0.05, 0] },
  rightUpperArm: { parent: "rightShoulder", offset: [-0.14, 0, 0] },
  rightLowerArm: { parent: "rightUpperArm", offset: [-0.26, 0, 0] },
  rightHand: { parent: "rightLowerArm", offset: [-0.24, 0, 0] },
  leftUpperLeg: { parent: "hips", offset: [0.09, -0.04, 0] },
  leftLowerLeg: { parent: "leftUpperLeg", offset: [0, -0.42, 0] },
  leftFoot: { parent: "leftLowerLeg", offset: [0, -0.42, 0.04] },
  leftToes: { parent: "leftFoot", offset: [0, -0.06, 0.12] },
  rightUpperLeg: { parent: "hips", offset: [-0.09, -0.04, 0] },
  rightLowerLeg: { parent: "rightUpperLeg", offset: [0, -0.42, 0] },
  rightFoot: { parent: "rightLowerLeg", offset: [0, -0.42, 0.04] },
  rightToes: { parent: "rightFoot", offset: [0, -0.06, 0.12] }
};

const IDENTITY: Quat = [0, 0, 0, 1];

function qMulV(q: Quat, v: Vec3): Vec3 {
  const [x, y, z, w] = q;
  const tx = 2 * (y * v[2] - z * v[1]);
  const ty = 2 * (z * v[0] - x * v[2]);
  const tz = 2 * (x * v[1] - y * v[0]);
  return [
    v[0] + w * tx + (y * tz - z * ty),
    v[1] + w * ty + (z * tx - x * tz),
    v[2] + w * tz + (x * ty - y * tx)
  ];
}

function qMul(a: Quat, b: Quat): Quat {
  return [
    a[3] * b[0] + a[0] * b[3] + a[1] * b[2] - a[2] * b[1],
    a[3] * b[1] - a[0] * b[2] + a[1] * b[3] + a[2] * b[0],
    a[3] * b[2] + a[0] * b[1] - a[1] * b[0] + a[2] * b[3],
    a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2]
  ];
}

/** Forward kinematics over the canonical rest skeleton given per-bone local rotations + hips offset. */
export function solveWorld(rotations: Partial<Record<HumanoidBoneName, Quat>>, hipsOffset: Vec3): Record<HumanoidBoneName, Vec3> {
  const worldPos = {} as Record<HumanoidBoneName, Vec3>;
  const worldRot = {} as Record<HumanoidBoneName, Quat>;
  // REST_SKELETON is declared parent-before-child, so a single pass resolves the chain.
  for (const bone of Object.keys(REST_SKELETON) as HumanoidBoneName[]) {
    const rest = REST_SKELETON[bone];
    const localRot = rotations[bone] ?? IDENTITY;
    if (rest.parent === null) {
      worldRot[bone] = localRot;
      worldPos[bone] = [rest.offset[0] + hipsOffset[0], rest.offset[1] + hipsOffset[1], rest.offset[2] + hipsOffset[2]];
    } else {
      const pRot = worldRot[rest.parent] ?? IDENTITY;
      const pPos = worldPos[rest.parent] ?? ([0, 0, 0] as Vec3);
      const rotated = qMulV(pRot, rest.offset);
      worldPos[bone] = [pPos[0] + rotated[0], pPos[1] + rotated[1], pPos[2] + rotated[2]];
      worldRot[bone] = qMul(pRot, localRot);
    }
  }
  return worldPos;
}

// ------------------------------------------------------------------------------------------------
// Pose sampling + retargeting.
// ------------------------------------------------------------------------------------------------

const STANDARD_CLIPS = createStandardHumanoidClipDefinitions();

interface ClipLike {
  readonly duration: number;
  readonly loop: boolean;
  readonly tracks: readonly { readonly target: string; readonly valueType: string; sample(t: number): unknown }[];
}

/**
 * Sample a standard library clip at `t` into an {@link AnimationPose} keyed by the canonical
 * HUMANOID_BONES (the standard clips' tracks target `<bone>.rotation` / `hips.translation`). This
 * is the SOURCE pose handed to {@link retargetHumanoidPose}.
 */
function sampleStandardPose(clipId: string, t: number): AnimationPose {
  const clip = STANDARD_CLIPS.find((c) => c.id === clipId) as ClipLike | undefined;
  if (!clip) throw new Error(`standard clip not found: ${clipId}`);
  const duration = clip.duration > 0 ? clip.duration : 1;
  const local = clip.loop ? t % duration : Math.min(t, duration);
  const bones: Record<string, { position?: { x: number; y: number; z: number }; rotation?: { x: number; y: number; z: number; w: number } }> = {};
  for (const track of clip.tracks) {
    const dot = track.target.lastIndexOf(".");
    if (dot < 0) continue;
    const bone = track.target.slice(0, dot);
    const path = track.target.slice(dot + 1);
    const v = track.sample(local) as number[];
    bones[bone] ??= {};
    if (path === "rotation" && Array.isArray(v) && v.length >= 4) {
      bones[bone].rotation = { x: v[0]!, y: v[1]!, z: v[2]!, w: v[3]! };
    } else if (path === "translation" && Array.isArray(v) && v.length >= 3) {
      bones[bone].position = { x: v[0]!, y: v[1]!, z: v[2]! };
    }
  }
  return { bones } as AnimationPose;
}

/** Quat object → tuple. */
function quatTuple(q: { x: number; y: number; z: number; w: number } | undefined): Quat {
  return q ? [q.x, q.y, q.z, q.w] : IDENTITY;
}

/**
 * Retarget a standard-library source pose onto the inferred rig, then collapse the result back to
 * the CANONICAL bone names so the FK rest skeleton can be driven. `retargetHumanoidPose` keys the
 * output by the TARGET rig's node names; we ask for `includeSemanticBoneNames` so the canonical
 * bone keys are also present, and read those directly.
 */
function retargetToCanonical(
  sourcePose: AnimationPose,
  map: ReturnType<typeof createHumanoidRetargetingMap>
): { rotations: Partial<Record<HumanoidBoneName, Quat>>; hipsOffset: Vec3 } {
  const retargeted = retargetHumanoidPose(sourcePose, map, { includeSemanticBoneNames: true });
  const rotations: Partial<Record<HumanoidBoneName, Quat>> = {};
  let hipsOffset: Vec3 = [0, 0, 0];
  for (const bone of HUMANOID_BONES) {
    const t: AnimationPoseTransform | undefined = retargeted.bones[bone];
    if (!t) continue; // bone didn't map onto this rig — leave it at rest (a sparse rig stays sparse)
    if (t.rotation) rotations[bone] = quatTuple(t.rotation);
    if (bone === "hips" && t.position) hipsOffset = [t.position.x, t.position.y, t.position.z];
  }
  return { rotations, hipsOffset };
}

// ------------------------------------------------------------------------------------------------
// Failure-signature checks on FK world positions.
// ------------------------------------------------------------------------------------------------

function isFinite3(v: Vec3): boolean {
  return Number.isFinite(v[0]) && Number.isFinite(v[1]) && Number.isFinite(v[2]);
}

function magnitude(v: Vec3): number {
  return Math.hypot(v[0], v[1], v[2]);
}

export type FkFailureSignature = "legs-collapsed" | "arms-sagging" | "bone-exploded" | "bone-nan";

export interface FkFailure {
  readonly signature: FkFailureSignature;
  readonly detail: string;
}

/**
 * Inspect a single FK frame for the failure signatures we saw on broken downloads. Returns every
 * failure found (empty ⇒ this frame is clean). Thresholds are deliberately generous — this is a
 * pre-filter that should only reject the OBVIOUSLY broken, never a borderline-but-renderable rig.
 */
export function checkFrame(
  world: Record<HumanoidBoneName, Vec3>,
  mapped: Set<HumanoidBoneName>
): FkFailure[] {
  const failures: FkFailure[] = [];

  // NaN / explosion: any non-finite or absurdly-far bone (a healthy ~1.8m human stays well under 5m).
  for (const bone of Object.keys(world) as HumanoidBoneName[]) {
    const p = world[bone];
    if (!isFinite3(p)) {
      failures.push({ signature: "bone-nan", detail: `${bone} is non-finite (${p.join(", ")})` });
      continue;
    }
    if (magnitude(p) > 5) {
      failures.push({ signature: "bone-exploded", detail: `${bone} flew to |p|=${magnitude(p).toFixed(2)}m (>5m)` });
    }
  }
  if (failures.length > 0) return failures; // explosion dominates — don't bother with the geometry checks

  const hipY = world.hips[1];

  // Legs collapsed: a foot ends up at or ABOVE the hips (a standing human's feet are ~0.9m below).
  // Only meaningful when the foot bone actually mapped (an unmapped foot stays at rest = below hips).
  for (const foot of ["leftFoot", "rightFoot"] as const) {
    if (!mapped.has(foot)) continue;
    const footY = world[foot][1];
    if (footY > hipY - 0.1) {
      failures.push({
        signature: "legs-collapsed",
        detail: `${foot} Y=${footY.toFixed(2)} is not below hips Y=${hipY.toFixed(2)} (leg folded up)`
      });
    }
  }

  // Arms sagging / hands at the floor: a hand should sit roughly between knee and shoulder height.
  // Flag a hand that drops to near the floor (Y < 0.2m) — the "arms dragging on the ground" look.
  for (const hand of ["leftHand", "rightHand"] as const) {
    if (!mapped.has(hand)) continue;
    const handY = world[hand][1];
    if (handY < 0.2) {
      failures.push({
        signature: "arms-sagging",
        detail: `${hand} Y=${handY.toFixed(2)} near the floor (<0.2m — arm sagging/dragging)`
      });
    }
  }

  return failures;
}

// ------------------------------------------------------------------------------------------------
// Per-GLB validation.
// ------------------------------------------------------------------------------------------------

/** Sample times (seconds) across each clip — start, two beats in, near the end. */
const SAMPLE_TIMES = [0, 0.3, 0.6, 0.9, 1.2, 1.6];
const FK_CLIPS = ["talk", "walk"] as const;

export interface FkClipResult {
  readonly clip: string;
  readonly pass: boolean;
  readonly failures: readonly FkFailure[];
}

export interface Verdict {
  readonly file: string;
  readonly bytes: number;
  readonly parsed: boolean;
  readonly jointCount: number;
  readonly clips: readonly string[];
  // --- rig grade ---
  readonly rigGrade: RigGrade | null;
  readonly mappedBoneCount: number;
  readonly capabilities: { hasLegs: boolean; hasKnees: boolean; hasAnkles: boolean; hasFeet: boolean } | null;
  readonly gradeReasons: readonly string[];
  // --- retarget coverage ---
  readonly retargetCoverage: number;
  readonly retargetRequiredCoverage: number;
  readonly retargetingPoor: boolean;
  // --- FK proxy ---
  readonly fkPass: boolean;
  readonly fkClips: readonly FkClipResult[];
  readonly fkSignatures: readonly string[];
  // --- overall ---
  readonly verdict: "PASS" | "FAIL" | "UNPARSEABLE";
  readonly notes: readonly string[];
}

export interface FkProxyResult {
  readonly fkPass: boolean;
  readonly fkClips: readonly FkClipResult[];
  readonly signatures: readonly string[];
  /** Canonical bones that mapped onto the rig (drives which failure checks are meaningful). */
  readonly mapped: ReadonlySet<HumanoidBoneName>;
}

/**
 * Run the TALK + WALK FK proxy for an inferred rig built from `nodeNames`. Sampled across several
 * beats; every frame is checked for the failure signatures (collapsed legs / sagging arms / NaN /
 * exploded bones). Exposed (with {@link validateGlb}) so the unit-graded probe can drive it on both
 * a clean canonical skeleton and deliberately-broken inputs without touching the filesystem.
 */
export function runFkProxy(nodeNames: readonly string[]): FkProxyResult {
  const inferred = inferHumanoidRig(nodeNames, { id: "hifi-fk-proxy" });
  const mapped = new Set<HumanoidBoneName>(
    HUMANOID_BONES.filter((bone) => {
      const b = inferred.bones[bone];
      return Boolean(b && typeof b.name === "string" && b.name.length > 0);
    })
  );
  const map = createHumanoidRetargetingMap(STANDARD_LIBRARY_RIG, inferred, { minRequiredCoverage: 0 });
  const fkClips: FkClipResult[] = [];
  const signatures = new Set<string>();
  for (const clipId of FK_CLIPS) {
    const clipFailures: FkFailure[] = [];
    for (const t of SAMPLE_TIMES) {
      const source = sampleStandardPose(clipId, t);
      const { rotations, hipsOffset } = retargetToCanonical(source, map);
      const world = solveWorld(rotations, hipsOffset);
      for (const f of checkFrame(world, mapped)) {
        clipFailures.push(f);
        signatures.add(f.signature);
      }
    }
    const unique = new Map<string, FkFailure>();
    for (const f of clipFailures) if (!unique.has(f.signature)) unique.set(f.signature, f);
    fkClips.push({ clip: clipId, pass: clipFailures.length === 0, failures: [...unique.values()] });
  }
  return { fkPass: fkClips.every((c) => c.pass), fkClips, signatures: [...signatures], mapped };
}

export function validateGlb(absPath: string): Verdict {
  const file = relative(TEMPLATE_DIR, absPath);
  const buf = readFileSync(absPath);
  const bytes = buf.length;
  const json = parseGlbJson(buf);

  if (!json) {
    return {
      file, bytes, parsed: false, jointCount: 0, clips: [],
      rigGrade: null, mappedBoneCount: 0, capabilities: null, gradeReasons: [],
      retargetCoverage: 0, retargetRequiredCoverage: 0, retargetingPoor: true,
      fkPass: false, fkClips: [], fkSignatures: [],
      verdict: "UNPARSEABLE", notes: ["not a binary glTF (.glb)"]
    };
  }

  const names = jointNodeNames(json);
  const clips = (json.animations ?? []).map((a) => a.name).filter((n): n is string => typeof n === "string");
  const inferred: HumanoidRigDefinition = inferHumanoidRig(names, { id: `hifi:${file}`, name: file });
  const rigReport = gradeRig(inferred);

  // Retarget map: STANDARD library rig → this character's inferred rig. minRequiredCoverage at 0 so
  // we always get a map back (we report coverage ourselves rather than letting it gate to !ok).
  const map = createHumanoidRetargetingMap(STANDARD_LIBRARY_RIG, inferred, { minRequiredCoverage: 0 });
  const retargetingPoor = map.coverage < POOR_COVERAGE_THRESHOLD;

  // FK proxy across talk + walk (shared with the unit-graded probe via runFkProxy).
  const { fkPass, fkClips, signatures, mapped } = runFkProxy(names);

  const notes: string[] = [];
  if (rigReport.grade === "D") notes.push("rig graded D — not suitable for body acting (refuse).");
  if (retargetingPoor) {
    notes.push(`retargeting will be poor — body acting won't transfer (coverage ${(map.coverage * 100).toFixed(0)}% < ${POOR_COVERAGE_THRESHOLD * 100}%).`);
  }
  if (!rigReport.hasFeet && !mapped.has("leftFoot") && !mapped.has("rightFoot")) {
    notes.push("no feet mapped — locomotion / standing pose can't be validated by FK.");
  }
  if (!fkPass) notes.push(`FK proxy detected: ${[...signatures].join(", ")}.`);

  // Overall verdict. UNPARSEABLE handled above. A clean rig is one that grades C-or-better AND
  // passes the FK proxy. (FK pass is necessary, NOT sufficient — see the render warning.)
  const verdict: Verdict["verdict"] =
    rigReport.grade === "D" ? "FAIL" : fkPass && !retargetingPoor ? "PASS" : "FAIL";

  return {
    file, bytes, parsed: true, jointCount: names.length, clips,
    rigGrade: rigReport.grade,
    mappedBoneCount: rigReport.mappedBoneCount,
    capabilities: {
      hasLegs: rigReport.hasLegs, hasKnees: rigReport.hasKnees,
      hasAnkles: rigReport.hasAnkles, hasFeet: rigReport.hasFeet
    },
    gradeReasons: rigReport.reasons,
    retargetCoverage: +map.coverage.toFixed(3),
    retargetRequiredCoverage: +map.requiredCoverage.toFixed(3),
    retargetingPoor,
    fkPass, fkClips, fkSignatures: [...signatures],
    verdict, notes
  };
}

// ------------------------------------------------------------------------------------------------
// Discovery + CLI.
// ------------------------------------------------------------------------------------------------

/** Recursively collect every .glb under `dir` (hifi-cast/ has nested rpm/ + quaternius/ subdirs). */
function collectGlbs(dir: string): string[] {
  if (!existsSync(dir)) return [];
  const out: string[] = [];
  for (const entry of readdirSync(dir)) {
    const p = resolve(dir, entry);
    const st = statSync(p);
    if (st.isDirectory()) out.push(...collectGlbs(p));
    else if (entry.toLowerCase().endsWith(".glb")) out.push(p);
  }
  return out.sort();
}

function discoverTargets(): string[] {
  const targets = collectGlbs(HIFI_DIR);
  for (const name of COMPARISON_GLBS) {
    const p = resolve(AURA_ASSETS_DIR, name);
    if (existsSync(p)) targets.push(p);
  }
  return targets;
}

function printWarning(): void {
  console.error("");
  console.error("  ┌──────────────────────────────────────────────────────────────────────────┐");
  console.error("  │  ⚠  FK PRE-FILTER ONLY — NOT A RENDER.                                      │");
  console.error("  │  A PASS here means the rig survived a fast forward-kinematics sanity pass   │");
  console.error("  │  (no collapsed legs / sagging arms / exploded or NaN bones) on a canonical  │");
  console.error("  │  rest skeleton. It does NOT skin the real mesh and cannot see texture,      │");
  console.error("  │  weighting, or bind-pose problems. FINAL ACCEPTANCE STILL REQUIRES A REAL   │");
  console.error("  │  GPU RENDER + VISUAL REVIEW. Use this only to reject obviously-broken rigs  │");
  console.error("  │  before spending a render.                                                 │");
  console.error("  └──────────────────────────────────────────────────────────────────────────┘");
  console.error("");
}

function main(): void {
  const argv = process.argv.slice(2).filter((a) => !a.startsWith("--"));
  const targets = argv.length > 0 ? argv.map((a) => resolve(process.cwd(), a)) : discoverTargets();

  printWarning();

  if (targets.length === 0) {
    console.error(`  no GLBs found under ${relative(process.cwd(), HIFI_DIR)} (and no comparison assets present).`);
  }

  const verdicts: Verdict[] = [];
  for (const t of targets) {
    if (!existsSync(t)) {
      console.error(`  SKIP (missing): ${t}`);
      continue;
    }
    let v: Verdict;
    try {
      v = validateGlb(t);
    } catch (err) {
      console.error(`  ERROR validating ${t}: ${(err as Error).message}`);
      continue;
    }
    verdicts.push(v);
    const cov = `${(v.retargetCoverage * 100).toFixed(0)}%`;
    const cap = v.capabilities
      ? `legs=${v.capabilities.hasLegs ? "Y" : "n"} knees=${v.capabilities.hasKnees ? "Y" : "n"} feet=${v.capabilities.hasFeet ? "Y" : "n"}`
      : "—";
    console.error(
      `  ${v.verdict.padEnd(11)} ${v.file}\n` +
      `      grade=${v.rigGrade ?? "—"} mappedBones=${v.mappedBoneCount}/${HUMANOID_BONES.length} ${cap} ` +
      `retargetCoverage=${cov}${v.retargetingPoor ? " (POOR)" : ""} joints=${v.jointCount} clips=${v.clips.length}\n` +
      `      FK ${v.fkPass ? "PASS" : "FAIL"}${v.fkSignatures.length ? ` [${v.fkSignatures.join(", ")}]` : ""}` +
      (v.notes.length ? `\n      notes: ${v.notes.join(" ")}` : "")
    );
  }

  const report = {
    generatedAt: new Date().toISOString(),
    note:
      "FK PRE-FILTER ONLY — NOT A RENDER. A PASS means the rig survived a canonical forward-" +
      "kinematics sanity pass (no collapsed legs / sagging arms / exploded or NaN bones). It does " +
      "NOT skin the real mesh and cannot see texture/weight/bind-pose problems. Final acceptance " +
      "requires a real GPU render + visual review.",
    poorCoverageThreshold: POOR_COVERAGE_THRESHOLD,
    fkClips: FK_CLIPS,
    sampleTimes: SAMPLE_TIMES,
    count: verdicts.length,
    passCount: verdicts.filter((v) => v.verdict === "PASS").length,
    failCount: verdicts.filter((v) => v.verdict !== "PASS").length,
    verdicts
  };
  mkdirSync(REPORT_DIR, { recursive: true });
  writeFileSync(REPORT_FILE, `${JSON.stringify(report, null, 2)}\n`);
  console.error(`\n  wrote ${relative(process.cwd(), REPORT_FILE)} (${verdicts.length} verdict(s), ${report.passCount} PASS / ${report.failCount} FAIL)`);
  printWarning();
}

// Run only when invoked directly (not when imported by the unit-graded probe / other tooling).
if (process.argv[1] && /hifi-cast-validate\.(ts|js)$/.test(process.argv[1])) {
  main();
}