"""Re-score stem_ms96 (eeg-thao.zip second stage) under the NEW metric (kappa_next_inclusive, provisional scorer).

Same inputs and procedure as schedule_noise_score.py (offset 0, the usual synthetic schedule) for LODO and as
eval_stem_external.py for AASD / Carta2026; only the scorer changes (r1_acc_decision_grid.install_scorer). Checkpoints are
loaded with torch.load(weights_only=True) and only numpy globals allowed; nothing from the zip is executed.
  mean4      plain mean of the 4 DirectNet sw2 seed logits (no second stage); emissions from the other four datasets
             (LODO) or all five (real sets)
  stem_orig  stem_ms96 as trained;  stem_sym = (f(x) - f(-x)) / 2
For orig / sym each held-out fold model scores its own dataset (LODO); on AASD / Carta all five fold models are scored and
averaged. p_stay / scale: the fold's selected pair (SEL from their log) and (0.998, 1.0).
usage: python stem_kappa.py --ckpt-dir ../../eeg-thao_unzipped/eeg-thao/models/stem_ms96_image_split
   -> results/research/stem_kappa.csv, stem_kappa_summary.txt
"""
import argparse
import importlib
import os
import pickle

import numpy as np
import pandas as pd
import torch

import eval_external as E
import r1_acc_decision_grid as R
import score as S
from common import DS_KEYS
from common_exp import EXP
from eval_stem_external import EXT_TAG, REF, SEL, LogitTransformer, emission, ms_features, streams_of

RES = os.path.join(EXP, "results", "research")
CLF = [c.replace("_aug-sw2", "_aug-sw2_wts") for c in REF]   # bit-exact retrain of REF with saved weights


def allow_numpy(ckdir):
    need = set()
    for ds in DS_KEYS:
        need |= set(torch.serialization.get_unsafe_globals_in_checkpoint(os.path.join(ckdir, f"stem_ms96__held-{ds}.pt")))
    allow = []
    for n in need:
        mod, _, attr = n.rpartition(".")
        if not mod.startswith("numpy"):
            raise SystemExit(f"refusing non-numpy global {n}")
        allow.append(getattr(importlib.import_module(mod), attr))
    torch.serialization.add_safe_globals(allow + [type(np.dtype(np.float32)), type(np.dtype(np.float64))])


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--ckpt-dir", required=True)
    a = ap.parse_args()
    R.install_scorer()
    allow_numpy(a.ckpt_dir)
    torch.set_num_threads(2)
    dev = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    evs, info = zip(*[S.load_folds(c, "causal") for c in CLF])
    la = float(info[0][DS_KEYS[0]]["lookahead_s"])
    D = {ds: {k: np.stack([(e[ds][k]["r0"] - e[ds][k]["r1"]) for e in evs], 1) for k in evs[0][ds]} for ds in DS_KEYS}
    X = {ds: {k: ms_features(v) for k, v in D[ds].items()} for ds in DS_KEYS}
    att = {ds: {k: evs[0][ds][k]["att"] for k in evs[0][ds]} for ds in DS_KEYS}
    ext = {}
    for ds in ("AASD", "Carta2026"):
        E4 = [pickle.load(open(os.path.join(RES, f"ext_clf_{ds}{EXT_TAG}_evidence_s{i}.pkl"), "rb")) for i in range(4)]
        ext[ds] = {k: dict(ev=E4[0][k], D=np.stack([(e[k]["r0"] - e[k]["r1"]).astype(np.float64) for e in E4], 1)) for k in E4[0]}
        for v in ext[ds].values():
            v["X"] = ms_features(v["D"])
    rows = []

    def add(**kw):
        rows.append(kw)
        print({k: (round(v, 4) if isinstance(v, float) else v) for k, v in kw.items()}, flush=True)

    def ev_of(streams, ds):
        return {k: dict(r0=s, r1=np.zeros(len(s)), att=att[ds][k], t_end=evs[0][ds][k]["t_end"], pre_switched=True)
                for k, s in streams.items()}

    # ---- mean4 reference
    m4 = {ds: {k: v.mean(1) for k, v in D[ds].items()} for ds in DS_KEYS}
    for held in DS_KEYS:
        mu, sd = emission({k: s for d in DS_KEYS if d != held for k, s in m4[d].items()},
                          {k: att[d][k] for d in DS_KEYS if d != held for k in att[d]})
        ev = {ds: ev_of(m4[ds], ds) for ds in DS_KEYS}
        for p in (0.998, 0.994):
            r = S.score_dataset(held, ev, la, emis=(mu, sd), p_stay=p)
            add(method="mean4", fold=held, ds=held, p_stay=p, scale=1.0, **{x: float(r[x]) for x in ("Acc", "H", "SDT", "L")})
    mu, sd = emission({k: s for d in DS_KEYS for k, s in m4[d].items()}, {k: att[d][k] for d in DS_KEYS for k in att[d]})
    for ds in ext:
        for p in (0.998, 0.994):
            ev = {k: dict(v["ev"], r0=v["D"].mean(1), r1=np.zeros(len(v["D"]))) for k, v in ext[ds].items()}
            r = E.score(ev, mu, sd, p, la)
            add(method="mean4", fold="ALL", ds=ds, p_stay=p, scale=1.0, **{x: float(r[x]) for x in ("Acc", "H", "SDT", "L")})

    # ---- stem_ms96
    for held in DS_KEYS:
        ck = torch.load(os.path.join(a.ckpt_dir, f"stem_ms96__held-{held}.pt"), map_location="cpu", weights_only=True)
        model = LogitTransformer().to(dev)
        model.load_state_dict(ck["state"])
        model.eval()
        mu_, sd_ = np.asarray(ck["mu"], np.float32), np.asarray(ck["sd"], np.float32)
        st = {v: {ds: {} for ds in DS_KEYS} for v in ("orig", "sym")}
        for ds in DS_KEYS:
            for k, x in X[ds].items():
                st["orig"][ds][k], st["sym"][ds][k] = streams_of(model, x, mu_, sd_, dev)
        sx = {k: streams_of(model, v["X"], mu_, sd_, dev) for ds in ext for k, v in ext[ds].items()}
        for vi, v in enumerate(("orig", "sym")):
            m, s_ = emission({k: s for ds in DS_KEYS if ds != held for k, s in st[v][ds].items()},
                             {k: att[ds][k] for ds in DS_KEYS if ds != held for k in att[ds]})
            ev = {ds: ev_of(st[v][ds], ds) for ds in DS_KEYS}
            for p, sc in sorted({SEL[held], (0.998, 1.0)}):
                r = S.score_dataset(held, ev, la, emis=(m, s_ * sc), p_stay=p)
                add(method=f"stem_{v}", fold=held, ds=held, p_stay=p, scale=sc, **{x: float(r[x]) for x in ("Acc", "H", "SDT", "L")})
                for ds in ext:
                    e2 = {k: dict(w["ev"], r0=sx[k][vi], r1=np.zeros(len(sx[k][vi]))) for k, w in ext[ds].items()}
                    r = E.score(e2, m, s_ * sc, p, la)
                    add(method=f"stem_{v}", fold=held, ds=ds, p_stay=p, scale=sc, **{x: float(r[x]) for x in ("Acc", "H", "SDT", "L")})
        del model
        torch.cuda.empty_cache()

    df = pd.DataFrame(rows).assign(metric="kappa_next_inclusive_provisional")
    df.to_csv(os.path.join(RES, "stem_kappa.csv"), index=False)
    df["cfg"] = np.where((df.p_stay == 0.998) & (df.scale == 1.0), "p0.998", "their_sel")
    df.loc[(df.method == "mean4") & (df.p_stay == 0.994), "cfg"] = "p0.994"
    lo = df[df.ds.isin(DS_KEYS)]
    t = lo.pivot_table(index=["method", "cfg"], columns="ds", values="Acc")
    t.insert(0, "LODO_Acc", t[list(DS_KEYS)].mean(1))
    h = lo.pivot_table(index=["method", "cfg"], columns="ds", values="H")
    t.insert(1, "LODO_H", h[list(DS_KEYS)].mean(1)); t.insert(2, "LODO_SDT", lo.pivot_table(index=["method", "cfg"], columns="ds", values="SDT").mean(1))
    t["AVGC_H"] = h["AVGC"]
    re = df[~df.ds.isin(DS_KEYS)]
    for ds in ext:
        g = re[re.ds == ds].groupby(["method", "cfg"])[["Acc", "H", "SDT"]].mean()   # stem: mean over the five fold models
        t[f"{ds}_Acc"], t[f"{ds}_H"], t[f"{ds}_SDT"] = g.Acc, g.H, g.SDT
    txt = ("stem_ms96 (eeg-thao.zip) vs mean of 4 DirectNet sw2 logits, NEW metric (kappa_next_inclusive_provisional)\n"
           "LODO: each fold model on its held-out dataset (usual schedule, offset 0); AASD / Carta: mean over the 5 fold models\n"
           "their_sel = the fold's (p_stay, scale) from their log; Acc / SDT per dataset, H\n\n" + t.round(3).to_string() + "\n")
    open(os.path.join(RES, "stem_kappa_summary.txt"), "w").write(txt)
    print(txt, flush=True)


if __name__ == "__main__":
    main()
