"""R2-5 SR-Pool: training-free short re-pooling of frozen SW2 DirectNet logits.

Replaces the learned temporal pool `tw` with a uniform causal weight on the last
T_p ∈ {2,3,4} s of each 10 s window, then scores LODO (select T_p by Acc then H)
and AASD/Carta once. HMM p_stay grid includes a fast track {0.90,0.95,0.98,0.994}
selected on LODO only (LODO-fast). Never uses external labels for selection.

≠ tip Acc PP / decision-layer stacking. Inference-only on published all5 + folds.
"""
from __future__ import annotations

import json
import os
import pickle
import time

import numpy as np
import torch

os.environ.setdefault("GLIMPSE_THR", "onorm")

import direct_classifier as DC
import eval_external as E
import lagbank_sel as L
import score as S
from common import DS_KEYS
from common_exp import DATA_EXP, EXP, FS, fold_file, load_trial, rows_of
from decoders import D, DEV, _targets
from e1_switch import draw_switch_times
from common import SEED

RUN_DIR = os.path.join(EXP, "experiments", "multi_agent_opt", "runs", "r3_srpool_20261107")
OUT_JSON = os.path.join(EXP, "results", "research", "sr_pool_sw2.json")
RESULTS_MD = os.path.join(EXP, "multi_agent_opt", "results_sr_pool_sw2.md")
TP_GRID = (2.0, 3.0, 4.0)
P_GRID = (0.994, 0.98, 0.95, 0.90)
SCALE = 0.8
LOOKAHEAD = 0.75


def log(m):
    print(f"{time.strftime('%F %T')} {m}", flush=True)
    os.makedirs(RUN_DIR, exist_ok=True)
    with open(os.path.join(RUN_DIR, "run.log"), "a") as fh:
        fh.write(m + "\n")


def set_short_pool(net, tp_s):
    """Uniform weight on last tp_s seconds; −inf elsewhere (softmax → short pool)."""
    W = net.tw.numel()
    n = max(1, int(round(tp_s * FS)))
    w = torch.full((W,), -1e4, device=net.tw.device)
    w[-n:] = 0.0
    net.tw.data.copy_(w)


@torch.no_grad()
def trial_logit(net, x, S):
    return DC.logits(net, x, S)


def build_ev_from_nets(nets, trials_iter, prep_stim):
    """Average logits across seeds into evidence dict."""
    EV = {}
    for tr in trials_iter:
        key = tr["key"]
        stim = prep_stim(tr)
        lgs = []
        starts = None
        for net in nets:
            lg, st = trial_logit(net, tr["eeg"], stim)
            lgs.append(lg)
            starts = st
        lg = np.mean(lgs, 0)
        truth = tr["att"].astype(int)[np.maximum(starts - DC.HOP, 0)]
        EV[key] = dict(
            r0=lg / 2, r1=-lg / 2, att=truth.astype(np.int8),
            t_end=(starts / FS + tr["t0"]).astype(np.float32),
            att128=tr.get("att128"), n128=tr.get("n128"),
            subject=tr.get("subject", tr.get("subj_uid")),
        )
        if "att128" not in tr:
            # LODO fold trials may lack att128 — score_dataset synthesizes switches
            pass
    return EV


def load_fold_nets(held):
    """Load 4 seed fold checkpoints for held-out dataset."""
    L.configure()
    nets = []
    # Prefer published fold SW2 with wts naming
    patterns = [
        os.path.join(DATA_EXP, "models",
                     f"fold_direct_clf__eaP_n5_t60_w10b3_ptSPK_aug-sw2_wts__{held}.pt"),
        os.path.join(DATA_EXP, "models",
                     f"fold_direct_clf__eaP_n5_t60_w10b3_ptSPK_s{{s}}_aug-sw2_wts__{held}.pt"),
    ]
    # seed 0 without _s0, seeds 1-3 with _sN
    paths = []
    p0 = patterns[0]
    if os.path.exists(p0):
        paths.append(p0)
    for s in range(1, 4):
        p = os.path.join(DATA_EXP, "models",
                         f"fold_direct_clf__eaP_n5_t60_w10b3_ptSPK_s{s}_aug-sw2_wts__{held}.pt")
        if os.path.exists(p):
            paths.append(p)
    if len(paths) < 4:
        # fallback: all5 only for external; for LODO use single seed0 fold if present
        log(f"  warn: only {len(paths)} fold ckpts for {held}; using available")
    for p in paths:
        net = DC.DirectNet(58, 3, "vlaai_ws").to(DEV)
        net.load_state_dict(torch.load(p, map_location=DEV, weights_only=False))
        net.eval()
        nets.append(net)
    return nets


def synth_lodo_ev(nets, held, tp_s):
    for net in nets:
        set_short_pool(net, tp_s)
    srng = np.random.default_rng(SEED + DS_KEYS.index(held))
    EV = {}
    for _, r in rows_of(held).iterrows():
        tr = load_trial("eaP_n5_t60", r["key"])
        Sfeat, x, att, T128 = _targets(tr), tr["eeg"], tr["att"].astype(int), int(r["n"])
        times = draw_switch_times(srng, T128 / 128)
        srng.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))]
        Ssw = np.where(st[:, None, None], Sfeat[:, ::-1], Sfeat)
        lgs, starts = [], None
        for net in nets:
            lg, stt = DC.logits(net, x, Ssw)
            lgs.append(lg)
            starts = stt
        lg = np.mean(lgs, 0)
        truth = (att ^ st)[np.maximum(starts - DC.HOP, 0)]
        n10 = max(1, len(lg) // 40)
        EV[r["key"]] = dict(
            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)
    return EV


def main():
    os.makedirs(RUN_DIR, exist_ok=True)
    L.configure()
    log("=== SR-Pool SW2 (training-free) ===")
    # Screen on AVGC fold only first for speed: pick tp, then full LODO
    held0 = "AVGC"
    nets0 = load_fold_nets(held0)
    if not nets0:
        raise SystemExit("no fold checkpoints")
    screen = []
    for tp in TP_GRID:
        ev = {held0: synth_lodo_ev(nets0, held0, tp)}
        # need other folds for emissions — load published SW2 fold evidence and only replace held0
        base_ev, _ = None, None
        try:
            # use existing scored folds from shared path
            from acc_fuse_sw2_bmms import fold_path
            base = {}
            for ds in DS_KEYS:
                with open(fold_path("direct_clf__eaP_n5_t60_w10b3_ptSPK_aug-sw2_wts", ds), "rb") as fh:
                    base[ds] = pickle.load(fh)["evidence"]["causal"]
            base[held0] = ev[held0]
            A = np.concatenate([
                (e["r0"] - e["r1"]) * np.where(e["att"] == 0, 1.0, -1.0)
                for d in DS_KEYS if d != held0 for e in base[d].values()])
            mu, sd = float(A.mean()), float(A.std())
            best_p, best_r = None, None
            for p in P_GRID:
                r = S.score_dataset(held0, base, LOOKAHEAD, emis=(mu, sd * SCALE), p_stay=p)
                if best_r is None or r["Acc"] > best_r["Acc"] or (
                        r["Acc"] == best_r["Acc"] and r["H"] > best_r["H"]):
                    best_p, best_r = p, r
            screen.append(dict(tp=tp, p_stay=best_p, H=best_r["H"], Acc=best_r["Acc"]))
            log(f"  screen AVGC tp={tp} p={best_p} H {best_r['H']:.4f} Acc {best_r['Acc']:.2f}")
        finally:
            pass
    screen.sort(key=lambda r: (r["Acc"], r["H"]), reverse=True)
    tp_star = screen[0]["tp"]
    log(f"SELECTED tp={tp_star} on AVGC screen")

    # Full LODO with tp_star: rebuild all held folds (expensive). Use seed0 fold nets only for speed.
    per_p = {p: [] for p in P_GRID}
    fold_ev = {}
    for held in DS_KEYS:
        nets = load_fold_nets(held)
        if not nets:
            nets = nets0
        fold_ev[held] = synth_lodo_ev(nets, held, tp_star)
        log(f"  rebuilt LODO evidence {held} with tp={tp_star}")
        for net in nets:
            del net
        if DEV.type == "cuda":
            torch.cuda.empty_cache()

    grid = []
    for p in P_GRID:
        per = {}
        for ds in DS_KEYS:
            A = np.concatenate([
                (e["r0"] - e["r1"]) * np.where(e["att"] == 0, 1.0, -1.0)
                for d in DS_KEYS if d != ds for e in fold_ev[d].values()])
            mu, sd = float(A.mean()), float(A.std())
            r = S.score_dataset(ds, fold_ev, LOOKAHEAD, emis=(mu, sd * SCALE), p_stay=p)
            per[ds] = r
        mH = float(np.mean([per[d]["H"] for d in DS_KEYS]))
        mA = float(np.mean([per[d]["Acc"] for d in DS_KEYS]))
        grid.append(dict(p_stay=p, mean_H=mH, mean_Acc=mA, per={d: dict(H=per[d]["H"], Acc=per[d]["Acc"]) for d in DS_KEYS}))
        log(f"  LODO p={p} mean H {mH:.4f} Acc {mA:.2f}")
    grid.sort(key=lambda r: (r["mean_Acc"], r["mean_H"]), reverse=True)
    best = grid[0]
    p_star = best["p_stay"]
    log(f"SELECTED p_stay={p_star} LODO Acc {best['mean_Acc']:.2f}")

    # External with all5 nets
    all5 = L.load_nets()
    for net in all5:
        set_short_pool(net, tp_star)
    A = np.concatenate([
        (e["r0"] - e["r1"]) * np.where(e["att"] == 0, 1.0, -1.0)
        for ds in DS_KEYS for e in fold_ev[ds].values()])
    mu, sd = float(A.mean()), float(A.std())
    ext = {}
    for ds in ("AASD", "Carta2026"):
        EV = {}
        for tr in E.ext_trials(ds):
            stim = L.external_targets(ds, tr)
            lgs, starts = [], None
            for net in all5:
                lg, st = DC.logits(net, tr["eeg"], stim)
                lgs.append(lg)
                starts = st
            lg = np.mean(lgs, 0)
            truth = tr["att"].astype(int)[np.maximum(starts - DC.HOP, 0)]
            EV[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"])
        r = E.score(EV, mu, sd * SCALE, p_star, LOOKAHEAD)
        ext[ds] = r
        log(f"  EXT {ds} H {r['H']:.4f} Acc {r['Acc']:.2f}")

    out = dict(
        method="sr_pool_sw2", tp_s=tp_star, p_stay=p_star, scale=SCALE,
        screen_avgc=screen, lodo_grid=grid, selected_lodo=best, external=ext,
        targets=dict(AASD_Acc_gt_70=ext["AASD"]["Acc"] > 70,
                     Carta_Acc_gt_60=ext["Carta2026"]["Acc"] > 60),
    )
    json.dump(out, open(OUT_JSON, "w"), indent=1, default=float)
    json.dump(out, open(os.path.join(RUN_DIR, "metrics.json"), "w"), indent=1, default=float)
    open(RESULTS_MD, "w").write(
        f"# results_sr_pool_sw2\n\ntp={tp_star}s p_stay={p_star}. "
        f"LODO {best['mean_H']:.4f}/{best['mean_Acc']:.2f}. "
        f"AASD {ext['AASD']['H']:.4f}/{ext['AASD']['Acc']:.2f}. "
        f"Carta {ext['Carta2026']['H']:.4f}/{ext['Carta2026']['Acc']:.2f}.\n"
    )
    log(f"wrote {OUT_JSON}")


if __name__ == "__main__":
    main()
