"""Causal seed-reliability weights on 4-seed classifier logits.

CPU-only. Past-only / causal. Always emit a weighted mean (no hard hold/zero).
NOT seed-disagree hard-hold/soft-shrink. NOT fuse↔hp30 MoE/emis/MMD/xσ. NOT multi-τ bank.

Variants (label-free):
  1. invvar:   per-seed EWMA variance of logit; w∝1/(σ²+ε); weighted mean.
               τ∈{4,8,15,30}s on raw seeds and/or after causal hp30 per seed.
  2. agree:    w∝exp(−β·EWMA|s_i−median_others|); β∈{0.5,1,2,4}; τ∈{4,8}.
  3. softneg:  softmax(−EWMA|s_i−mean|/T); mean=equal mean; T∈{0.25,0.5,1,2}; τ∈{4,8}.
  4. baselines: equal_mean (raw), linear_hp30.

Select by mean LODO Acc then H @ HMM 0.994/0.8. Never AASD/Carta labels.
Score LODO + AASD + Carta @0.994/0.8. Report ΔAcc vs linear_hp30 53.12.

usage:
  PYTHONPATH=.../reports/eda_full/scripts:$PYTHONPATH \\
    .../.venv/bin/python -u seed_reliability_weights.py
"""
from __future__ import annotations

import json
import os
import time

import numpy as np
from scipy.signal import lfilter

import ensemble_clf as EC
import ensemble_clf_nested as N
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__))
LOG = os.path.join(EXP, "experiments", "seed_reliability_weights.log")
OUT = os.path.join(EXP, "results", "research", "seed_reliability_weights.json")
CKPT = os.path.join(EXP, "models", "seed_reliability_weights")

CORPUS = ("AVGC", "DTU", "KUL", "UHD", "USTC")
TEST_NAMES = ("AASD", "Carta2026")
P_STAY = 0.994
SCALE = 0.8
LOOKAHEAD = 0.75
HOP = 0.25
EPS = 1e-6

INVVAR_TAUS = (4.0, 8.0, 15.0, 30.0)
AGREE_BETAS = (0.5, 1.0, 2.0, 4.0)
AGREE_TAUS = (4.0, 8.0)
SOFT_TS = (0.25, 0.5, 1.0, 2.0)
SOFT_TAUS = (4.0, 8.0)

LINEAR_HP30_BASELINE = dict(
    AASD=dict(H=0.6422, Acc=53.12),
    Carta2026=dict(H=0.6520, Acc=60.54),
    LODO_mean=dict(H=0.7899, Acc=69.21),
)


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 alpha_from_tau(tau):
    return float(1.0 - np.exp(-HOP / float(tau)))


def ewma_2d(X, tau):
    """Causal EWMA along time for (T,K). Past-inclusive at emit t."""
    X = np.asarray(X, np.float64)
    if X.ndim == 1:
        X = X.reshape(-1, 1)
        squeeze = True
    else:
        squeeze = False
    a = alpha_from_tau(tau)
    T, K = X.shape
    Y = np.empty_like(X)
    for k in range(K):
        y, _ = lfilter(
            [a], [1.0, -(1.0 - a)], X[:, k],
            zi=np.asarray([X[0, k] * (1.0 - a)], np.float64),
        )
        Y[:, k] = y
    return Y.reshape(-1) if squeeze else Y


def ewma_var_2d(X, tau):
    """Per-column causal EWMA variance: μ=EWMA(x), v=EWMA((x−μ)²)."""
    X = np.asarray(X, np.float64)
    mu = ewma_2d(X, tau)
    return ewma_2d((X - mu) ** 2, tau)


def abs_dev_median_others(X):
    """|s_i − median(others)| for K=4. X: (T,4)."""
    X = np.asarray(X, np.float64)
    T, K = X.shape
    if K != 4:
        raise ValueError(f"expected 4 seeds, got {K}")
    out = np.empty_like(X)
    for i in range(K):
        others = np.concatenate([X[:, :i], X[:, i + 1 :]], axis=1)
        med = np.median(others, axis=1)
        out[:, i] = np.abs(X[:, i] - med)
    return out


def normalize_weights(W):
    W = np.asarray(W, np.float64)
    s = W.sum(axis=1, keepdims=True)
    s = np.maximum(s, EPS)
    return W / s


def weighted_mean(X, W):
    return (np.asarray(X, np.float64) * np.asarray(W, np.float64)).sum(axis=1)


def seed_stack(D, use_hp):
    D = np.asarray(D, np.float64)
    if use_hp:
        D = V4.highpass(D).astype(np.float64)
    return D


def weights_invvar(X, tau):
    var = ewma_var_2d(X, tau)
    return normalize_weights(1.0 / (var + EPS))


def weights_agree(X, tau, beta):
    d = ewma_2d(abs_dev_median_others(X), tau)
    return normalize_weights(np.exp(-float(beta) * d))


def weights_softneg(X, tau, temperature):
    """Softmax(−EWMA|s_i − mean|/T); mean = equal mean of seeds at each frame."""
    eq = X.mean(axis=1, keepdims=True)
    d = ewma_2d(np.abs(X - eq), tau)
    T = max(float(temperature), EPS)
    logits = -d / T
    logits = logits - logits.max(axis=1, keepdims=True)
    W = np.exp(logits)
    return normalize_weights(W)


def apply_one(D, family, use_hp, tau=None, beta=None, temperature=None):
    """Return 1-D evidence for one trial (T,)."""
    X = seed_stack(D, use_hp)
    if family == "equal":
        return X.mean(1).astype(np.float64)
    if family == "invvar":
        W = weights_invvar(X, tau)
    elif family == "agree":
        W = weights_agree(X, tau, beta)
    elif family == "softneg":
        W = weights_softneg(X, tau, temperature)
    else:
        raise ValueError(family)
    return weighted_mean(X, W).astype(np.float64)


def apply_variant(logits_4d, family, use_hp, tau=None, beta=None, temperature=None):
    out = {}
    for ds, table in logits_4d.items():
        out[ds] = {}
        for k, D in table.items():
            out[ds][k] = apply_one(D, family, use_hp, tau=tau, beta=beta, temperature=temperature)
    return out


def emissions_from(streams, att, datasets):
    parts = []
    for ds in datasets:
        labels = att[ds]
        for key, d in streams[ds].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 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, LOOKAHEAD)


def load_lodo_4d():
    import score as S
    evs = []
    for _seed, exp in EC.SEEDS:
        ev, _info = S.load_folds(exp, "causal")
        evs.append(ev)
    logits = {}
    for ds in DS_KEYS:
        logits[ds] = {}
        for k in evs[0][ds].keys():
            cols = [EC.delta(ev[ds][k]) for ev in evs]
            logits[ds][k] = np.stack(cols, 1).astype(np.float64)
    return logits


def build_variants():
    """List of selectable variants + baselines."""
    variants = []
    # baselines
    variants.append(dict(
        name="equal_mean", family="equal", use_hp=False,
        tau=None, beta=None, temperature=None, selectable=True,
    ))
    variants.append(dict(
        name="linear_hp30", family="equal", use_hp=True,
        tau=None, beta=None, temperature=None, selectable=True,
    ))
    # inv-variance
    for use_hp in (False, True):
        tag = "hp30" if use_hp else "raw"
        for tau in INVVAR_TAUS:
            variants.append(dict(
                name=f"invvar_{tag}_t{int(tau)}", family="invvar", use_hp=use_hp,
                tau=float(tau), beta=None, temperature=None, selectable=True,
            ))
    # EWMA agreement (raw + hp30)
    for use_hp in (False, True):
        tag = "hp30" if use_hp else "raw"
        for tau in AGREE_TAUS:
            for beta in AGREE_BETAS:
                btag = str(beta).replace(".", "p")
                variants.append(dict(
                    name=f"agree_{tag}_t{int(tau)}_b{btag}", family="agree", use_hp=use_hp,
                    tau=float(tau), beta=float(beta), temperature=None, selectable=True,
                ))
    # Softmax negative deviation
    for use_hp in (False, True):
        tag = "hp30" if use_hp else "raw"
        for tau in SOFT_TAUS:
            for T in SOFT_TS:
                ttag = str(T).replace(".", "p")
                variants.append(dict(
                    name=f"softneg_{tag}_t{int(tau)}_T{ttag}", family="softneg", use_hp=use_hp,
                    tau=float(tau), beta=None, temperature=float(T), selectable=True,
                ))
    return variants


def pick_variant(lodo_means, variants):
    selectable = {v["name"] for v in variants if v.get("selectable", True)}
    best_name, best_key = None, None
    for name, m in lodo_means.items():
        if name not in selectable:
            continue
        key = (float(m["Acc"]), float(m["H"]))
        if best_key is None or key > best_key:
            best_key, best_name = key, name
    return best_name


def main():
    os.makedirs(os.path.dirname(LOG), exist_ok=True)
    os.makedirs(CKPT, exist_ok=True)
    open(LOG, "w").close()
    t_all = time.time()
    log_line(f"seed-reliability-weights CPU-only  p_stay {P_STAY} scale {SCALE}")
    log_line("honesty: past-only invvar/agree/softneg weights → weighted mean; always emit")
    log_line("NOT seed-disagree hard-hold; NOT fuse↔hp30; NOT multi-tau bank")
    log_line("select LODO Acc then H; never AASD/Carta labels")

    N.load_all()

    log_line("loading CACHE train + external 4-seed evidence")
    cache_logits, cache_att = V4.load_train()
    src_cache = {ds: cache_logits[ds] for ds in CORPUS}
    train_att = {ds: cache_att[ds] for ds in CORPUS}
    test_logits, test_meta = V4.load_test()

    log_line("loading LODO fold 4-seed logits")
    lodo_4d = load_lodo_4d()

    variants = build_variants()
    log_line(f"n_variants {len(variants)}")

    results = dict(
        method="seed-reliability-weights: causal invvar/agree/softneg weighted mean of 4 seeds",
        p_stay=P_STAY, scale=SCALE,
        honesty="past-only weights; LODO Acc then H; no AASD/Carta labels; always emit",
        baselines=LINEAR_HP30_BASELINE,
        variants={},
    )

    log_line("=== LODO (fixed HMM; selection) ===")
    lodo_means = {}
    for v in variants:
        name = v["name"]
        t0 = time.time()
        adapted = apply_variant(
            lodo_4d, v["family"], v["use_hp"],
            tau=v["tau"], beta=v["beta"], temperature=v["temperature"],
        )
        per = {}
        for held in DS_KEYS:
            off = N.official(held, N.to_ev(adapted), P_STAY, SCALE)
            per[held] = off
            log_line(f"LODO {name:36s} {held:5s}  H {off['H']:.4f} Acc {off['Acc']:.2f}")
        mean_h = float(np.mean([per[d]["H"] for d in DS_KEYS]))
        mean_a = float(np.mean([per[d]["Acc"] for d in DS_KEYS]))
        log_line(f"LODO_MEAN {name:36s}  H {mean_h:.4f} Acc {mean_a:.2f}  ({time.time()-t0:.0f}s)")
        lodo_means[name] = dict(H=mean_h, Acc=mean_a)
        results["variants"][name] = dict(
            family=v["family"], use_hp=v["use_hp"], tau=v["tau"],
            beta=v["beta"], temperature=v["temperature"],
            lodo=per, lodo_mean=dict(H=mean_h, Acc=mean_a),
        )

    selected = pick_variant(lodo_means, variants)
    log_line(
        f"SELECTED (LODO Acc then H): {selected}  "
        f"H {lodo_means[selected]['H']:.4f} Acc {lodo_means[selected]['Acc']:.2f}"
    )
    results["selected"] = selected

    # Top-10 LODO for quick glance
    ranked = sorted(lodo_means.items(), key=lambda kv: (kv[1]["Acc"], kv[1]["H"]), reverse=True)
    results["lodo_rank"] = [
        dict(name=n, Acc=m["Acc"], H=m["H"]) for n, m in ranked
    ]
    log_line("LODO top-10:")
    for n, m in ranked[:10]:
        log_line(f"  {n:36s}  H {m['H']:.4f} Acc {m['Acc']:.2f}")

    log_line("=== external ===")
    for v in variants:
        name = v["name"]
        adapted_train = apply_variant(
            src_cache, v["family"], v["use_hp"],
            tau=v["tau"], beta=v["beta"], temperature=v["temperature"],
        )
        mu_e, sd_e = emissions_from(adapted_train, train_att, list(CORPUS))
        adapted_test = apply_variant(
            test_logits, v["family"], v["use_hp"],
            tau=v["tau"], beta=v["beta"], temperature=v["temperature"],
        )
        ext = {}
        for ds in TEST_NAMES:
            r = score_external(adapted_test[ds], test_meta[ds], mu_e, sd_e)
            ext[ds] = r
            base_acc = LINEAR_HP30_BASELINE[ds]["Acc"]
            dacc = r["Acc"] - base_acc
            log_line(
                f"EXT {name:36s} {ds:10s}  H {r['H']:.4f} Acc {r['Acc']:.2f}  "
                f"ΔAcc vs linear_hp30 {dacc:+.2f}"
            )
        results["variants"][name]["external"] = ext
        results["variants"][name]["emis"] = dict(mu=mu_e, sd=sd_e)

    prim = results["variants"][selected]
    aasd = prim["external"]["AASD"]
    carta = prim["external"]["Carta2026"]
    d_aasd = aasd["Acc"] - LINEAR_HP30_BASELINE["AASD"]["Acc"]
    results["headline"] = dict(
        selected=selected,
        AASD=aasd, Carta2026=carta,
        AASD_Acc_delta_vs_linear_hp30=d_aasd,
        lodo_mean=prim["lodo_mean"],
        AVGC=prim["lodo"].get("AVGC"),
    )
    log_line(
        f"HEADLINE {selected} AASD H {aasd['H']:.4f} Acc {aasd['Acc']:.2f} "
        f"(Δ {d_aasd:+.2f} vs 53.12)  Carta H {carta['H']:.4f} Acc {carta['Acc']:.2f}"
    )
    log_line(
        f"HEADLINE LODO mean H {prim['lodo_mean']['H']:.4f} Acc {prim['lodo_mean']['Acc']:.2f}"
    )
    if "AVGC" in prim["lodo"]:
        av = prim["lodo"]["AVGC"]
        log_line(f"HEADLINE AVGC H {av['H']:.4f} Acc {av['Acc']:.2f}")

    os.makedirs(os.path.dirname(OUT), exist_ok=True)
    with open(OUT, "w") as fh:
        json.dump(results, fh, indent=1, default=float)
    with open(os.path.join(CKPT, "selection.json"), "w") as fh:
        json.dump(
            dict(selected=selected, lodo_means=lodo_means, lodo_rank=results["lodo_rank"]),
            fh, indent=1,
        )
    log_line(f"wrote {OUT} ({time.time() - t_all:.0f}s)")


if __name__ == "__main__":
    main()
