"""H4 residual: SR-Pool short re-pool → mean4 → causal τ=30 HP + LODO-fast.

≠ closed sr_pool_sw2 alone (no hp30; Carta Acc 59.10).
≠ multi-τ / MoE fuse↔hp30 / tip stacking.
Inference-only on published SW2 fold/all5 nets. Selection on LODO Acc then H
(incl. fast p_stay grid); never AASD/Carta labels.

Priority B: LODO H>0.80 Acc>70; Carta H>0.60 Acc>60; AASD H>0.60 (Acc soft).
"""
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 ensemble_clf_transformer_v4 as V4
import eval_external as E
import lagbank_sel as L
import score as S
from common import DS_KEYS, SEED
from common_exp import DATA_EXP, EXP, FS, load_trial, rows_of
from decoders import DEV, _targets
from e1_switch import draw_switch_times

RUN_ID = "sr_pool_hp30_20261107"
RUN_DIR = os.path.join(EXP, "experiments", "multi_agent_opt", "runs", RUN_ID)
OUT_JSON = os.path.join(EXP, "results", "research", "sr_pool_hp30.json")
OUT_MD = os.path.join(EXP, "multi_agent_opt", "results_sr_pool_hp30.md")

TP_GRID = (2.0, 3.0, 4.0)
P_GRID = (0.994, 0.98, 0.95, 0.90)  # includes LODO-fast
SCALE = 0.8
LOOKAHEAD = 0.75
TEST_NAMES = ("AASD", "Carta2026")


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):
    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)


def hp30_logit(lg):
    h = V4.highpass(np.asarray(lg, np.float64)[:, None], tau=30.0, hop=0.25)[:, 0]
    return h.astype(np.float64)


def load_fold_nets(held):
    L.configure()
    paths = []
    p0 = os.path.join(
        DATA_EXP,
        "models",
        f"fold_direct_clf__eaP_n5_t60_w10b3_ptSPK_aug-sw2_wts__{held}.pt",
    )
    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)
    nets = []
    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 = hp30_logit(np.mean(lgs, 0))
        truth = (att ^ st)[np.maximum(starts - DC.HOP, 0)]
        EV[r["key"]] = dict(
            r0=(lg / 2).astype(np.float32),
            r1=(-lg / 2).astype(np.float32),
            att=truth.astype(np.int8),
            t_end=(starts / FS + tr["t0"]).astype(np.float32),
            pre_switched=True,
        )
    return EV


def priority_b_ok(mean, ext):
    return (
        mean["H"] > 0.80
        and mean["Acc"] > 70.0
        and ext["Carta2026"]["H"] > 0.60
        and ext["Carta2026"]["Acc"] > 60.0
        and ext["AASD"]["H"] > 0.60
    )


def main():
    t0 = time.time()
    os.makedirs(RUN_DIR, exist_ok=True)
    open(os.path.join(RUN_DIR, "run.log"), "w").close()
    L.configure()
    log("=== H4 SR-Pool → mean4 → hp30 + LODO-fast ===")

    held0 = "AVGC"
    nets0 = load_fold_nets(held0)
    if not nets0:
        raise SystemExit("no fold checkpoints")

    # Reuse published SW2 fold evidence for non-held emissions during AVGC screen
    from acc_fuse_sw2_bmms import fold_path

    base_sw2 = {}
    for ds in DS_KEYS:
        with open(fold_path("direct_clf__eaP_n5_t60_w10b3_ptSPK_aug-sw2_wts", ds), "rb") as fh:
            base_sw2[ds] = pickle.load(fh)["evidence"]["causal"]

    screen = []
    for tp in TP_GRID:
        ev_h = synth_lodo_ev(nets0, held0, tp)
        base = {d: base_sw2[d] for d in DS_KEYS}
        base[held0] = ev_h
        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+hp30 tp={tp} p={best_p} H {best_r['H']:.4f} Acc {best_r['Acc']:.2f}")
    screen.sort(key=lambda r: (r["Acc"], r["H"]), reverse=True)
    tp_star = screen[0]["tp"]
    log(f"SELECTED tp={tp_star} on AVGC+hp30 screen")

    fold_ev = {}
    for held in DS_KEYS:
        nets = load_fold_nets(held) or nets0
        fold_ev[held] = synth_lodo_ev(nets, held, tp_star)
        log(f"  rebuilt LODO+hp30 evidence {held} 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] = {k: float(r[k]) for k in ("H", "Acc", "L", "SDT")}
        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=per))
        log(f"  LODO+hp30 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}")

    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 TEST_NAMES:
        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 = hp30_logit(np.mean(lgs, 0))
            truth = tr["att"].astype(int)[np.maximum(starts - DC.HOP, 0)]
            EV[tr["key"]] = dict(
                r0=(lg / 2).astype(np.float32),
                r1=(-lg / 2).astype(np.float32),
                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] = {k: float(r[k]) for k in ("H", "Acc", "L", "SDT")}
        log(f"  EXT {ds} H {ext[ds]['H']:.4f} Acc {ext[ds]['Acc']:.2f}")

    mean = dict(H=best["mean_H"], Acc=best["mean_Acc"])
    ok = priority_b_ok(mean, ext)
    out = dict(
        method="sr_pool_hp30",
        run_id=RUN_ID,
        tp_s=tp_star,
        p_stay=p_star,
        scale=SCALE,
        screen_avgc=screen,
        lodo_grid=grid,
        selected_lodo=best,
        external=ext,
        verdict="PASS" if ok else "FAIL",
        elapsed_s=time.time() - t0,
        note="SR-Pool short tw → mean4 → τ=30 HP; LODO-fast p_stay grid",
    )
    json.dump(out, open(OUT_JSON, "w"), indent=2, default=float)
    json.dump(out, open(os.path.join(RUN_DIR, "metrics.json"), "w"), indent=2, default=float)
    open(OUT_MD, "w").write(
        "# results_sr_pool_hp30\n\n"
        f"tp={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"
        f"Verdict: **{out['verdict']}** (priority B).\n"
    )
    log(f"VERDICT {out['verdict']} elapsed={out['elapsed_s']:.0f}s wrote {OUT_JSON}")
    return 0 if ok else 1


if __name__ == "__main__":
    raise SystemExit(main())
