#!/usr/bin/env python3
"""Reconstruct all target rows from a Suite30 checkpoint and verify saved scores."""
from __future__ import annotations
import argparse
from pathlib import Path
import numpy as np
import pandas as pd
import torch
from suite25_data import load_fold_bundle
from suite30_utils import Standardizer,validate_suite29_reference
from suite30_data import matched_peer_placebo
from train_suite30 import make_loader,predict

def replay(checkpoint, scores_path, cache_dir=None, structured_dir=None, device="cpu"):
    ck=torch.load(checkpoint,map_location="cpu",weights_only=False)
    a=argparse.Namespace(**ck["args"])
    if cache_dir:a.cache_dir=cache_dir
    if structured_dir:a.structured_dir=structured_dir
    fold,seed,mode=int(ck["fold"]),int(ck["seed"]),ck["mode"]
    faculties=ck["faculties"]
    _,target,raw=load_fold_bundle(a.cache_dir,a.structured_dir,faculties,fold,ck["feature_names"])
    if list(raw)!=list(ck["feature_names"]):raise ValueError("Feature order mismatch")
    if tuple(target.current.shape)[1]!=ck["model_config"]["n_features"]:
        raise ValueError("Checkpoint feature dimension mismatch")
    df=pd.read_csv(scores_path,dtype={"faculty":str,"student_id":str,"course_id":str})
    validate_suite29_reference(df,target,fold,seed)
    prep=Standardizer.__new__(Standardizer)
    pr=ck["preprocessing"]
    prep.mean=np.asarray(pr["mean"],np.float32);prep.scale=np.asarray(pr["scale"],np.float32)
    prep.smean=float(pr["smean"]);prep.sscale=float(pr["sscale"])
    normalized=prep.apply(target)
    from suite30_model import JointPortfolioRisk
    dev=torch.device(device)
    net=JointPortfolioRisk(**ck["model_config"]).to(dev)
    net.load_state_dict(ck["model"],strict=True)
    ds,ld=make_loader(normalized,None,a,False)
    calibration=np.asarray(ck.get("calibration",np.zeros(len(faculties))),np.float32)
    p,aux=predict(net,ld,mode,dev,len(normalized.y),calibration=calibration)
    key="suite30_"+mode
    if key not in df:raise ValueError("Missing score column: "+key)
    expected=np.asarray(df[key],float)
    err=float(np.max(np.abs(p-expected)))
    print(f"[REPLAY] {key}: rows={len(p):,} maximum absolute error={err:.3g}",flush=True)
    if err>1e-6:raise AssertionError(f"Score mismatch: {err}")
    extra=[("no_attention","joint_no_attention_intervention"),
           ("no_context","joint_no_context_intervention")] if mode=="joint" else []
    if mode=="joint" and "suite30_joint_matched_placebo" in df:
        extra.append(("placebo","joint_matched_placebo"))
    for intervention,tag in extra:
        if intervention=="placebo":
            donor,_=matched_peer_placebo(normalized,seed+fold*100003,a.course_dim)
            _,ld2=make_loader(normalized,None,a,False,override=donor)
        else:ld2=ld
        q,_=predict(net,ld2,mode,dev,len(p),intervention=intervention,
                    calibration=calibration)
        col="suite30_"+tag
        if col not in df:raise ValueError("Missing intervention column "+col)
        e=float(np.max(np.abs(q-df[col].to_numpy(float))))
        print(f"[REPLAY] {col}: max absolute error={e:.3g}",flush=True)
        if e>1e-6:raise AssertionError(f"Intervention mismatch: {col} {e}")
    if mode=="joint" and "suite30_joint_raw_uncalibrated" in df:
        raw,_=predict(net,ld,mode,dev,len(p))
        err_raw=float(np.max(np.abs(raw-df["suite30_joint_raw_uncalibrated"].to_numpy(float))))
        print(f"[REPLAY] joint raw uncalibrated: error={err_raw:.3g}")
        if err_raw>1e-6:raise AssertionError("Raw calibration replay mismatch")
    print("[REPLAY PASS] Exact target key alignment + score reconstruction",flush=True)
    return err

if __name__=="__main__":
    p=argparse.ArgumentParser(description=__doc__)
    p.add_argument("--checkpoint",required=True)
    p.add_argument("--scores",required=True)
    p.add_argument("--cache-dir")
    p.add_argument("--structured-dir")
    p.add_argument("--device",default="cpu")
    a=p.parse_args()
    replay(a.checkpoint,a.scores,a.cache_dir,a.structured_dir,a.device)
