"""CPU-portable trusted-local checkpoints with exact schema validation."""
from __future__ import annotations
from s34_runtime import configure_cuda_workspace

configure_cuda_workspace()

from pathlib import Path
import torch
import numpy as np
from s34_data import json_hash
from s34_model import IPMVCL
from s34_preprocessing import Preprocessor
from s34_views import view_indices
from s34_training import predict_model


def save_checkpoint(path, result, metadata):
    model, pp = result["model"], result["preprocessor"]
    neural = isinstance(model, IPMVCL)
    names = pp.names if neural else metadata["feature_names"]
    payload = dict(format_version=1, kind="neural" if neural else "HGB",
                   feature_names=names, feature_schema_hash=json_hash(names), metadata=metadata,
                   selection=result["selection"])
    if neural:
        payload.update(state_dict={k: v.detach().cpu() for k, v in model.state_dict().items()},
                       model_config=model.config, arm=model.arm, manifest=result["manifest"],
                       preprocessing=pp.__dict__)
    else:
        payload["model"] = model
    Path(path).parent.mkdir(parents=True, exist_ok=True)
    torch.save(payload, path)


def load_checkpoint(path, device="cpu"):
    # Only load locally generated/trusted checkpoints; these include fitted preprocessing.
    checkpoint = torch.load(path, map_location="cpu", weights_only=False)
    if checkpoint.get("format_version") != 1:
        raise ValueError("Unsupported checkpoint format")
    if json_hash(checkpoint["feature_names"]) != checkpoint["feature_schema_hash"]:
        raise ValueError("Checkpoint feature schema hash mismatch")
    if checkpoint["kind"] == "HGB":
        return checkpoint, checkpoint["model"], None
    pp = Preprocessor(checkpoint["feature_names"])
    pp.__dict__.update(checkpoint["preprocessing"])
    views = view_indices(checkpoint["manifest"], pp.bundles)
    model = IPMVCL(pp.dimension, views, checkpoint["arm"], checkpoint["model_config"])
    model.load_state_dict(checkpoint["state_dict"], strict=True)
    model.to(device).eval()
    return checkpoint, model, pp


def replay_checkpoint(path, X, feature_names, device="cpu", batch_size=4096):
    checkpoint, model, pp = load_checkpoint(path, device)
    if list(feature_names) != checkpoint["feature_names"]:
        raise ValueError("Checkpoint feature schema/order mismatch")
    if checkpoint["kind"] == "HGB":
        return model.predict_proba(np.where(np.isfinite(X), X, np.nan))[:, 1]
    return predict_model(model, pp.transform(X), batch_size)


def main():
    import argparse
    import pandas as pd
    from s34_data import load_cell, sha256_file
    parser = argparse.ArgumentParser(description="Replay a completed cell on its exact canonical target rows.")
    for name in ("checkpoint", "canonical", "structured", "faculty", "output"):
        parser.add_argument("--"+name, required=True)
    parser.add_argument("--fold", required=True, type=int)
    args = parser.parse_args()
    checkpoint, _, _ = load_checkpoint(args.checkpoint)
    metadata = checkpoint["metadata"]
    if metadata.get("faculty") != args.faculty or metadata.get("fold") != args.fold:
        raise ValueError("Checkpoint faculty/fold mismatch")
    actual = dict(canonical=sha256_file(args.canonical), structured=sha256_file(args.structured))
    if metadata.get("source_sha256") != actual:
        raise ValueError("Checkpoint source hash mismatch")
    names = checkpoint["feature_names"]
    if len(names) < 17 or any(not n.startswith("course::") for n in names[-17:]):
        raise ValueError("Checkpoint structured feature schema mismatch")
    cell = load_cell(args.canonical, args.structured, args.faculty, args.fold, names[:-17])
    p = replay_checkpoint(args.checkpoint, cell.target.X, cell.target.names)
    path = Path(args.output)
    if path.suffix != ".csv":
        raise ValueError("Replay output must be a separate .csv file")
    path.parent.mkdir(parents=True, exist_ok=True)
    pd.DataFrame(dict(faculty=args.faculty, fold=args.fold, seed=metadata.get("seed"),
        arm=metadata.get("arm"), row_index=cell.target.row_index,
        student_id=cell.target.frame.IDSV.astype(str), course_id=cell.target.frame.IDMH.astype(str),
        target_semester=cell.target.frame.target_NHHK.astype(str), y=cell.target.y, p=p)).to_csv(path, index=False)
    print(f"[CHECKPOINT_REPLAY] rows={len(p)} source_and_schema=EXACT output={path}")


if __name__ == "__main__":
    main()
