"""Score the best fusion and the stem_ms96 second stage on ONE synthetic-switch schedule (env SCHEDULE_OFFSET, read by score.py and
fuse_evidence.py: the schedule rng is default_rng(SEED + OFFSET + dataset index)). Run once per offset; rows are appended to
results/research/schedule_noise.csv.
  best      4 decoders + 4 classifiers, fuse_general (LDA decoder weights, a = 0.5 and 1.0, p_stay 0.998 / 0.9997)
  best_orig the same with the ORIGINAL classifier folds (offset 0 only: must reproduce H 0.7981)
  stem_orig / stem_sym   stem_ms96 checkpoints of eeg-thao.zip (trained on the offset-0 logits) on the 4-seed logits of this schedule;
            *_sym = (f(x) - f(-x)) / 2. p_stay / scale = the fold's pair of their log; emissions from the other four datasets' streams
            on this schedule.
The classifier folds are `<exp>_wts` (retrained with saved weights) at offset 0 and `<exp>_wts__sched<K>` otherwise.
usage: SCHEDULE_OFFSET=K python schedule_noise_score.py --offset K --ckpt-dir DIR"""
import argparse
import importlib
import os

import numpy as np
import pandas as pd
import torch

import fuse_general as FG
import score as S
from common import DS_KEYS
from common_exp import EXP
from eval_stem_external import LogitTransformer, SEL, emission, ms_features, streams_of

DEC = ["vlaai_ws__eaP_n5_t60_aug_cluster_onset_dom_xFUG_ptSPK" + t for t in ("", "_s1", "_s2", "_s3")]
CLF = ["direct_clf__eaP_n5_t60_w10b3_ptSPK" + t + "_aug-sw2" for t in ("", "_s1", "_s2", "_s3")]
OUT = os.path.join(EXP, "results", "research", "schedule_noise.csv")


def clf_name(base, k, wts=True):
    return base + ("_wts" if wts else "") + (f"__sched{k}" if k else "")


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--offset", type=int, required=True)
    ap.add_argument("--ckpt-dir", required=True)
    a = ap.parse_args()
    if int(os.environ.get("SCHEDULE_OFFSET", 0)) != a.offset:
        raise SystemExit("SCHEDULE_OFFSET must equal --offset (score.py / fuse_evidence.py read it at import)")
    torch.set_num_threads(4)
    rows = []

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

    # ---- best fusion
    variants = [("best", [clf_name(c, a.offset) for c in CLF])]
    if a.offset == 0:
        variants.append(("best_orig", CLF))
    for name, clfs in variants:
        Z, meta = FG.build(DEC, clfs)
        for ds in DS_KEYS:
            for x in (0.5, 1.0):
                for p in (0.998, 0.9997):
                    r = FG.one(Z[ds], meta, ds, x, p)
                    add(method=name, ds=ds, a=x, p_stay=p, scale=1.0, H=r["H"], Acc=r["Acc"], SDT=r["SDT"])

    # ---- stem_ms96
    need = set()
    for ds in DS_KEYS:
        need |= set(torch.serialization.get_unsafe_globals_in_checkpoint(os.path.join(a.ckpt_dir, 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))])
    evs, info = zip(*[S.load_folds(clf_name(c, a.offset), "causal") for c in CLF])
    lookahead = float(info[0][DS_KEYS[0]]["lookahead_s"])
    dev = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    X = {ds: {k: ms_features(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}
    att = {ds: {k: evs[0][ds][k]["att"] for k in evs[0][ds]} for ds in DS_KEYS}
    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)
        for v in ("orig", "sym"):
            tr_streams = {k: s for ds in DS_KEYS if ds != held for k, s in st[v][ds].items()}
            tr_att = {k: att[ds][k] for ds in DS_KEYS if ds != held for k in att[ds]}
            m, s_ = emission(tr_streams, tr_att)
            ev = {ds: {k: dict(r0=st[v][ds][k], r1=np.zeros(len(st[v][ds][k])), att=att[ds][k], t_end=evs[0][ds][k]["t_end"], pre_switched=True)
                       for k in st[v][ds]} for ds in DS_KEYS}
            for p, sc in {SEL[held], (0.998, 1.0)}:
                r = S.score_dataset(held, ev, lookahead, emis=(m, s_ * sc), p_stay=p)
                add(method=f"stem_{v}", ds=held, a=np.nan, p_stay=p, scale=sc, H=r["H"], Acc=r["Acc"], SDT=r["SDT"])
    pd.DataFrame(rows).to_csv(OUT, mode="a", header=not os.path.exists(OUT), index=False)
    df = pd.DataFrame(rows)
    print(df.groupby(["method", "a", "p_stay", "scale"], dropna=False)[["H", "Acc", "SDT"]].mean().round(4).to_string())


if __name__ == "__main__":
    main()
