"""B1 screen: DirectNet SW2 on prep wb16P_n5_t60 (causal 0.5–16 → 32 Hz + eaP).

Baseline LA=0.75 s (causal_future_s=0.5). Recipe otherwise = published SW2
(w10 b3 ptSPK aug-sw2). Chance-abort on AVGC; full LODO + all5 external Acc/H
@0.994/0.8. Cleanup bulky .pt if AASD Acc < tip−1 (~52.5).

≠ AADNet-from-scratch, ≠ tip Acc PP, ≠ fft15 (non-causal).
"""
from __future__ import annotations

import json
import os
import pickle
import time
from types import SimpleNamespace

import numpy as np
import torch
import torch.nn.functional as F

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

import decoders
import direct_classifier as DC
import eval_external as E
import score as S
from common import DS_KEYS, SEED
from common_exp import CFG, EXP, FS, fold_file, load_trial, rows_of, save_pickle
from decoders import D, DEV, _targets
from e1_switch import draw_switch_times
from run_experiment import load_external, log_to

PREP = "wb16P_n5_t60"
EXP_NAME = f"direct_clf__{PREP}_w10b3_ptSPK_aug-sw2"
TAG = f"_{PREP}_w10b3_ptSPK_aug-sw2"
LOG_PATH = os.path.join(EXP, "experiments", "b1_wb16_sw2_lodo.log")
OUT_JSON = os.path.join(EXP, "results", f"{EXP_NAME}.json")
CKPT_DIR = os.path.join(EXP, "models", "b1_wb16_sw2")
ALL5_PT = os.path.join(EXP, "models", f"all5_direct_clf{TAG}.pt")
EXT_DIR = os.path.join(EXP, "results", "research")
RESULTS_MD = os.path.join(EXP, "multi_agent_opt", "results_b1_wb16_sw2.md")
RUN_DIR = os.path.join(EXP, "experiments", "multi_agent_opt", "runs", "b1_wb16_20261107")
_INIT_CANDS = [
    "/root/disk_3tb/EEG-sAAD-Grand-Challenge-Training-Dataset/experiments/decoder_lodo/models/pretrain_spk_direct_clf_w10_b3_s0.pt",
    os.path.join(EXP, "models", "pretrain_spk_direct_clf_w10_b3_s0.pt"),
]
MAX_EPOCHS = int(os.environ.get("MAX_EPOCHS", "40"))
MIN_EPOCHS = int(os.environ.get("MIN_EPOCHS", "10"))
P_STAY, SCALE = 0.994, 0.8
WINDOW_S = 10.0
BATCH = int(os.environ.get("BATCH", "64"))
CHANCE_STEPS = 50
CHANCE_LOSS = 0.685
TIP_AASD = 53.53  # Acc tip (swmix); cleanup if Acc < tip-1


class ChanceStuckError(RuntimeError):
    pass


def configure():
    D["causal_future_s"] = 0.5
    DC.HOP = int(D.get("infer_hop_s", 0.25) * FS)
    DC.FUT = int(0.5 * FS)
    DC.W = int(WINDOW_S * FS)
    DC.POS0, DC.LAB = DC.W - DC.FUT - DC.HOP, DC.W - FS
    D["targets"] = ["env", "onset", "dom"]
    D["model_blocks"] = 3
    D["augment"] = {**CFG["dnn_augment"], **CFG["aug_variants"]["cluster"], "clf_p_switch2": 0.5}
    D["train_seed"] = int(CFG["seed"])
    D["max_epochs"] = MAX_EPOCHS
    D["steps_per_epoch"] = 250
    D["batch_size"] = BATCH
    D["patience"] = 6
    decoders.apply_overrides(["model_blocks=3"], ["clf_p_switch2=0.5"])


def resolve_init():
    for p in _INIT_CANDS:
        if os.path.exists(p):
            return p
    return None


def fit_net(train, val, log, a, check_chance=True):
    Fs = train[0]["_S"].shape[-1]
    seed = D.get("train_seed", CFG["seed"])
    torch.manual_seed(seed)
    net = DC.DirectNet(58, Fs, "vlaai_ws").to(DEV)
    init = resolve_init()
    if init:
        st = torch.load(init, map_location=DEV, weights_only=False)
        missing, unexpected = net.load_state_dict(st, strict=False)
        log(f"  init from {init} missing={len(missing)} unexpected={len(unexpected)}")
    aug = decoders.DNNDec.__new__(decoders.DNNDec)
    aug.W, aug.fut, aug.hop, aug.C = DC.W, DC.FUT, DC.HOP, 58
    rs = np.random.default_rng(seed)
    Xv, Sv, yv = DC.windows(val, D["val_windows"], rs, None, a.p_switch, a.zero_eeg)
    opt = torch.optim.AdamW(net.parameters(), lr=D["lr"], weight_decay=D["weight_decay"])
    sch = torch.optim.lr_scheduler.ReduceLROnPlateau(opt, mode="min", factor=0.5, patience=D["lr_patience"])
    best, bad, state = np.inf, 0, None
    for ep in range(D["max_epochs"]):
        t1, tl = time.time(), []
        net.train()
        for _ in range(D["steps_per_epoch"]):
            X, Sfeat, y = [z.to(DEV) for z in DC.windows(train, D["batch_size"], rs, aug, a.p_switch, a.zero_eeg)]
            loss = F.binary_cross_entropy_with_logits(net(X, Sfeat), y)
            tl.append(loss.item())
            opt.zero_grad()
            loss.backward()
            torch.nn.utils.clip_grad_norm_(net.parameters(), 5.0)
            opt.step()
            if check_chance and ep == 0 and len(tl) == CHANCE_STEPS:
                recent = float(np.mean(tl))
                log(f"    step {CHANCE_STEPS} train {recent:.4f}")
                if recent >= CHANCE_LOSS:
                    raise ChanceStuckError(f"ABORT_CHANCE: mean loss {recent:.4f} >= {CHANCE_LOSS}")
        net.eval()
        with torch.no_grad():
            lv = torch.cat([net(Xv[i:i + 256].to(DEV), Sv[i:i + 256].to(DEV)).cpu()
                            for i in range(0, len(Xv), 256)])
        vl = float(F.binary_cross_entropy_with_logits(lv, yv))
        va = float(((lv > 0).float() == yv).float().mean())
        if ep >= a.min_epochs:
            sch.step(vl)
        log(f"    epoch {ep:02d} train {np.mean(tl):.4f} val BCE {vl:.4f} acc {va:.3f} ({time.time()-t1:.0f}s)")
        if vl < best - 1e-4:
            best, bad, state = vl, 0, {k: v.detach().clone() for k, v in net.state_dict().items()}
        elif ep >= a.min_epochs:
            bad += 1
            if bad >= D["patience"]:
                break
    net.load_state_dict(state)
    net.eval()
    return net, best


def run_fold(held, log, a, check_chance=False):
    rng = np.random.default_rng(CFG["seed"] + DS_KEYS.index(held))
    train, val = [], []
    for ds in DS_KEYS:
        if ds == held:
            continue
        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, log)
    for tr in train + val:
        tr["_S"] = _targets(tr)
    la = (DC.FUT + DC.HOP) / FS
    log(f"  fold {held}: {len(train)}/{len(val)} LA={la:.3f}s prep={a.prep}")
    t0 = time.time()
    net, best = fit_net(train, val, log, a, check_chance=check_chance)
    os.makedirs(CKPT_DIR, exist_ok=True)
    torch.save(net.state_dict(), os.path.join(CKPT_DIR, f"held-{held}.pt"))
    srng = np.random.default_rng(SEED + DS_KEYS.index(held))
    ev = {}
    for _, r in rows_of(held).iterrows():
        tr = load_trial(a.prep, 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)
        lg, starts = DC.logits(net, x, Ssw)
        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)
    info = dict(decoder="direct_clf", prep=a.prep, held_out=held, best_val=best,
                lookahead_s=la, fit_s=time.time() - t0, window_s=WINDOW_S)
    save_pickle(dict(evidence={"causal": ev}, info=info), fold_file(EXP_NAME, held))
    log(f"  fold {held} done best_val {best:.4f}")
    del net
    if DEV.type == "cuda":
        torch.cuda.empty_cache()


def cleanup_ckpts(log):
    log("failure cleanup: removing bulky B1 checkpoints")
    for p in [ALL5_PT]:
        if os.path.exists(p):
            try:
                os.remove(p)
            except OSError:
                pass
    if os.path.isdir(CKPT_DIR):
        for f in os.listdir(CKPT_DIR):
            if f.endswith(".pt"):
                try:
                    os.remove(os.path.join(CKPT_DIR, f))
                except OSError:
                    pass


def main():
    os.makedirs(RUN_DIR, exist_ok=True)
    configure()
    log = log_to(LOG_PATH)
    a = SimpleNamespace(backbone="vlaai_ws", p_switch=0.5, zero_eeg=False,
                        min_epochs=MIN_EPOCHS, prep=PREP, tag=TAG)
    la = (DC.FUT + DC.HOP) / FS
    log(f"=== B1 wb16 SW2 LA={la:.3f}s prep={PREP} device={DEV} ===")
    if la > 1.001:
        raise RuntimeError(f"lookahead {la} exceeds 1 s")

    # CONF for eval_external.ext_trials
    E.CONF["prep"] = PREP
    E.CONF["decoder"] = "direct_clf"
    E.CONF["targets"] = ["env", "onset", "dom"]

    try:
        for held in DS_KEYS:
            if os.path.exists(fold_file(EXP_NAME, held)):
                log(f"  cached {held}")
                continue
            run_fold(held, log, a, check_chance=(held == "AVGC"))
    except ChanceStuckError as e:
        log(f"ABANDON {e}")
        out = dict(status="abandoned", reason=str(e), prep=PREP)
        json.dump(out, open(OUT_JSON, "w"), indent=1)
        json.dump(out, open(os.path.join(RUN_DIR, "metrics.json"), "w"), indent=1)
        open(RESULTS_MD, "w").write(f"# results_b1_wb16_sw2\n\nABANDONED: {e}\n")
        raise SystemExit(3)

    ev, _ = S.load_folds(EXP_NAME, "causal")
    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 ev[d].values()])
        mu, sd = float(A.mean()), float(A.std())
        r = S.score_dataset(ds, ev, la, emis=(mu, sd * SCALE), p_stay=P_STAY)
        per[ds] = r
        log(f"  LODO {ds} H {r['H']:.4f} Acc {r['Acc']:.2f}")
    mH = float(np.mean([per[d]["H"] for d in DS_KEYS]))
    mA = float(np.mean([per[d]["Acc"] for d in DS_KEYS]))
    log(f"  LODO MEAN H {mH:.4f} Acc {mA:.2f}")

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

    if not os.path.exists(ALL5_PT):
        rng = np.random.default_rng(CFG["seed"] + 99)
        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, log)
        for tr in train + val:
            tr["_S"] = _targets(tr)
        net, best = fit_net(train, val, log, a, check_chance=False)
        torch.save(net.state_dict(), ALL5_PT)
        log(f"  saved {ALL5_PT} best_val {best:.4f}")
    else:
        net = DC.DirectNet(58, 3, "vlaai_ws").to(DEV)
        net.load_state_dict(torch.load(ALL5_PT, map_location=DEV, weights_only=False))
        net.eval()
        log(f"  loaded {ALL5_PT}")

    os.makedirs(EXT_DIR, exist_ok=True)
    ext = {}
    for ds in ("AASD", "Carta2026"):
        path = os.path.join(EXT_DIR, f"ext_clf_{ds}{TAG}_evidence.pkl")
        if not os.path.exists(path):
            EV = {}
            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)]
                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"])
            pickle.dump(EV, open(path, "wb"))
        else:
            EV = pickle.load(open(path, "rb"))
        r = E.score(EV, mu, sd * SCALE, P_STAY, la)
        # also plain Acc1
        plain = S.plain_acc(EV) if hasattr(S, "plain_acc") else None
        ext[ds] = dict(H=r["H"], Acc=r["Acc"], raw=r)
        if plain is not None:
            ext[ds]["acc1"] = plain.get("acc1")
        log(f"  EXT {ds} H {r['H']:.4f} Acc {r['Acc']:.2f}")

    out = dict(
        status="done", prep=PREP, lookahead_s=la,
        lodo={d: dict(H=per[d]["H"], Acc=per[d]["Acc"]) for d in DS_KEYS},
        mean_H=mH, mean_Acc=mA, external={k: dict(H=v["H"], Acc=v["Acc"]) for k, v in ext.items()},
        targets=dict(AASD_Acc_gt_70=ext["AASD"]["Acc"] > 70,
                     Carta_Acc_gt_60=ext["Carta2026"]["Acc"] > 60,
                     Performance_H_met=False),
        vs_bars=dict(AASD_bar=70, Carta_bar=60, AASD_gap=ext["AASD"]["Acc"] - 70,
                     Carta_gap=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_b1_wb16_sw2\n\n"
        f"Prep `{PREP}` (causal 0.5–16→32 + eaP). SW2 w10b3 ptSPK. LA={la:.3f}s HMM {P_STAY}/{SCALE}.\n\n"
        f"| Set | H | Acc | Bar |\n|---|---:|---:|---:|\n"
        f"| LODO mean | {mH:.4f} | {mA:.2f} | — |\n"
        f"| AASD | {ext['AASD']['H']:.4f} | {ext['AASD']['Acc']:.2f} | >70 |\n"
        f"| Carta2026 | {ext['Carta2026']['H']:.4f} | {ext['Carta2026']['Acc']:.2f} | >60 |\n\n"
        f"Targets: AASD>70={'YES' if out['targets']['AASD_Acc_gt_70'] else 'NO'}; "
        f"Carta>60={'YES' if out['targets']['Carta_Acc_gt_60'] else 'NO'}.\n"
    )
    if ext["AASD"]["Acc"] < TIP_AASD - 1.0:
        cleanup_ckpts(log)
    log(f"DONE AASD Acc={ext['AASD']['Acc']:.2f} Carta Acc={ext['Carta2026']['Acc']:.2f}")


if __name__ == "__main__":
    main()
