"""Direct classifier on REAL attention switches (AASD, Carta2026): counterpart of eval_external.py.

Train the direct classifier (direct_classifier.py: prep mat_reac, stimulus features env,onset,dom, synthetic switches in
30% of the training windows) on ALL five corpus datasets + Fuglsang2020 (one validation subject per dataset, the split
of eval_external.py), run it causally on the converted external trials and keep the evidence (no synthetic switch: the
labels are the real key presses). Alone it is scored with HMM emissions from the corpus LODO folds of --ref.
usage: GLIMPSE_THR=norm python eval_external_clf.py --seed 0 [--window-s 10] --init-from models/pretrain_spk_direct_clf_v2_s0.pt
           --ref direct_clf__mat_reac_ptSPKv2 --tag _v2   -> results/research/ext_clf_<DS><tag>_evidence_s<seed>.pkl (+ .json)"""
import argparse
import json
import os
import pickle
from types import SimpleNamespace

import numpy as np
import torch

import direct_classifier as DC
import eval_external as E
import score as S
from common_exp import CFG, EXP, FS, load_trial, rows_of
from common import DS_KEYS
from decoders import D, _targets
from run_experiment import load_external

if __name__ == "__main__":
    ap = argparse.ArgumentParser()
    ap.add_argument("--seed", type=int, default=0)
    ap.add_argument("--window-s", type=float, default=None)
    ap.add_argument("--init-from", default=None)
    ap.add_argument("--min-epochs", type=int, default=10)
    ap.add_argument("--ref", required=True, help="corpus LODO classifier experiment of the same configuration (emissions)")
    ap.add_argument("--dataset", default="AASD,Carta2026")
    ap.add_argument("--tag", default="")
    ap.add_argument("--prep", default="mat_reac")
    ap.add_argument("--set", nargs="*", default=[], help="overrides of config dnn, e.g. model_blocks=3")
    ap.add_argument("--aug-set", nargs="*", default=[], help="overrides of the augmentation, e.g. clf_p_switch2=0.5")
    ap.add_argument("--p-switch", type=float, default=0.3)
    ap.add_argument("--backbone", default="vlaai_ws", choices=["vlaai_ws", "adt", "happyquokka", "gru_ffn", "conv_attn", "env_xattn"])
    a = ap.parse_args()
    if a.window_s:
        DC.W = int(a.window_s * FS)
        DC.POS0, DC.LAB = DC.W - DC.FUT - DC.HOP, DC.W - FS
    D.update(targets=["env", "onset", "dom"], train_seed=a.seed, augment={**CFG["dnn_augment"], **CFG["aug_variants"]["cluster"]})
    import decoders
    decoders.apply_overrides(a.set, a.aug_set)
    E.CONF.update(prep=a.prep, targets=D["targets"])
    torch.set_num_threads(4)
    out = os.path.join(EXP, "results", "research")
    sets = a.dataset.split(",")
    evp = {ds: os.path.join(out, f"ext_clf_{ds}{a.tag}_evidence_s{a.seed}.pkl") for ds in sets}
    EV = {ds: pickle.load(open(evp[ds], "rb")) for ds in sets if os.path.exists(evp[ds])}
    if any(ds not in EV for ds in sets):
        rng = np.random.default_rng(CFG["seed"] + 99)                       # the split of eval_external.train
        train, val = [], []
        for ds in DS_KEYS:
            rows = rows_of(ds)
            vs = rng.choice(sorted(rows.subject.unique()))
            for _, r in rows.iterrows():
                (val if r["subject"] == vs else train).append(load_trial(a.prep, r["key"]))
        train += load_external(["Fuglsang2020"], a.prep, E.log)
        for tr in train + val:
            tr["_S"] = _targets(tr)
        E.log(f"direct classifier, window {DC.W / FS:g} s, seed {a.seed}: {len(train)} train / {len(val)} val trials")
        net, best = DC.fit(train, val, E.log, SimpleNamespace(backbone=a.backbone, p_switch=a.p_switch, zero_eeg=False, min_epochs=a.min_epochs), a.init_from)
        torch.save(net.state_dict(), os.path.join(EXP, "models", f"all5_direct_clf{a.tag}_s{a.seed}.pt"))
        del train, val
        for ds in [d for d in sets if d not in EV]:
            EV[ds] = {}
            for tr in E.ext_trials(ds):
                lg, starts = DC.logits(net, tr["eeg"], _targets(tr))
                truth = tr["att"].astype(int)[np.maximum(starts - DC.HOP, 0)]      # attended column 1 s before the window end
                EV[ds][tr["key"]] = dict(r0=lg / 2, r1=-lg / 2, att=truth.astype(np.int8), t_end=(starts / FS + tr["t0"]).astype(np.float32),
                                         att128=tr["att128"], n128=tr["n128"], subject=tr["subject"])
            pickle.dump(EV[ds], open(evp[ds], "wb"))
    import time
    from common_exp import fold_file
    for _ in range(720):                                  # the corpus LODO run of --ref may still be training (job queue)
        if all(os.path.exists(fold_file(a.ref, ds)) for ds in DS_KEYS):
            break
        time.sleep(30)
    ev, _ = S.load_folds(a.ref, "causal")
    A = np.concatenate([(e["r0"] - e["r1"]) * np.where(e["att"] == 0, 1.0, -1.0) for ds in DS_KEYS for e in ev[ds].values()])
    mu, sd = float(A.mean()), float(A.std())
    for ds in sets:
        res = dict(seed=a.seed, dataset=ds, window_s=DC.W / FS, init_from=a.init_from, emissions=dict(mu=mu, sd=sd), plain=E.plain(EV[ds]),
                   by_p_stay={str(p): E.score(EV[ds], mu, sd, p, 0.75) for p in (0.9997, 0.998, 0.995, 0.99, 0.98, 0.95, 0.9)})
        b = res["by_p_stay"]
        E.log(f"{ds} classifier {DC.W / FS:g} s: plain {res['plain']} | REAL " + "  ".join(f"p{p} H {v['H']:.3f} Acc {v['Acc']:.1f}" for p, v in b.items()))
        json.dump(res, open(os.path.join(out, f"ext_clf_{ds}{a.tag}_s{a.seed}.json"), "w"), indent=1, default=float)
