"""Train-time learned causal EEG baseline (α softplus-constrained) inside DirectNet.

Front-end: y = EEG − EMA_α(EEG) with learnable α (init ≈ τ=30s), shared across
channels. Short FT of published SW2. Born-debiased emissions; no tip↔stem mix.

≠ fixed-τ eeg_causal_demean (this learns α), ≠ running-z prep, ≠ hp30_center_ft.

usage:
  SCREEN=1 flock multi_agent_opt/gpu.lock python -u learned_baseline_sw2.py
"""
from __future__ import annotations

import json
import math
import os
import shutil
import time

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

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

import decoders
import direct_classifier as DC
import score as S
from common import DS_KEYS, SEED
from common_exp import CFG, DATA_EXP, EXP, FS, load_trial, resolve_model, rows_of
from decoders import D, DEV, _targets
from e1_switch import draw_switch_times
from run_experiment import load_external

PREP = "eaP_n5_t60"
TAU0 = float(os.environ.get("TAU0", "30"))
MAX_EPOCHS = int(os.environ.get("MAX_EPOCHS", "4"))
MIN_EPOCHS = int(os.environ.get("MIN_EPOCHS", "2"))
BATCH = 64
FT_LR = float(os.environ.get("FT_LR", "2.5e-4"))
STEPS = 250
P_SWITCH = 0.5
P_SWITCH2 = 0.5
P_STAY, SCALE = 0.994, 0.8
LOOKAHEAD = 0.75
CHANCE_LOSS = 0.685
SCREEN = os.environ.get("SCREEN", "1") == "1"

CKPT_ROOT = os.path.join(EXP, "models", "learned_baseline_sw2")
LOG_PATH = os.path.join(EXP, "experiments", "learned_baseline_sw2.log")
OUT_JSON = os.path.join(EXP, "results", "research", "learned_baseline_sw2.json")
RESULTS_MD = os.path.join(EXP, "multi_agent_opt", "results_learned_baseline_sw2.md")


def log(msg):
    print(msg, flush=True)
    os.makedirs(os.path.dirname(LOG_PATH), exist_ok=True)
    with open(LOG_PATH, "a") as fh:
        fh.write(msg + "\n")


class LearnedBaselineNet(nn.Module):
    """Wrap DirectNet: causal EMA demean of EEG with learnable α before backbone."""

    def __init__(self, Fs, tau0=TAU0):
        super().__init__()
        self.net = DC.DirectNet(58, Fs, "vlaai_ws")
        # α = softplus(raw) ∈ (0,1); init so α ≈ 1-exp(-1/(τ*fs)) for hop=1 sample
        a0 = 1.0 - math.exp(-1.0 / (tau0 * FS))
        # softplus(x)=a0 → x = log(exp(a0)-1)
        x0 = math.log(math.expm1(max(a0, 1e-6)))
        self.alpha_raw = nn.Parameter(torch.tensor(float(x0)))

    @property
    def alpha(self):
        return F.softplus(self.alpha_raw).clamp(1e-4, 0.5)

    def demean(self, E):
        # E: (B, W, C) — out-of-place EMA (no inplace on autograd views)
        a = self.alpha
        B, W, C = E.shape
        frames = [a * E[:, 0]]
        for t in range(1, W):
            frames.append(a * E[:, t] + (1.0 - a) * frames[-1])
        ema = torch.stack(frames, dim=1)
        return E - ema

    def forward(self, E, S):
        return self.net(self.demean(E), S)

    def load_pub(self, path):
        sd = torch.load(resolve_model(path), map_location="cpu", weights_only=False)
        missing, unexpected = self.net.load_state_dict(sd, strict=True)
        return missing, unexpected


def pub_fold(seed, held):
    if seed == 0:
        name = f"fold_direct_clf__eaP_n5_t60_w10b3_ptSPK_aug-sw2_wts__{held}.pt"
    else:
        name = f"fold_direct_clf__eaP_n5_t60_w10b3_ptSPK_s{seed}_aug-sw2_wts__{held}.pt"
    path = os.path.join(DATA_EXP, "models", name)
    if not os.path.exists(path):
        path = resolve_model(os.path.join("models", name))
    return path


@torch.no_grad()
def logits_lb(net, x, S, step=1):
    T = len(x)
    xp = np.concatenate([np.zeros((DC.POS0, 58), np.float32), x.astype(np.float32),
                         np.zeros((DC.FUT + DC.HOP, 58), np.float32)])
    Sp = np.concatenate([np.zeros((DC.POS0,) + S.shape[1:], np.float32), S,
                         np.zeros((DC.FUT + DC.HOP,) + S.shape[1:], np.float32)])
    starts = np.arange(0, T, DC.HOP * step)
    out = np.empty(len(starts), np.float32)
    for i in range(0, len(starts), 1024):
        a = starts[i:i + 1024]
        out[i:i + len(a)] = net(
            torch.from_numpy(np.stack([xp[k:k + DC.W] for k in a])).to(DEV),
            torch.from_numpy(np.stack([Sp[k:k + DC.W] for k in a])).to(DEV),
        ).cpu().numpy()
    return out, starts


def configure(seed):
    DC.W = int(10 * FS)
    DC.POS0, DC.LAB = DC.W - DC.FUT - DC.HOP, DC.W - FS
    D["targets"] = ["env", "onset", "dom"]
    D["augment"] = {**CFG["dnn_augment"], **CFG["aug_variants"]["cluster"], "clf_p_switch2": P_SWITCH2}
    D["train_seed"] = seed
    D["model_blocks"] = 3
    D["max_epochs"] = MAX_EPOCHS
    D["steps_per_epoch"] = STEPS
    D["batch_size"] = BATCH
    D["patience"] = 6
    D["lr"] = FT_LR
    D["val_windows"] = 512
    D["weight_decay"] = float(CFG.get("weight_decay", 5e-4))
    D["lr_patience"] = int(CFG.get("lr_patience", 2))
    decoders.apply_overrides(["model_blocks=3", f"lr={FT_LR}"], [f"clf_p_switch2={P_SWITCH2}"])


def fit(train, val, init_from, seed):
    Fs = train[0]["_S"].shape[-1]
    torch.manual_seed(seed)
    net = LearnedBaselineNet(Fs, TAU0).to(DEV)
    net.load_pub(init_from)
    log(f"  init {init_from} α0={float(net.alpha):.5f} (τ≈{TAU0})")
    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, P_SWITCH, False)
    opt = torch.optim.AdamW(net.parameters(), lr=D["lr"], weight_decay=D["weight_decay"])
    best, bad, state = np.inf, 0, None
    early = []
    for ep in range(D["max_epochs"]):
        tl = []
        net.train()
        for si in range(D["steps_per_epoch"]):
            X, S_, y = [z.to(DEV) for z in DC.windows(train, BATCH, rs, aug, P_SWITCH, False)]
            loss = F.binary_cross_entropy_with_logits(net(X, S_), y)
            opt.zero_grad()
            loss.backward()
            torch.nn.utils.clip_grad_norm_(net.parameters(), 5.0)
            opt.step()
            tl.append(float(loss.detach()))
            if ep == 0 and si < 50:
                early.append(float(loss.detach()))
        if ep == 0:
            me = float(np.mean(early))
            log(f"  early@50={me:.4f} α={float(net.alpha):.5f}")
            if me >= CHANCE_LOSS:
                raise RuntimeError(f"ABORT_CHANCE {me}")
        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())
        log(f"    ep {ep:02d} train {np.mean(tl):.4f} val {vl:.4f} acc {va:.3f} α={float(net.alpha):.5f}")
        if vl < best - 1e-4:
            best, bad, state = vl, 0, {k: v.detach().clone() for k, v in net.state_dict().items()}
        elif ep >= MIN_EPOCHS:
            bad += 1
            if bad >= D["patience"]:
                break
    net.load_state_dict(state)
    net.eval()
    return net, best


def dump_ev(net, held):
    srng = np.random.default_rng(SEED + DS_KEYS.index(held))
    ev = {}
    for _, r in rows_of(held).iterrows():
        tr = load_trial(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 = logits_lb(net, x, Ssw)
        truth = (att ^ st)[np.maximum(starts - DC.HOP, 0)]
        n10 = 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 run_screen():
    open(LOG_PATH, "w").close()
    log(f"=== SCREEN learned-baseline SW2 τ0={TAU0} held-AVGC ===")
    configure(0)
    held = "AVGC"
    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():
            tr = load_trial(PREP, r["key"])
            tr["_S"] = _targets(tr)
            (val if r["subject"] == vs else train).append(tr)
    train += load_external(["Fuglsang2020"], PREP, log)
    for tr in train:
        if "_S" not in tr:
            tr["_S"] = _targets(tr)
    try:
        net, best = fit(train, val, pub_fold(0, held), 0)
    except RuntimeError as e:
        log(f"SCREEN FAIL {e}")
        shutil.rmtree(CKPT_ROOT, ignore_errors=True)
        return 1
    os.makedirs(os.path.join(CKPT_ROOT, "s0"), exist_ok=True)
    torch.save(net.state_dict(), os.path.join(CKPT_ROOT, "s0", "held-AVGC.pt"))
    ev = dump_ev(net, held)
    A = np.concatenate([(e["r0"] - e["r1"]) * np.where(e["att"] == 0, 1.0, -1.0) for e in ev.values()])
    r = S.score_dataset(held, {held: ev}, LOOKAHEAD, emis=(float(A.mean()), float(A.std()) * SCALE), p_stay=P_STAY)
    alpha = float(net.alpha)
    log(f"SCREEN AVGC H={r['H']:.4f} Acc={r['Acc']:.2f} α={alpha:.5f} τ_eff≈{-1/(FS*math.log(1-alpha)):.1f}s")
    out = dict(screen=True, avgc=dict(H=float(r["H"]), Acc=float(r["Acc"])), alpha=alpha, best_val=best)
    with open(OUT_JSON, "w") as fh:
        json.dump(out, fh, indent=1, default=float)
    Path = __import__("pathlib").Path
    Path(RESULTS_MD).write_text(
        f"# results_learned_baseline_sw2\n\nSCREEN AVGC H={r['H']:.4f} Acc={r['Acc']:.2f} α={alpha:.5f}\n"
    )
    ok = r["H"] > 0.70 and r["Acc"] > 65
    if not ok:
        shutil.rmtree(CKPT_ROOT, ignore_errors=True)
    log(f"SCREEN {'PASS' if ok else 'FAIL'}")
    return 0 if ok else 1


if __name__ == "__main__":
    raise SystemExit(run_screen() if SCREEN else 1)
