"""Label-free causal test-time adaptation on frozen stem_ms96.

MixStyle on vlaai_ws is already scored (technique agent). PATH 2:
within each trial, without labels,

  1) mild causal feature running-stat re-normalisation (blend train mu/sd with
     an EMA of past frames; blend weight capped);
  2) mild online entropy-minimisation of a scale-only affine on the frozen
     logit (a updated after emitting; no bias, so signs cannot flip).

HMM fixed at p_stay 0.994, emission scale 0.8. No HMM retune on test labels.
Weights never updated.

Checkpoints: published stem_ms96 held-* for LODO; SWA all5 for external.

Env:
  TTA_MODE = both|feat|ent|none   (default both)
  TTA_FEAT_ALPHA, TTA_FEAT_WARM, TTA_FEAT_MAX_W
  TTA_ENT_LR, TTA_ENT_CLIP
  TTA_SKIP_FROZEN=1  skip frozen re-score (use published stem / SWA numbers)
  TTA_HELD=AVGC,DTU,...  optional subset of LODO folds

usage:
  python stem_ms96_tta.py
"""
import json
import math
import os
import pickle
import time

import numpy as np
import torch
from scipy.signal import lfilter

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__))
STEM_DIR = os.path.join(EXP, "models", "logit_tf_v2")
SWA_DIR = os.path.join(EXP, "models", "stem_ms96_swa")
LOG = os.path.join(EXP, "experiments", "stem_ms96_tta.log")
OUT = os.path.join(EXP, "results", "research", "stem_ms96_tta.json")
EVID = "/root/disk_3tb/EEG-sAAD-Grand-Challenge-Training-Dataset/experiments/decoder_lodo/results/research"
TEST_NAMES = ("AASD", "Carta2026")

WINDOW = 96
P_STAY = 0.994
SCALE = 0.8
MODE = os.environ.get("TTA_MODE", "both").strip().lower()
FEAT_ALPHA = float(os.environ.get("TTA_FEAT_ALPHA", "0.02"))
FEAT_WARM = float(os.environ.get("TTA_FEAT_WARM", "80"))
FEAT_MAX_W = float(os.environ.get("TTA_FEAT_MAX_W", "0.25"))
ENT_LR = float(os.environ.get("TTA_ENT_LR", "0.01"))
ENT_CLIP = float(os.environ.get("TTA_ENT_CLIP", "0.25"))
SKIP_FROZEN = os.environ.get("TTA_SKIP_FROZEN", "1") == "1"
HELD_LIST = os.environ.get("TTA_HELD", "").strip()
HELD_KEYS = [h.strip() for h in HELD_LIST.split(",") if h.strip()] or list(DS_KEYS)

# published stem_ms96 (preset) for LODO frozen reference when skipping re-score
PUB_STEM = {
    "AVGC": dict(H=0.7945, Acc=74.06),
    "DTU": dict(H=0.9061, Acc=89.85),
    "KUL": dict(H=0.8755, Acc=82.33),
    "UHD": dict(H=0.8407, Acc=79.47),
    "USTC": dict(H=0.9219, Acc=86.36),
}
PUB_SWA_EXT = {
    "AASD": dict(H=0.6202, Acc=51.08),
    "Carta2026": dict(H=0.5507, Acc=48.68),
}


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 load_stem(path, device):
    blob = torch.load(path, map_location="cpu", weights_only=False)
    _name, _family, window, d_model, nlayers, stem, _lr = blob["cfg"]
    if window != WINDOW:
        raise RuntimeError(f"unexpected window {window} in {path}")
    c_in = int(np.asarray(blob["mu"]).shape[0])
    net = V.LogitTransformer(c_in, window, d_model=d_model, nlayers=nlayers, stem=bool(stem))
    net.load_state_dict(blob["state"])
    net = net.to(device).eval()
    for p in net.parameters():
        p.requires_grad_(False)
    mu = np.asarray(blob["mu"], np.float32)
    sd = np.asarray(blob["sd"], np.float32)
    return net, mu, sd


def causal_feature_stats(X, alpha):
    X = np.asarray(X, np.float64)
    a = float(alpha)
    b_coef = [a]
    a_coef = [1.0, -(1.0 - a)]
    zi = X[0:1] * (1.0 - a)
    mu, _ = lfilter(b_coef, a_coef, X, axis=0, zi=zi)
    second, _ = lfilter(b_coef, a_coef, X * X, axis=0, zi=X[0:1] * X[0:1] * (1.0 - a))
    var = np.maximum(second - mu * mu, 1e-6)
    return mu.astype(np.float32), np.sqrt(var).astype(np.float32)


def entropy_scale(z, lr=ENT_LR, clip=ENT_CLIP):
    """Causal online entropy-min scale-only: emit a_t * z_t then update a on z_t. No bias."""
    z = np.asarray(z, np.float64)
    out = np.empty_like(z)
    a = 1.0
    for t in range(len(z)):
        out[t] = a * z[t]
        l = out[t]
        if l >= 0:
            e = math.exp(-l)
            p = 1.0 / (1.0 + e)
        else:
            e = math.exp(l)
            p = e / (1.0 + e)
        p = min(max(p, 1e-6), 1.0 - 1e-6)
        dH_dl = p * (1.0 - p) * math.log((1.0 - p) / p)
        a -= lr * dH_dl * z[t]
        a = min(max(a, 1.0 - clip), 1.0 + clip)
    return out


@torch.no_grad()
def infer_trial(model, X, mu_train, sd_train, window, device, mode):
    X = np.asarray(X, np.float32)
    T, C = X.shape
    use_feat = mode in ("both", "feat")
    use_ent = mode in ("both", "ent")
    pad = np.zeros((window - 1, C), np.float32)
    xp = np.concatenate([pad, X], 0)
    pieces = []
    if use_feat:
        run_mu, run_sd = causal_feature_stats(X.astype(np.float64), FEAT_ALPHA)
    for i in range(0, T, 2048):
        n = min(2048, T - i)
        sl = torch.from_numpy(xp[i:i + n + window - 1])
        w = sl.unfold(0, window, 1).permute(0, 2, 1).contiguous()
        if use_feat:
            idx = np.arange(i, i + n)
            w_mix = np.minimum(FEAT_MAX_W, (idx + 1) / max(FEAT_WARM, 1.0)).astype(np.float32)
            mu_b = (1.0 - w_mix)[:, None] * mu_train[None, :] + w_mix[:, None] * run_mu[idx]
            sd_b = (1.0 - w_mix)[:, None] * sd_train[None, :] + w_mix[:, None] * run_sd[idx]
            mu_b = torch.from_numpy(mu_b[:, None, :])
            sd_b = torch.from_numpy(sd_b[:, None, :]).clamp_min(1e-3)
            w = (w - mu_b) / sd_b
        else:
            mu_t = torch.from_numpy(mu_train.reshape(1, 1, -1))
            sd_t = torch.from_numpy(sd_train.reshape(1, 1, -1))
            w = (w - mu_t) / sd_t
        pieces.append(model(w.to(device))[:, -1].cpu().numpy())
    pred = np.concatenate(pieces).astype(np.float64)
    if len(pred) != T:
        raise RuntimeError(f"length {len(pred)} != {T}")
    if use_ent:
        pred = entropy_scale(pred)
    return pred


@torch.no_grad()
def infer_all_tta(model, feat_ds, mu, sd, window, device, mode):
    model.eval()
    out = {}
    for ds, table in feat_ds.items():
        out[ds] = {}
        for key, X in table.items():
            out[ds][key] = infer_trial(model, X, mu, sd, window, device, mode)
    return out


def score_lodo(streams, held):
    return N.official(held, N.to_ev(streams), P_STAY, SCALE)


def score_external(stream, meta, mu_e, sd_e):
    ev = {}
    for key, d in stream.items():
        m = meta[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"])
    return E.score(ev, mu_e, sd_e * SCALE, P_STAY, 0.75)


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 emissions_from(streams, att):
    parts = []
    for ds, table in streams.items():
        labels = att[ds]
        for key, d in table.items():
            parts.append(np.asarray(d, np.float64) * np.where(labels[key] == 0, 1.0, -1.0))
    A = np.concatenate(parts)
    return float(A.mean()), float(A.std())


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")
    log_line(f"device {device} mode {MODE} feat_alpha {FEAT_ALPHA} feat_warm {FEAT_WARM} "
             f"feat_max_w {FEAT_MAX_W} ent_lr {ENT_LR} ent_clip {ENT_CLIP} "
             f"p_stay {P_STAY} scale {SCALE} held {HELD_KEYS}")
    torch.backends.cuda.matmul.allow_tf32 = True
    torch.backends.cudnn.allow_tf32 = True
    V.assert_causal(device)
    N.load_all()
    feat_all = V.build_features()["ms"]

    lodo = {}
    for held in HELD_KEYS:
        path = os.path.join(STEM_DIR, f"stem_ms96__held-{held}.pt")
        log_line(f"LODO held-out={held} ckpt {path}")
        model, mu, sd = load_stem(path, device)
        t0 = time.time()
        streams = infer_all_tta(model, feat_all, mu, sd, WINDOW, device, MODE)
        off = score_lodo(streams, held)
        log_line(f"LODO_tta {held}  H {off['H']:.4f} Acc {off['Acc']:.2f} "
                 f"L {off['L']:.3f} SDT {off['SDT']:.2f} ({time.time() - t0:.0f}s)")
        if SKIP_FROZEN:
            off_fr = dict(PUB_STEM[held])
            log_line(f"LODO_frozen {held}  H {off_fr['H']:.4f} Acc {off_fr['Acc']:.2f} (published)")
        else:
            streams_fr = V.infer_all(model, feat_all, mu, sd, WINDOW, device)
            off_fr = score_lodo(streams_fr, held)
            log_line(f"LODO_frozen {held}  H {off_fr['H']:.4f} Acc {off_fr['Acc']:.2f}")
        lodo[held] = dict(tta=off, frozen=off_fr)
        del model, streams
        if device.type == "cuda":
            torch.cuda.empty_cache()

    mean_tta_h = float(np.mean([lodo[d]["tta"]["H"] for d in HELD_KEYS]))
    mean_tta_acc = float(np.mean([lodo[d]["tta"]["Acc"] for d in HELD_KEYS]))
    mean_fr_h = float(np.mean([lodo[d]["frozen"]["H"] for d in HELD_KEYS]))
    mean_fr_acc = float(np.mean([lodo[d]["frozen"]["Acc"] for d in HELD_KEYS]))
    log_line(f"LODO_tta mean H {mean_tta_h:.4f} Acc {mean_tta_acc:.2f}")
    log_line(f"LODO_frozen mean H {mean_fr_h:.4f} Acc {mean_fr_acc:.2f}")

    all5 = os.path.join(SWA_DIR, "all5.pt")
    log_line(f"external ckpt {all5}")
    model, mu, sd = load_stem(all5, device)
    t0 = time.time()
    corpus = infer_all_tta(model, feat_all, mu, sd, WINDOW, device, MODE)
    mu_e, sd_e = emissions_from(corpus, N.G["att"])
    log_line(f"  corpus_tta emissions mu {mu_e:.4f} sd {sd_e:.4f} ({time.time() - t0:.0f}s)")

    ext_logits, ext_meta = load_external()
    ext_feat = V4.build_features_from(ext_logits)["ms"]
    external = {}
    for ds in TEST_NAMES:
        st = infer_all_tta(model, {ds: ext_feat[ds]}, mu, sd, WINDOW, device, MODE)[ds]
        r = score_external(st, ext_meta[ds], mu_e, sd_e)
        external[ds] = dict(tta=r, frozen=PUB_SWA_EXT[ds])
        log_line(f"EXT_tta {ds}  H {r['H']:.4f} Acc {r['Acc']:.2f} "
                 f"L {r['L']:.3f} SDT {r['SDT']:.2f}")
        log_line(f"EXT_frozen {ds}  H {PUB_SWA_EXT[ds]['H']:.4f} Acc {PUB_SWA_EXT[ds]['Acc']:.2f} (SWA)")

    out = dict(
        method="label-free causal TTA (mild feature running-stat + scale-only entropy-min)",
        mode=MODE,
        base_lodo="stem_ms96__held-*",
        base_external="stem_ms96_swa/all5.pt",
        p_stay=P_STAY, scale=SCALE,
        feat_alpha=FEAT_ALPHA, feat_warm=FEAT_WARM, feat_max_w=FEAT_MAX_W,
        ent_lr=ENT_LR, ent_clip=ENT_CLIP,
        lodo={d: lodo[d] for d in HELD_KEYS},
        lodo_mean=dict(tta=dict(H=mean_tta_h, Acc=mean_tta_acc),
                       frozen=dict(H=mean_fr_h, Acc=mean_fr_acc)),
        external=external,
        aggressive_v1=dict(
            note="first run both/feat_alpha0.05/warm40/ent_lr0.05+bias collapsed LODO",
            lodo_mean_tta=dict(H=0.3927, Acc=59.10),
            AASD=dict(H=0.5776, Acc=50.65),
            Carta2026=dict(H=0.6065, Acc=50.51),
        ),
    )
    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()
