"""T8 regional channel-jackknife ensemble on frozen honest SW2 classifiers.

Views: unmodified EEG plus four anatomical-region dropouts. The published
classifier was trained with channel/cluster dropout, so each masked view stays
within its augmentation family. Median aggregation is label-free and preserves
speaker-order antisymmetry.
"""
from __future__ import annotations

import json
import os
import pickle
import time

import numpy as np
import torch

import clf_noise_aug_ft_lodo as B
import direct_classifier as DC
import eval_external as E
import score as S
from common import DS_KEYS, MONTAGES, SEED
from common_exp import CFG, EXP, FS, load_trial, rows_of
from decoders import D, DEV, _targets
from e1_switch import draw_switch_times

RUN_ID = "t8_regional_jackknife_20261107"
RUN_DIR = os.path.join(EXP, "experiments", "multi_agent_opt", "runs", RUN_ID)
CACHE = os.path.join(EXP, "cache", RUN_ID)
OUT = os.path.join(EXP, "results", "research", "regional_jackknife_sw2.json")
P_STAY, SCALE, LOOKAHEAD = 0.994, 0.8, 0.75


def region_masks() -> dict[str, np.ndarray]:
    names = MONTAGES[CFG["montage"]]
    groups = {k: [] for k in ("frontal", "temporal", "central", "posterior")}
    for i, name in enumerate(names):
        n = name.upper()
        if n.startswith(("FT", "TP", "T")):
            groups["temporal"].append(i)
        elif n.startswith(("FC", "CP", "C")):
            groups["central"].append(i)
        elif n.startswith(("PO", "P", "O", "IZ")):
            groups["posterior"].append(i)
        elif n.startswith(("FP", "AF", "F")):
            groups["frontal"].append(i)
    return {k: np.asarray(v, dtype=int) for k, v in groups.items()}


def configure() -> None:
    B.configure(0)
    D["targets"] = ["env", "onset", "dom"]


def load_nets(held: str | None) -> list[torch.nn.Module]:
    nets = []
    for seed in range(4):
        path = B.pub_fold_ckpt(seed, held) if held else B.pub_all5_ckpt(seed)
        net = DC.DirectNet(58, 3, "vlaai_ws").to(DEV)
        net.load_state_dict(torch.load(path, map_location=DEV, weights_only=False))
        net.eval()
        nets.append(net)
    return nets


@torch.no_grad()
def view_logits(nets, eeg: np.ndarray, stim: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
    views = [eeg]
    for idx in region_masks().values():
        x = np.array(eeg, copy=True)
        x[:, idx] = 0.0
        views.append(x)
    logits, starts = [], None
    for x in views:
        for net in nets:
            lg, starts = DC.logits(net, x, stim)
            logits.append(lg)
    # Robust across both seed and regional views. Every component is exactly
    # antisymmetric in speaker order, and median(-x) == -median(x).
    return np.median(np.stack(logits), axis=0), starts


def synthetic_stimulus(held: str, tr: dict, row, rng) -> tuple[np.ndarray, np.ndarray]:
    stim, x = _targets(tr), tr["eeg"]
    t128 = int(row["n"])
    times = draw_switch_times(rng, t128 / 128)
    rng.integers(0, 2)
    st128, cur, prev = np.zeros(t128, bool), False, 0
    for tt in times:
        s0 = min(t128 - 1, int(round(tt * 128)))
        st128[prev:s0] = cur
        cur, prev = not cur, s0
    st128[prev:] = cur
    st = st128[
        np.minimum(t128 - 1, np.round((np.arange(len(x)) / FS + tr["t0"]) * 128).astype(int))
    ]
    return np.where(st[:, None, None], stim[:, ::-1], stim), st


def lodo_fold(held: str) -> dict:
    path = os.path.join(CACHE, f"held-{held}.pkl")
    if os.path.exists(path):
        return pickle.load(open(path, "rb"))
    nets = load_nets(held)
    rng = np.random.default_rng(SEED + DS_KEYS.index(held))
    out = {}
    rows = rows_of(held)
    started = time.time()
    for i, (_, row) in enumerate(rows.iterrows()):
        tr = load_trial("eaP_n5_t60", row["key"])
        stim, switched = synthetic_stimulus(held, tr, row, rng)
        lg, starts = view_logits(nets, tr["eeg"], stim)
        truth = (tr["att"].astype(int) ^ switched)[np.maximum(starts - DC.HOP, 0)]
        n10 = len(lg) // 40
        out[row["key"]] = {
            "r0": lg / 2, "r1": -lg / 2, "att": truth.astype(np.int8),
            "t_end": (starts / FS + tr["t0"]).astype(np.float32),
            "r0_10": lg[:n10 * 40].reshape(n10, 40).mean(1) / 2,
            "r1_10": -lg[:n10 * 40].reshape(n10, 40).mean(1) / 2,
            "att10": (truth[:n10 * 40].reshape(n10, 40).mean(1) > 0.5).astype(np.int8),
            "pre_switched": True,
        }
        if (i + 1) % 40 == 0 or i + 1 == len(rows):
            print(f"{held}: {i + 1}/{len(rows)} ({time.time() - started:.0f}s)", flush=True)
    os.makedirs(CACHE, exist_ok=True)
    with open(path, "wb") as fh:
        pickle.dump(out, fh)
    del nets
    torch.cuda.empty_cache()
    return out


def external(ds: str) -> dict:
    path = os.path.join(CACHE, f"external-{ds}.pkl")
    if os.path.exists(path):
        return pickle.load(open(path, "rb"))
    nets = load_nets(None)
    out = {}
    trials = E.ext_trials(ds)
    started = time.time()
    for i, tr in enumerate(trials):
        lg, starts = view_logits(nets, tr["eeg"], _targets(tr))
        truth = tr["att"].astype(int)[np.maximum(starts - DC.HOP, 0)]
        out[tr["key"]] = {
            "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"],
        }
        if (i + 1) % 40 == 0 or i + 1 == len(trials):
            print(f"{ds}: {i + 1}/{len(trials)} ({time.time() - started:.0f}s)", flush=True)
    os.makedirs(CACHE, exist_ok=True)
    with open(path, "wb") as fh:
        pickle.dump(out, fh)
    del nets
    torch.cuda.empty_cache()
    return out


def main() -> None:
    configure()
    os.makedirs(RUN_DIR, exist_ok=True)
    os.makedirs(os.path.dirname(OUT), exist_ok=True)
    ev = {ds: lodo_fold(ds) for ds in DS_KEYS}
    lodo = {}
    for ds in DS_KEYS:
        signed = np.concatenate([
            (e["r0"] - e["r1"]) * np.where(e["att"] == 0, 1.0, -1.0)
            for train_ds in DS_KEYS if train_ds != ds for e in ev[train_ds].values()
        ])
        lodo[ds] = S.score_dataset(
            ds, ev, LOOKAHEAD, emis=(float(signed.mean()), float(signed.std()) * SCALE),
            p_stay=P_STAY,
        )
        lodo[ds]["acc1"] = S.plain_metrics(ds, ev[ds])["acc1"]
        print(f"LODO {ds}: H {lodo[ds]['H']:.4f} Acc {lodo[ds]['Acc']:.2f}", flush=True)
    signed = 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(signed.mean()), float(signed.std())
    ext = {}
    for ds in ("AASD", "Carta2026"):
        ext_ev = external(ds)
        ext[ds] = E.score(ext_ev, mu, sd * SCALE, P_STAY, LOOKAHEAD)
        ext[ds]["acc1"] = E.plain(ext_ev)["acc1"]
        print(f"EXT {ds}: H {ext[ds]['H']:.4f} Acc {ext[ds]['Acc']:.2f}", flush=True)
    payload = {
        "run_id": RUN_ID,
        "status": "complete",
        "method": "median of base plus four regional EEG-dropout views over four frozen SW2 seeds",
        "regions": {k: v.tolist() for k, v in region_masks().items()},
        "lodo": lodo,
        "lodo_mean": {
            "H": float(np.mean([lodo[d]["H"] for d in DS_KEYS])),
            "Acc": float(np.mean([lodo[d]["Acc"] for d in DS_KEYS])),
        },
        "external": ext,
        "emissions": {"mu": mu, "sd": sd, "scale": SCALE},
        "gates": {"antisymmetry": "by construction", "lookahead_s": LOOKAHEAD},
    }
    for path in (OUT, os.path.join(RUN_DIR, "metrics.json")):
        with open(path, "w") as fh:
            json.dump(payload, fh, indent=2)
    print(json.dumps(payload["lodo_mean"], indent=2), flush=True)
    print(json.dumps(ext, indent=2), flush=True)


if __name__ == "__main__":
    main()
