"""Causal feature-statistic AdaLN / FiLM fine-tune of stem_ms96 from SWA.

Conditioning is content-based (NOT subject/dataset/trial ID, NOT electrode XY):
causal EWMA mean and std of the 24-d multi-scale ms logit features already in
the stem pipeline (raw + hp60 + hp120 + z60 + slope + mean of 4 seed streams).
Timescales τ ∈ {1 s, 4 s} at 4 Hz → α = 1−exp(−1/τ_frames) with τ_frames∈{4,16}.

FiLM is applied after each DilatedResidual LayerNorm and after each
TransformerEncoder layer. γ,β projections are zero-init so step-0 matches the
SWA stem forward (identity AdaLN).

Distinct from MixStyle (cross-instance style mix) and from channel-XY / graph-adj
FiLM (electrode geometry).

Init: models/stem_ms96_swa/{held-*,all5}.pt. Score LODO + AASD + Carta at
p_stay 0.994 scale 0.8 + linear_hp30 on logits.

usage:
  flock multi_agent_opt/gpu.lock python -u stem_ms96_speech_adaln.py
  STEPS=80 EARLY_ABORT=1 python -u stem_ms96_speech_adaln.py   # learn check
"""
import copy
import json
import math
import os
import pickle
import time

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

import ensemble_clf_nested as N
import ensemble_clf_transformer_v2 as V
import ensemble_clf_transformer_v4 as V4
import eval_external as E
from common import DS_KEYS

EXP = os.path.dirname(os.path.abspath(__file__))
SWA_DIR = os.path.join(EXP, "models", "stem_ms96_swa")
CKPT_DIR = os.path.join(EXP, "models", "stem_ms96_speech_adaln")
LOG = os.path.join(EXP, "experiments", "stem_ms96_speech_adaln.log")
OUT = os.path.join(EXP, "results", "research", "stem_ms96_speech_adaln.json")
EVID = "/root/disk_3tb/EEG-sAAD-Grand-Challenge-Training-Dataset/experiments/decoder_lodo/results/research"
TEST_NAMES = ("AASD", "Carta2026")

STEPS = int(os.environ.get("STEPS", "1000"))
BATCH = int(os.environ.get("BATCH", "512"))
LR = float(os.environ.get("LR", "8e-4"))
EMA_DECAY = 0.995
P_STAY = 0.994
SCALE = 0.8
WINDOW = 96
CFG = ("stem_ms96_speech_adaln", "ms", 96, 64, 2, True, LR)
# ms features are 4 Hz (1 s slope uses 4 frames; 2 s mean uses 8 frames)
HZ = 4.0
TAU_SEC = (1.0, 4.0)
EARLY_ABORT_STEPS = int(os.environ.get("EARLY_ABORT_STEPS", "50"))
EARLY_ABORT_LOSS = float(os.environ.get("EARLY_ABORT_LOSS", "0.685"))


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


def ewma_alphas(hz=HZ, taus=TAU_SEC):
    """α = 1 − exp(−1/τ_frames) for each timescale in seconds."""
    out = []
    for tau in taus:
        tau_frames = max(tau * hz, 1.0)
        out.append(1.0 - math.exp(-1.0 / tau_frames))
    return tuple(out)


def causal_ewma_mean_std(x, alpha):
    """Causal EWMA mean and std of x (B, T, C) via depthwise causal conv.

    m_t = α Σ_{j=0}^t (1−α)^j x_{t−j}  (zero init), same kernel on x² for E[x²].
    """
    b, t, c = x.shape
    a = float(alpha)
    # kern[0]→oldest in window, kern[-1]→current = α; left-pad T-1 zeros
    lags = torch.arange(t - 1, -1, -1, device=x.device, dtype=x.dtype)
    kern = a * ((1.0 - a) ** lags)  # (T,)
    w = kern.view(1, 1, t).expand(c, 1, t).contiguous()
    xt = x.transpose(1, 2)  # (B, C, T)
    mean = F.conv1d(F.pad(xt, (t - 1, 0)), w, groups=c)
    sec = F.conv1d(F.pad(xt * xt, (t - 1, 0)), w, groups=c)
    std = (sec - mean * mean).clamp_min(1e-6).sqrt()
    return mean.transpose(1, 2), std.transpose(1, 2)


def causal_feat_cond(x, alphas):
    """Build (B, T, 4*C) = concat μ,σ over two EWMA timescales. Causal."""
    parts = []
    for a in alphas:
        mu, sd = causal_ewma_mean_std(x, a)
        parts.extend([mu, sd])
    return torch.cat(parts, dim=-1)


class FeatAdaLNStem(nn.Module):
    """SWA LogitTransformer + zero-init FiLM from causal ms-feature EWMA stats.

    Sites:
      - after LayerNorm inside each DilatedResidual (true AdaLN on stem)
      - after each TransformerEncoder layer (post-layer FiLM; identity at init)
    """

    def __init__(self, base: V.LogitTransformer, alphas=None):
        super().__init__()
        self.base = base
        self.alphas = alphas if alphas is not None else ewma_alphas()
        c_in = base.proj.in_features
        d_model = base.head.in_features
        cond_dim = 4 * c_in  # μ,σ × 2 taus
        n_stem = len(base.blocks)
        n_enc = len(base.enc.layers)
        self.stem_film = nn.ModuleList(
            [nn.Linear(cond_dim, 2 * d_model) for _ in range(n_stem)])
        self.enc_film = nn.ModuleList(
            [nn.Linear(cond_dim, 2 * d_model) for _ in range(n_enc)])
        for lin in list(self.stem_film) + list(self.enc_film):
            nn.init.zeros_(lin.weight)
            nn.init.zeros_(lin.bias)

    def _film(self, h, cond, lin):
        gb = lin(cond)
        gamma, beta = gb.chunk(2, dim=-1)
        return h * (1.0 + gamma) + beta

    def _dilated_adaln(self, block, x, cond, film):
        """DilatedResidual forward with FiLM after LayerNorm (AdaLN)."""
        h = block.conv(F.pad(x.transpose(1, 2), (block.pad, 0))).transpose(1, 2)
        h = block.norm(h)
        h = self._film(h, cond, film)
        return x + block.drop(F.gelu(h))

    def forward(self, x):
        raw = x
        b = self.base
        cond = causal_feat_cond(x, self.alphas)
        if b.dw is not None:
            x = x + b.dw(F.pad(x.transpose(1, 2), (b.dw_pad, 0))).transpose(1, 2)
        h = b.proj(x)
        for block, film in zip(b.blocks, self.stem_film):
            h = self._dilated_adaln(block, h, cond, film)
        h = h + b.pos[:, : h.size(1)]
        # Manual TransformerEncoder so we can FiLM after each layer.
        for layer, film in zip(b.enc.layers, self.enc_film):
            h = layer(h, src_mask=b.mask, is_causal=False)
            h = self._film(h, cond, film)
        return b.head(h).squeeze(-1) + b.skip(raw).squeeze(-1)


def load_swa_wrapped(path, device):
    blob = torch.load(path, map_location="cpu", weights_only=False)
    name, family, window, d_model, nlayers, stem, _lr = blob["cfg"]
    if name != "stem_ms96" or not stem or window != WINDOW:
        raise RuntimeError(f"unexpected stem cfg {blob['cfg']}")
    c_in = int(np.asarray(blob["mu"]).shape[0])
    base = V.LogitTransformer(c_in, window, d_model=d_model, nlayers=nlayers, stem=True)
    good_mask = base.mask.detach().clone()
    base.load_state_dict(blob["state"])
    base.mask.copy_(good_mask)
    if torch.isnan(base.mask).any():
        raise RuntimeError(f"causal mask still has nan after restore from {path}")
    net = FeatAdaLNStem(base).to(device)
    mu = np.asarray(blob["mu"], np.float32)
    sd = np.asarray(blob["sd"], np.float32)
    return net, mu, sd, list(blob.get("train", []))


def assert_feat_adaln_causal(device):
    """Zero-init FiLM must stay causal; perturbing last frame must not change earlier logits."""
    torch.manual_seed(0)
    base = V.LogitTransformer(8, 16, d_model=32, nlayers=1, stem=True)
    model = FeatAdaLNStem(base, alphas=ewma_alphas()).to(device).eval()
    x = torch.randn(2, 16, 8, device=device)
    x2 = x.clone()
    x2[:, -1] = torch.randn(2, 8, device=device)
    with torch.no_grad():
        y1 = model(x)
        y2 = model(x2)
    if not torch.allclose(y1[:, :-1], y2[:, :-1], atol=1e-4):
        raise RuntimeError("feat-AdaLN readout is not causal")
    # Identity at init vs bare stem (same weights, zero FiLM)
    bare = V.LogitTransformer(8, 16, d_model=32, nlayers=1, stem=True).to(device).eval()
    bare.load_state_dict(base.state_dict())
    with torch.no_grad():
        yb = bare(x)
        yw = model(x)
    if not torch.allclose(yb, yw, atol=1e-5):
        raise RuntimeError("zero-init AdaLN does not match bare stem")
    log_line("causality + zero-init identity checks passed")


def set_lr(opt, step, total, base):
    warm = min(40, max(total // 10, 1))
    if step < warm:
        lr = base * (step + 1) / warm
    else:
        p = (step - warm) / max(total - warm, 1)
        lr = 1e-5 + 0.5 * (base - 1e-5) * (1.0 + math.cos(math.pi * p))
    for group in opt.param_groups:
        group["lr"] = lr
    return lr


def train_fold(model, groups, y_all, mu, sd, device, steps, batch, tag):
    pos = float(y_all.mean())
    pos_weight = torch.tensor([(1.0 - pos) / max(pos, 1e-3)], device=device)
    opt = torch.optim.AdamW(model.parameters(), lr=LR, weight_decay=1e-4)
    rng = np.random.default_rng(V.TRAIN_SEED)
    ema = copy.deepcopy(model).eval()
    model.train()
    t0 = time.time()
    last = None
    for step in range(steps):
        set_lr(opt, step, steps, LR)
        xb, yb, mb = V.sample_batch(rng, groups, WINDOW, batch, mu, sd)
        x = torch.from_numpy(xb).to(device, non_blocking=True)
        y = torch.from_numpy(yb).to(device, non_blocking=True)
        m = torch.from_numpy(mb).to(device, non_blocking=True)
        x = V.augment(x)
        opt.zero_grad(set_to_none=True)
        logit = model(x)
        sw = V.switch_weights(y, m)
        bce = F.binary_cross_entropy_with_logits(logit, y, pos_weight=pos_weight, reduction="none")
        denom = (sw * m).sum().clamp_min(1.0)
        loss = (bce * sw * m).sum() / denom
        dv = (logit[:, 1:] - logit[:, :-1]).abs()
        m2 = m[:, 1:] * m[:, :-1]
        loss = loss + 0.05 * (dv * m2).sum() / m2.sum().clamp_min(1.0)
        if not torch.isfinite(loss):
            raise RuntimeError(f"non-finite loss at step {step} for {tag}")
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
        opt.step()
        V.ema_update(model, ema, EMA_DECAY)
        last = float(loss.item())
        if step + 1 == EARLY_ABORT_STEPS:
            log_line(f"    {tag} early-check step {step + 1} loss {last:.4f}")
            if last >= EARLY_ABORT_LOSS:
                raise RuntimeError(
                    f"early-abort: loss {last:.4f} >= {EARLY_ABORT_LOSS} "
                    f"after {EARLY_ABORT_STEPS} steps (not learning)")
        if step == 0 or (step + 1) % 200 == 0 or step + 1 == steps:
            # mean |γ| on first stem film as a learning signal
            with torch.no_grad():
                gnorm = float(model.stem_film[0].weight.abs().mean().cpu())
            log_line(f"    {tag} step {step + 1}/{steps} loss {last:.4f} "
                     f"|film0.w| {gnorm:.6f}")
    ema.eval()
    acc = V.train_frame_acc(ema, groups, WINDOW, mu, sd, device)
    log_line(f"  trained {tag} loss {last:.4f} frame-acc {acc:.3f} ({time.time() - t0:.0f}s)")
    return ema, dict(loss=last, frame_acc=acc)


def fit_with_oom(path, groups, y_all, device, steps, batch, tag, halved=False):
    model, mu, sd, _ = load_swa_wrapped(path, device)
    try:
        ema, stats = train_fold(model, groups, y_all, mu, sd, device, steps, batch, tag)
        return ema, mu, sd, batch, stats
    except torch.cuda.OutOfMemoryError:
        if halved:
            raise
        log_line(f"  OOM on {tag} at batch {batch}; halving once")
        del model
        if device.type == "cuda":
            torch.cuda.empty_cache()
        return fit_with_oom(path, groups, y_all, device, steps, batch // 2, tag, halved=True)


def hp30_stream(stream):
    out = {}
    for key, d in stream.items():
        out[key] = V4.highpass(np.asarray(d, np.float64)[:, None]).reshape(-1).astype(np.float64)
    return out


def score_lodo(model, feat, mu, sd, held, device):
    streams = V.infer_all(model, feat, mu, sd, WINDOW, device)
    ev = N.to_ev(streams)
    off = N.official(held, ev, P_STAY, SCALE)
    hp = {ds: hp30_stream(streams[ds]) for ds in streams}
    off_hp = N.official(held, N.to_ev(hp), P_STAY, SCALE)
    log_line(f"LODO {held} p {P_STAY} sc {SCALE}  H {off['H']:.4f} Acc {off['Acc']:.2f} "
             f"L {off['L']:.3f} SDT {off['SDT']:.2f}")
    log_line(f"LODO_hp30 {held} p {P_STAY} sc {SCALE}  H {off_hp['H']:.4f} Acc {off_hp['Acc']:.2f}")
    return dict(adaln=off, hp30=off_hp), streams


def score_external(model, feat_ext, meta, mu_in, sd_in, corpus_streams, corpus_att, device):
    parts = []
    for ds, table in corpus_streams.items():
        labels = corpus_att[ds]
        for key, d in table.items():
            parts.append(np.asarray(d, np.float64) * np.where(labels[key] == 0, 1.0, -1.0))
    mu_e = float(np.concatenate(parts).mean())
    sd_e = float(np.concatenate(parts).std())
    log_line(f"  external emissions mu {mu_e:.4f} sd {sd_e:.4f} scale {SCALE}")
    hp_corpus = {ds: hp30_stream(corpus_streams[ds]) for ds in corpus_streams}
    parts_hp = []
    for ds, table in hp_corpus.items():
        labels = corpus_att[ds]
        for key, d in table.items():
            parts_hp.append(np.asarray(d, np.float64) * np.where(labels[key] == 0, 1.0, -1.0))
    mu_hp = float(np.concatenate(parts_hp).mean())
    sd_hp = float(np.concatenate(parts_hp).std())
    log_line(f"  external hp30 emissions mu {mu_hp:.4f} sd {sd_hp:.4f} scale {SCALE}")
    rows = {}
    for ds in TEST_NAMES:
        stream = V.infer_all(model, {ds: feat_ext[ds]}, mu_in, sd_in, WINDOW, device)[ds]
        ev = {}
        for key, d in stream.items():
            m = meta[ds][key]
            d = np.asarray(d, np.float64)
            ev[key] = dict(r0=d, r1=np.zeros(len(d)), att=m["att"], t_end=m["t_end"],
                           att128=m["att128"], n128=m["n128"], subject=m["subject"])
        r = E.score(ev, mu_e, sd_e * SCALE, P_STAY, 0.75)
        stream_hp = hp30_stream(stream)
        ev_hp = {}
        for key, d in stream_hp.items():
            m = meta[ds][key]
            d = np.asarray(d, np.float64)
            ev_hp[key] = dict(r0=d, r1=np.zeros(len(d)), att=m["att"], t_end=m["t_end"],
                              att128=m["att128"], n128=m["n128"], subject=m["subject"])
        r_hp = E.score(ev_hp, mu_hp, sd_hp * SCALE, P_STAY, 0.75)
        rows[ds] = dict(adaln=r, hp30=r_hp)
        log_line(f"EXT {ds} p {P_STAY} sc {SCALE}  H {r['H']:.4f} Acc {r['Acc']:.2f} "
                 f"L {r['L']:.3f} SDT {r['SDT']:.2f}")
        log_line(f"EXT_hp30 {ds} p {P_STAY} sc {SCALE}  H {r_hp['H']:.4f} Acc {r_hp['Acc']:.2f}")
    return rows


def load_external():
    E.CONF.update(prep="eaP_n5_t60", targets=["env", "onset", "dom"])
    logits, meta = {}, {}
    for ds in TEST_NAMES:
        evs = []
        for i in range(4):
            path = os.path.join(EVID, f"ext_clf_{ds}_w10b3sw2P_evidence_s{i}.pkl")
            with open(path, "rb") as fh:
                evs.append(pickle.load(fh))
        logits[ds], meta[ds] = {}, {}
        for key in evs[0]:
            cols = [(ev[key]["r0"] - ev[key]["r1"]).astype(np.float32) for ev in evs]
            e0 = evs[0][key]
            logits[ds][key] = np.stack(cols, 1)
            meta[ds][key] = dict(
                att=np.asarray(e0["att"]), t_end=np.asarray(e0["t_end"], np.float64),
                att128=np.asarray(e0["att128"]), n128=int(e0["n128"]), subject=int(e0["subject"]))
        log_line(f"  external {ds}: {len(logits[ds])} trials")
    return logits, meta


def main():
    os.makedirs(os.path.dirname(LOG), exist_ok=True)
    open(LOG, "w").close()
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    alphas = ewma_alphas()
    log_line(f"device {device} steps {STEPS} batch {BATCH} lr {LR}")
    log_line(f"feat-AdaLN alphas={alphas} tau_sec={TAU_SEC} hz={HZ} "
             f"(cond=EWMA μ/σ of 24-d ms features; zero-init FiLM)")
    torch.backends.cuda.matmul.allow_tf32 = True
    torch.backends.cudnn.allow_tf32 = True
    V.assert_causal(device)
    assert_feat_adaln_causal(device)
    N.load_all()
    feat_all = V.build_features()["ms"]
    os.makedirs(CKPT_DIR, exist_ok=True)

    per = {}
    for held in DS_KEYS:
        path = os.path.join(SWA_DIR, f"held-{held}.pt")
        if not os.path.isfile(path):
            raise FileNotFoundError(path)
        train_ds = [d for d in DS_KEYS if d != held]
        groups, y_all = V.trial_groups(feat_all, train_ds)
        log_line(f"fold held-out={held} init {path}")
        ema, mu, sd, used, stats = fit_with_oom(
            path, groups, y_all, device, STEPS, BATCH, f"held-{held}")
        torch.save({"state": ema.state_dict(), "mu": mu, "sd": sd, "swa": path,
                    "train": train_ds, "steps": STEPS, "batch": used,
                    "alphas": alphas, "tau_sec": TAU_SEC, "stats": stats, "cfg": CFG},
                   os.path.join(CKPT_DIR, f"held-{held}.pt"))
        scores, _ = score_lodo(ema, feat_all, mu, sd, held, device)
        per[held] = dict(scores=scores, stats=stats, batch=used)
        del ema
        if device.type == "cuda":
            torch.cuda.empty_cache()

    all_path = os.path.join(SWA_DIR, "all5.pt")
    log_line(f"all-5 feat-AdaLN fine-tune for AASD/Carta, init {all_path}")
    groups, y_all = V.trial_groups(feat_all, list(DS_KEYS))
    ema, mu, sd, used, stats = fit_with_oom(
        all_path, groups, y_all, device, STEPS, BATCH, "all5")
    torch.save({"state": ema.state_dict(), "mu": mu, "sd": sd, "swa": all_path,
                "train": list(DS_KEYS), "steps": STEPS, "batch": used,
                "alphas": alphas, "tau_sec": TAU_SEC, "stats": stats, "cfg": CFG},
               os.path.join(CKPT_DIR, "all5.pt"))
    corpus_streams = V.infer_all(ema, feat_all, mu, sd, WINDOW, device)
    ext_logits, ext_meta = load_external()
    ext_feat = V4.build_features_from(ext_logits)["ms"]
    ext = score_external(ema, ext_feat, ext_meta, mu, sd, corpus_streams, N.G["att"], device)

    mean_h = float(np.mean([per[d]["scores"]["adaln"]["H"] for d in DS_KEYS]))
    mean_acc = float(np.mean([per[d]["scores"]["adaln"]["Acc"] for d in DS_KEYS]))
    log_line(f"LODO mean H {mean_h:.4f} Acc {mean_acc:.2f}")

    out = dict(
        method="causal_ms_feat_ewma_adaln",
        note=("AdaLN/FiLM from causal EWMA mean/std of 24-d ms features "
              "(speech-related seed-logit dynamics); no subject/dataset/trial ID"),
        p_stay=P_STAY, scale=SCALE, steps=STEPS, batch=BATCH,
        alphas=alphas, tau_sec=TAU_SEC, hz=HZ,
        lodo={d: per[d]["scores"] for d in DS_KEYS},
        lodo_stats={d: per[d]["stats"] for d in DS_KEYS},
        lodo_mean=dict(H=mean_h, Acc=mean_acc),
        external=ext,
        all5_stats=stats,
    )
    os.makedirs(os.path.dirname(OUT), exist_ok=True)
    with open(OUT, "w") as fh:
        json.dump(out, fh, indent=1, default=float)
    log_line(f"wrote {OUT}")


if __name__ == "__main__":
    main()
