#!/usr/bin/env python
"""Score the 2x2 ablation arms for the B_07 cloth case, 4DCodeBench-style.

Metrics (all computed against the baked ground-truth cloth trajectory):
  chamfer_t    mean per-frame symmetric chamfer between sim and GT cloth point
               clouds, subsampled, averaged over frames (meters, lower better)
  dtw_com      DTW between the cloth center-of-mass trajectories (meters)
  bbox_iou_t   mean 3D IoU of the axis-aligned cloth bounding box per frame
  final_cham   chamfer at the last frame (did it end in the same place?)

Usage:
  python score_ablation.py --world work/B_07/world --runs work/B_07/ablation \
      --out work/B_07/ablation/metrics.json [--csv work/B_07/ablation/metrics.csv]
"""
import argparse
import csv
import json
from pathlib import Path

import numpy as np


def chamfer(a, b, n=2000, seed=0):
    rng = np.random.default_rng(seed)
    ai = rng.choice(len(a), min(n, len(a)), replace=False)
    bi = rng.choice(len(b), min(n, len(b)), replace=False)
    A, B = a[ai].astype(np.float64), b[bi].astype(np.float64)
    d_ab = ((A[:, None, :] - B[None, :, :]) ** 2).sum(-1)
    d1 = np.sqrt(d_ab.min(1))
    d2 = np.sqrt(((B[:, None, :] - A[None, :, :]) ** 2).sum(-1)).min(1)
    return float(0.5 * (d1.mean() + d2.mean()))


def dtw(a, b):
    n, m = len(a), len(b)
    D = np.full((n + 1, m + 1), np.inf)
    D[0, 0] = 0.0
    for i in range(1, n + 1):
        for j in range(1, m + 1):
            c = float(np.linalg.norm(a[i - 1] - b[j - 1]))
            D[i, j] = c + min(D[i - 1, j - 1], D[i, j - 1], D[i - 1, j])
    return float(D[n, m] / (n + m))


def bbox_iou(a, b):
    amin, amax = a.min(0), a.max(0)
    bmin, bmax = b.min(0), b.max(0)
    inter_min = np.maximum(amin, bmin)
    inter_max = np.minimum(amax, bmax)
    inter = np.clip(inter_max - inter_min, 0, None).prod()
    va = (amax - amin).prod()
    vb = (bmax - bmin).prod()
    union = va + vb - inter
    return float(inter / union) if union > 0 else 0.0


def score(world_dir, traj_dir, frame_stride=3):
    gt = np.load(Path(world_dir) / "dyn" / "Cloth.npz")["pos"].astype(np.float32)
    sim = np.load(Path(traj_dir) / "clothtraj.npz")["pos"].astype(np.float32)
    assert sim.shape == gt.shape, f"shape mismatch {sim.shape} vs {gt.shape}"
    F = gt.shape[0]
    frames = list(range(0, F, frame_stride))
    if frames[-1] != F - 1:
        frames.append(F - 1)
    ch = [chamfer(sim[i], gt[i], seed=i) for i in frames]
    gt_com = gt.mean(1)
    sim_com = sim.mean(1)
    iou = [bbox_iou(sim[i], gt[i]) for i in frames]
    return {
        "chamfer_t_m": round(float(np.mean(ch)), 4),
        "final_chamfer_m": round(ch[-1], 4),
        "dtw_com_m": round(dtw(sim_com, gt_com), 4),
        "bbox_iou_t": round(float(np.mean(iou)), 4),
    }


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--world", required=True)
    ap.add_argument("--runs", required=True, nargs="+")
    ap.add_argument("--names", required=True, nargs="+")
    ap.add_argument("--out", required=True)
    ap.add_argument("--csv", default=None)
    args = ap.parse_args()

    report = {}
    for name, run in zip(args.names, args.runs):
        try:
            report[name] = score(args.world, run)
        except Exception as e:
            report[name] = {"error": str(e)}
        print(name, json.dumps(report[name]))

    Path(args.out).write_text(json.dumps(report, indent=1))
    print(f"wrote {args.out}")

    if args.csv:
        keys = ["chamfer_t_m", "final_chamfer_m", "dtw_com_m", "bbox_iou_t"]
        with open(args.csv, "w", newline="") as f:
            w = csv.writer(f)
            w.writerow(["arm"] + keys)
            for name in args.names:
                r = report[name]
                w.writerow([name] + [r.get(k, "") for k in keys])
        print(f"wrote {args.csv}")


if __name__ == "__main__":
    main()