"""Shape checks on the final scenes of the leaderboard episodes (medium effort), from held-out silhouettes.

  uv run python scripts/shape_checks.py          -> results/shape_checks.json

* Mirror test (build tasks): silhouette IoU of the final scene on the 8 held-out views, as built and after mirroring
  the Gaussian centers front to back (y -> -y), plus three other axis changes. A build that follows the object's real
  layout loses overlap when mirrored; a rough blob fits the mirrored object about as well as the real one, and no
  model gains from an axis change (no systematic axis error).
* Size (all tasks): area ratio = rendered pixels with alpha > 0.5 over true silhouette pixels, summed over the
  held-out views. 1 = right size, below 1 = too small or too transparent.
"""
import argparse
import json
import statistics as st
from collections import defaultdict
from pathlib import Path

import pyarrow.parquet as pq
import torch

from splatbench.render import render
from splatbench.scene import Scene

ap = argparse.ArgumentParser()
ap.add_argument("--data", default="data")
ap.add_argument("--out", default="results/shape_checks.json")
ap.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
a = ap.parse_args()
dev = a.device

TRANSFORMS = {"as_built": torch.eye(3), "mirror_x": torch.diag(torch.tensor([-1.0, 1, 1])),
              "mirror_y": torch.diag(torch.tensor([1.0, -1, 1])), "rotate_180_z": torch.diag(torch.tensor([-1.0, -1, 1])),
              "swap_xy": torch.tensor([[0.0, 1, 0], [1, 0, 0], [0, 0, 1]])}
rows = pq.read_table(Path(a.data) / "episodes" / "medium_effort.parquet",
                     columns=["episode_id", "model", "model_name", "task_id", "kind", "final_gaussians"]).to_pylist()
scenes = {}
iou, area = defaultdict(lambda: defaultdict(list)), defaultdict(list)
for e in rows:
    G = e["final_gaussians"]
    scene = e["task_id"].split("__")[0]
    if scene not in scenes:
        scenes[scene] = Scene.load(Path(a.data) / "bench" / "scenes" / scene)
    if not G:
        continue
    cams, _, masks = scenes[scene].torch_views("test", dev)
    f = lambda k: torch.tensor([g[k] for g in G], dtype=torch.float32, device=dev)
    gs = dict(means=f("pos"), scales=f("scale"), quats=f("quat"), colors=f("color"), opacities=f("opacity"))
    mine = truth = 0.0
    for cam, m in zip(cams, masks):
        with torch.no_grad():
            al = render(gs, cam)["alpha"]
        mine += float((al > 0.5).sum())
        truth += float((m > 0.5).sum())
    area[e["model"]].append(mine / max(truth, 1.0))
    if e["kind"] != "build":
        continue
    for name, M in TRANSFORMS.items():
        g2 = dict(gs, means=gs["means"] @ M.to(dev).T)
        inter = union = 0.0
        for cam, m in zip(cams, masks):
            with torch.no_grad():
                al = render(g2, cam)["alpha"] > 0.5
            b = m > 0.5
            inter += float((al & b).sum())
            union += float((al | b).sum())
        iou[e["model"]][name].append(inter / max(union, 1.0))

names = {e["model"]: e["model_name"] for e in rows}
out = {}
for m in sorted(iou, key=lambda m: -st.mean(iou[m]["as_built"])):
    r = area[m]
    out[m] = dict(
        heldout_iou={k: round(st.mean(v), 3) for k, v in iou[m].items()},
        mirror_drop_points=round(100 * (st.mean(iou[m]["as_built"]) - st.mean(iou[m]["mirror_y"])), 1),
        median_area_ratio=round(st.median(r), 2), share_too_small=round(sum(x < 0.7 for x in r) / len(r), 2),
        share_too_big=round(sum(x > 1.3 for x in r) / len(r), 2))
    o = out[m]
    print(f"{names[m]:18s} IoU as built {o['heldout_iou']['as_built']:.3f}, mirrored {o['heldout_iou']['mirror_y']:.3f} "
          f"(drop {o['mirror_drop_points']:.1f} points) | median area ratio {o['median_area_ratio']:.2f}, "
          f"too small {o['share_too_small']:.0%}")
Path(a.out).parent.mkdir(parents=True, exist_ok=True)
Path(a.out).write_text(json.dumps(out, indent=1))