"""0420 5fps protocol eval for ONE checkpoint.

Loads the model once, runs the fixed anchor manifest's 10s recursive AR rollouts
on hanoi_0420_balanced_5fps (frame_interval=1), and scores ROI + whole-frame
PSNR/SSIM/LPIPS at cumulative 1s/3s/6s/10s prefixes. Writes protocol_metrics.json.
"""
import argparse, json, sys, time, warnings
from pathlib import Path
import numpy as np
import torch

warnings.filterwarnings("ignore")
ROOT = Path(__file__).resolve().parents[1]
if str(ROOT) not in sys.path:
    sys.path.insert(0, str(ROOT))

from graphwm.config_graph import GraphWMArgs
from graphwm.cli_graph import load_graph_model_config_sidecar
from graphwm.models.ctrl_world_graph import CtrlWorldGraph
from graphwm.original_ctrl_world import import_original_modules
from scripts.eval_graph_video import decode_latents_to_video
from scripts.rollout_graph_episode import _episode_frame_ids, _make_graph_batch, _load_rgb_batch, _spaced_window
from skimage.metrics import structural_similarity as compute_ssim
import lpips

DATA_ROOT = Path("/workspace/gnn_data/hanoi_0420_balanced_5fps")
MANIFEST = DATA_ROOT / "eval_anchor_manifest.json"
ROI_X = (0.25, 0.75)
ROI_Y = (0.20, 0.80)
PREFIXES = {"1s": 5, "3s": 15, "6s": 30, "10s": 50}


def log(m): print(f"[{time.strftime('%H:%M:%S')}] {m}", flush=True)


def run_window(model, pipeline_cls, episode_dir, all_frame_ids, start, args, seed):
    """Recursive AR rollout for one window; returns generated (pred, gt) uint8 [50,H,W,3]."""
    torch.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)
    device = model.unet.device
    resize_hw = (args.height, args.width)
    fi = args.hanoi_frame_interval
    max_output = args.num_history + 1 + PREFIXES["10s"]  # 7 + 50 = 57
    new_per = args.num_frames - 1
    max_off = len(all_frame_ids) - 1 - new_per * fi

    initial_frame_ids = [all_frame_ids[start + i * fi] for i in range(args.num_history + 1)]
    with torch.no_grad():
        initial_rgb = _load_rgb_batch(episode_dir, initial_frame_ids, resize_hw).to(device)
        timeline_latents = [l.detach().clone() for l in model.encode_rgb_to_latents(initial_rgb)[0]]
    timeline_frame_ids = list(initial_frame_ids)
    cur = start + args.num_history * fi

    with torch.no_grad():
        while len(timeline_frame_ids) < max_output and cur <= max_off:
            gids = _spaced_window(all_frame_ids, cur, before=args.num_history, after=args.num_frames, interval=fi)
            gb = _make_graph_batch(episode_dir, args.hanoi_graph_dir_name, gids)
            gb["graph_seq"] = [g.to(device) for g in gb["graph_seq"]]
            gh = model.encode_graph_condition(gb).to(device=device, dtype=model.unet.dtype)
            history = torch.stack(timeline_latents[-(args.num_history + 1):-1], dim=0).unsqueeze(0)
            current_latent = timeline_latents[-1].unsqueeze(0)
            _, pred = pipeline_cls.__call__(
                model.pipeline, image=current_latent, text=gh, width=args.width, height=args.height,
                num_frames=args.num_frames, history=history, num_inference_steps=args.num_inference_steps,
                decode_chunk_size=args.decode_chunk_size, max_guidance_scale=args.guidance_scale,
                fps=args.fps, motion_bucket_id=args.motion_bucket_id, output_type="latent",
                return_dict=False, frame_level_cond=args.frame_level_cond, his_cond_zero=args.his_cond_zero)
            ac = min(new_per, max_output - len(timeline_frame_ids))
            for l in pred[0, 1:1 + ac]:
                timeline_latents.append(l.detach().clone())
            timeline_frame_ids.extend(all_frame_ids[cur + i * fi] for i in range(1, ac + 1))
            cur += new_per * fi

    rollout_latents = torch.stack(timeline_latents, dim=0).unsqueeze(0)
    pred_video = decode_latents_to_video(model.pipeline, rollout_latents, args.decode_chunk_size)[0]
    gt_rgb = _load_rgb_batch(episode_dir, timeline_frame_ids, resize_hw)[0]
    gt_video = (gt_rgb.permute(0, 2, 3, 1).clamp(0, 1) * 255).byte().cpu().numpy()
    gs = args.num_history + 1
    return pred_video[gs:], gt_video[gs:], list(timeline_frame_ids[gs:])


def crop_roi(v):
    T, H, W, _ = v.shape
    x0, x1 = int(W * ROI_X[0]), int(W * ROI_X[1])
    y0, y1 = int(H * ROI_Y[0]), int(H * ROI_Y[1])
    return v[:, y0:y1, x0:x1, :]


def per_frame_metrics(pred, gt, lnet, device):
    pf = pred.astype(np.float32) / 255.0
    gf = gt.astype(np.float32) / 255.0
    mse = ((pf - gf) ** 2).mean(axis=(1, 2, 3))
    psnr = [float("inf") if m == 0 else float(10.0 * np.log10(1.0 / m)) for m in mse]
    ssim_l = [float(compute_ssim(gt[i], pred[i], channel_axis=2, data_range=255)) for i in range(len(pred))]
    with torch.no_grad():
        pt = torch.from_numpy(pred).permute(0, 3, 1, 2).float().to(device) / 127.5 - 1
        gtt = torch.from_numpy(gt).permute(0, 3, 1, 2).float().to(device) / 127.5 - 1
        lp = lnet(pt, gtt).detach().cpu().numpy().reshape(-1)
    return psnr, ssim_l, [float(x) for x in lp]


def prefix_agg(arr):
    out = {}
    for name, k in PREFIXES.items():
        sl = [v for v in arr[:k] if np.isfinite(v)]
        out[name] = float(np.mean(sl)) if sl else float("inf")
    return out


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--ckpt-path", type=Path, required=True)
    ap.add_argument("--manifest", type=Path, default=MANIFEST)
    ap.add_argument("--episodes", nargs="*", default=None, help="subset; default all in manifest")
    ap.add_argument("--out-dir", type=Path, default=Path("/workspace/Ctrl-World-Graph/eval_5fps_protocol"))
    ap.add_argument("--seed", type=int, default=1234)
    ap.add_argument("--frame-interval", type=int, default=1)
    ap.add_argument("--save-preds", type=int, default=1, help="1=save predicted frames (compressed npz) per window for later re-eval")
    cli = ap.parse_args()

    args = GraphWMArgs()
    args.ckpt_path = str(cli.ckpt_path)
    load_graph_model_config_sidecar(args, args.ckpt_path)
    args.hanoi_frame_interval = cli.frame_interval
    args.num_workers = 0

    manifest = json.loads(cli.manifest.read_text())
    episodes = cli.episodes or list(manifest["episodes"].keys())

    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model = CtrlWorldGraph(args).to(device)
    model.load_state_dict(torch.load(args.ckpt_path, map_location="cpu"), strict=False)
    model.eval()
    pipeline_cls = import_original_modules(args.ctrl_world_root)["CtrlWorldDiffusionPipeline"]
    lnet = lpips.LPIPS(net="alex").to(device).eval()

    ckpt_stem = Path(args.ckpt_path).stem
    variant = Path(args.ckpt_path).parent.name
    out_dir = cli.out_dir / variant / ckpt_stem
    out_dir.mkdir(parents=True, exist_ok=True)
    log(f"model={variant}/{ckpt_stem} backbone={args.graph_backbone} device={device}")

    per_window = []
    t_start = time.time()
    nwin_total = sum(len(manifest["episodes"][e]["windows"]) for e in episodes)
    done = 0
    for ep in episodes:
        episode_dir = DATA_ROOT / ep
        all_frame_ids = _episode_frame_ids(episode_dir, args.hanoi_graph_dir_name)
        for w in manifest["episodes"][ep]["windows"]:
            s = w["start_frame_offset"]
            pred, gt, gen_ids = run_window(model, pipeline_cls, episode_dir, all_frame_ids, s, args, cli.seed)
            assert pred.shape[0] == PREFIXES["10s"], f"{ep} start {s}: {pred.shape[0]} != 50 frames"
            pred_file = ""
            if cli.save_preds:
                preds_dir = out_dir / "preds" / ep
                preds_dir.mkdir(parents=True, exist_ok=True)
                pred_file = str(preds_dir / f"start{s:04d}.npz")
                np.savez_compressed(pred_file, pred=pred.astype(np.uint8), frame_ids=np.array(gen_ids, dtype=np.int64))
            rp, rs, rl = per_frame_metrics(crop_roi(pred), crop_roi(gt), lnet, device)
            wp, ws, wl = per_frame_metrics(pred, gt, lnet, device)
            per_window.append({
                "episode": ep, "start_frame_offset": s, "anchor_frame": w["anchor_frame"],
                "horizon_frame_ids": gen_ids, "pred_file": pred_file,
                "roi": {"psnr": prefix_agg(rp), "ssim": prefix_agg(rs), "lpips": prefix_agg(rl)},
                "whole": {"psnr": prefix_agg(wp), "ssim": prefix_agg(ws), "lpips": prefix_agg(wl)},
            })
            done += 1
            if done % 10 == 0 or done == nwin_total:
                log(f"  {done}/{nwin_total} windows  ({(time.time()-t_start)/60:.1f} min)")
                (out_dir / "protocol_metrics.partial.json").write_text(json.dumps(per_window))

    # aggregate: mean over windows, per region/metric/prefix
    def agg(region, metric):
        return {p: float(np.mean([w[region][metric][p] for w in per_window
                                  if np.isfinite(w[region][metric][p])])) for p in PREFIXES}
    aggregate = {region: {metric: agg(region, metric) for metric in ("psnr", "ssim", "lpips")}
                 for region in ("roi", "whole")}
    result = {
        "model": variant, "checkpoint": ckpt_stem, "backbone": args.graph_backbone,
        "seed": cli.seed, "n_windows": len(per_window), "episodes": episodes,
        "roi_box_xyxy_at_320x192": [int(320 * ROI_X[0]), int(192 * ROI_Y[0]), int(320 * ROI_X[1]), int(192 * ROI_Y[1])],
        "aggregate": aggregate, "per_window": per_window,
    }
    (out_dir / "protocol_metrics.json").write_text(json.dumps(result, indent=2))
    (out_dir / "protocol_metrics.partial.json").unlink(missing_ok=True)
    log(f"DONE {variant}/{ckpt_stem}: {len(per_window)} windows in {(time.time()-t_start)/60:.1f} min")
    log(f"  ROI PSNR  1s/3s/6s/10s = " + "/".join(f"{aggregate['roi']['psnr'][p]:.2f}" for p in PREFIXES))
    log(f"  ROI SSIM  10s = {aggregate['roi']['ssim']['10s']:.4f}   ROI LPIPS 10s = {aggregate['roi']['lpips']['10s']:.4f}")
    print("saved=", out_dir / "protocol_metrics.json")


if __name__ == "__main__":
    main()