"""Visual comparison of reconstructed meshes vs ground truth for held-out cases.

Produces, per case, a PNG with GT (grey) and prediction (tooth=blue, canal=red)
overlaid, plus an error-colored view (vertices colored by distance to GT).

    python -m toothcanal.compare --config configs/default.yaml
    python -m toothcanal.compare --config configs/default.yaml --case 031-
"""
import os, glob, argparse
import numpy as np
import torch
from .utils import load_config, ensure_dir
from .splits import make_split
from .models import ImplicitNet
from .infer import reconstruct_instance
from .evaluate import gt_meshes


def _load_net(cfg, dev):
    ckpt = torch.load(os.path.join(cfg["paths"]["out_dir"], "stage2.pt"),
                      map_location=dev)
    n_lat = ckpt["model"]["latents.weight"].shape[0]

    class _N(ImplicitNet):
        def __init__(s):
            super().__init__(n_lat, cfg)
    net = _N().to(dev)
    net.load_state_dict(ckpt["model"]); net.eval()
    return net


def _nearest_dist(pred, gt, n=8000):
    from scipy.spatial import cKDTree
    import trimesh
    pp, _ = trimesh.sample.sample_surface(pred, n)
    gp, _ = trimesh.sample.sample_surface(gt, n)
    d, _ = cKDTree(gp).query(pp)
    return pp, d


def render_case(net, d, ids, cfg, dev, out_png, do_tto=True, max_teeth=None):
    import matplotlib
    matplotlib.use("Agg")
    import matplotlib.pyplot as plt
    from mpl_toolkits.mplot3d.art3d import Poly3DCollection

    fig = plt.figure(figsize=(16, 6))
    axO = fig.add_subplot(131, projection="3d"); axO.set_title("Overlay (grey=GT)")
    axP = fig.add_subplot(132, projection="3d"); axP.set_title("Prediction")
    axE = fig.add_subplot(133, projection="3d"); axE.set_title("Error (mm, vs GT)")

    allv = []
    errs = []
    teeth = ids if max_teeth is None else ids[:max_teeth]
    for iid in teeth:
        rec = reconstruct_instance(net, d, iid, cfg, dev, do_tto=do_tto)
        gt_t, gt_c = gt_meshes(d, iid, cfg)
        if rec is None or rec["tooth"] is None or gt_t is None:
            continue
        # place meshes in world by ROI origin so all teeth sit in the arch
        off = rec["roi"]["lo_world_mm"]
        pt = rec["tooth"].copy(); pt.vertices += off
        gt = gt_t.copy(); gt.vertices += off
        allv.append(pt.vertices)
        # GT grey
        axO.add_collection3d(Poly3DCollection(gt.vertices[gt.faces], facecolor=(.6,.6,.6),
                                              alpha=.25, linewidths=0))
        axO.add_collection3d(Poly3DCollection(pt.vertices[pt.faces], facecolor=(.2,.4,.8),
                                              alpha=.5, linewidths=0))
        axP.add_collection3d(Poly3DCollection(pt.vertices[pt.faces], facecolor=(.2,.4,.8),
                                              alpha=.7, linewidths=0))
        if rec["canal"] is not None:
            pc = rec["canal"].copy(); pc.vertices += off
            axP.add_collection3d(Poly3DCollection(pc.vertices[pc.faces], facecolor=(.85,.15,.15),
                                                  alpha=.95, linewidths=0))
            axO.add_collection3d(Poly3DCollection(pc.vertices[pc.faces], facecolor=(.85,.15,.15),
                                                  alpha=.8, linewidths=0))
        # error coloring
        pp, dd = _nearest_dist(pt, gt)
        errs.append(dd)
        axE.scatter(pp[:,0], pp[:,1], pp[:,2], c=dd, cmap="jet", s=1, vmin=0, vmax=1.0)

    if not allv:
        plt.close(fig); return False
    V = np.vstack(allv)
    for ax in (axO, axP, axE):
        ax.set_xlim(V[:,0].min(), V[:,0].max())
        ax.set_ylim(V[:,1].min(), V[:,1].max())
        ax.set_zlim(V[:,2].min(), V[:,2].max())
        ax.set_axis_off(); ax.view_init(elev=15, azim=-70)
    if errs:
        e = np.concatenate(errs)
        fig.suptitle(f"mean surface error = {e.mean():.3f} mm   "
                     f"(blue<{0.0:.1f}  red>{1.0:.1f} mm)", fontsize=12)
    fig.savefig(out_png, dpi=120, bbox_inches="tight"); plt.close(fig)
    return True


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--config", default="configs/default.yaml")
    ap.add_argument("--case", default=None)
    ap.add_argument("--no_tto", action="store_true")
    ap.add_argument("--max_teeth", type=int, default=None,
                    help="limit teeth per case for a faster preview")
    args = ap.parse_args()
    cfg = load_config(args.config)
    dev = "cuda" if torch.cuda.is_available() else "cpu"
    net = _load_net(cfg, dev)

    _, test = make_split(cfg["paths"]["proc_dir"], cfg)
    cases = [args.case] if args.case else test
    out_dir = ensure_dir(os.path.join(cfg["paths"]["out_dir"], "compare"))
    for cid in cases:
        d = dict(np.load(os.path.join(cfg["paths"]["proc_dir"], f"{cid}.npz")))
        ids = [int(v) for v in np.unique(d["inst"]) if v > 0]
        out = os.path.join(out_dir, f"{cid}_compare.png")
        ok = render_case(net, d, ids, cfg, dev, out, do_tto=not args.no_tto,
                         max_teeth=args.max_teeth)
        print(f"[compare] {cid}: {'wrote '+out if ok else 'no meshes'}")


if __name__ == "__main__":
    main()