"""Causal seed power-mean / trim / softmax-|logit| fusion of 4-seed logits.

CPU-only. Past-only / causal. Always emit a fused 1-D stream.

Variants (label-free):
  1. Power mean: sign-aware |x|^p mean, p∈{0.5,1,1.5,2,3}; optional 1-D hp30 after.
  2. Trim/agree: drop seed farthest from median, OR drop lowest past-only EWMA |logit|;
     then mean of remaining 3; optional 1-D hp30.
  3. Softmax-|logit| weights: static per-frame |s_i| or past-only EWMA(|s_i|) → softmax
     → weighted mean; then optional 1-D hp30.

Baselines: equal_mean, linear_hp30 (per-seed hp30 then mean).

NOT rank-gauss / seed-reliability / multi-tau / CORAL / fuse↔hp30 / Platt-calib.

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_power_trim.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_power_trim.log")
OUT = os.path.join(EXP, "results", "research", "seed_power_trim.json")
CKPT = os.path.join(EXP, "models", "seed_power_trim")

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-8

POWER_PS = (0.5, 1.0, 1.5, 2.0, 3.0)
TRIM_ABS_TAUS = (4.0, 8.0)
SOFT_TS = (0.25, 0.5, 1.0, 2.0)
SOFT_EWMA_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 hp30_1d(x):
    """Causal 1-D tau=30 high-pass (same one-pole as V4.highpass)."""
    return np.asarray(V4.highpass(np.asarray(x, np.float64).reshape(-1, 1)), np.float64).reshape(-1)


def sign_aware_power_mean(X, p):
    """Sign-aware power mean over seeds: y=mean(sign(x)|x|^p); out=sign(y)|y|^(1/p).

    For p=1 this recovers the arithmetic mean.
    """
    X = np.asarray(X, np.float64)
    p = float(p)
    signed = np.sign(X) * np.power(np.abs(X) + EPS, p)
    y = signed.mean(axis=1)
    return np.sign(y) * np.power(np.abs(y) + EPS, 1.0 / p)


def _mean_drop_one(X, drop):
    """Mean over seeds after dropping column index `drop` per row."""
    X = np.asarray(X, np.float64)
    Y = X.copy()
    Y[np.arange(len(X)), drop] = np.nan
    return np.nanmean(Y, axis=1)


def trim_far_median(X):
    """Drop the seed farthest from the per-frame median; mean of remaining."""
    X = np.asarray(X, np.float64)
    med = np.median(X, axis=1, keepdims=True)
    drop = np.abs(X - med).argmax(axis=1)
    return _mean_drop_one(X, drop)


def trim_low_abs_ewma(X, tau):
    """Drop seed with lowest past-only EWMA(|logit|); mean of remaining."""
    X = np.asarray(X, np.float64)
    drop = ewma_2d(np.abs(X), tau).argmin(axis=1)
    return _mean_drop_one(X, drop)


def softabs_weights(mag, temperature):
    """Softmax of magnitudes / T along seed axis. mag: (T,K)."""
    T = max(float(temperature), EPS)
    logits = np.asarray(mag, np.float64) / T
    logits = logits - logits.max(axis=1, keepdims=True)
    W = np.exp(logits)
    s = np.maximum(W.sum(axis=1, keepdims=True), EPS)
    return W / s


def softabs_weighted_mean(X, temperature, tau=None):
    """Weighted mean with softmax(|s|) or softmax(EWMA(|s|))."""
    X = np.asarray(X, np.float64)
    if tau is None:
        mag = np.abs(X)
    else:
        mag = ewma_2d(np.abs(X), tau)
    W = softabs_weights(mag, temperature)
    return (X * W).sum(axis=1)


def apply_one(D, family, p=None, tau=None, temperature=None, after_hp=False):
    """Return 1-D evidence for one trial (T,)."""
    X = np.asarray(D, np.float64)
    if family == "equal":
        out = X.mean(1)
    elif family == "linear_hp30":
        out = np.asarray(V4.highpass(X), np.float64).mean(1)
    elif family == "pmean":
        out = sign_aware_power_mean(X, p)
    elif family == "trim_far":
        out = trim_far_median(X)
    elif family == "trim_low":
        out = trim_low_abs_ewma(X, tau)
    elif family == "softabs":
        out = softabs_weighted_mean(X, temperature, tau=tau)
    else:
        raise ValueError(family)
    out = np.asarray(out, np.float64)
    if after_hp:
        out = hp30_1d(out)
    return out.astype(np.float64)


def apply_variant(logits_4d, family, p=None, tau=None, temperature=None, after_hp=False):
    out = {}
    for ds, table in logits_4d.items():
        out[ds] = {}
        for k, D in table.items():
            out[ds][k] = apply_one(
                D, family, p=p, tau=tau, temperature=temperature, after_hp=after_hp,
            )
    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 _ptag(p):
    return str(p).replace(".", "p")


def _ttag(T):
    return str(T).replace(".", "p")


def build_variants():
    variants = []
    variants.append(dict(
        name="equal_mean", family="equal", p=None, tau=None,
        temperature=None, after_hp=False, selectable=True,
    ))
    variants.append(dict(
        name="linear_hp30", family="linear_hp30", p=None, tau=None,
        temperature=None, after_hp=False, selectable=True,
    ))

    # 1) sign-aware power mean ± post hp30
    for p in POWER_PS:
        for after_hp in (False, True):
            suffix = "_hp30" if after_hp else ""
            variants.append(dict(
                name=f"pmean_p{_ptag(p)}{suffix}",
                family="pmean", p=float(p), tau=None,
                temperature=None, after_hp=after_hp, selectable=True,
            ))

    # 2) trim farthest-from-median ± post hp30
    for after_hp in (False, True):
        suffix = "_hp30" if after_hp else ""
        variants.append(dict(
            name=f"trim_far_med{suffix}",
            family="trim_far", p=None, tau=None,
            temperature=None, after_hp=after_hp, selectable=True,
        ))

    # 2b) trim lowest EWMA |logit| ± post hp30
    for tau in TRIM_ABS_TAUS:
        for after_hp in (False, True):
            suffix = "_hp30" if after_hp else ""
            variants.append(dict(
                name=f"trim_low_abs_t{int(tau)}{suffix}",
                family="trim_low", p=None, tau=float(tau),
                temperature=None, after_hp=after_hp, selectable=True,
            ))

    # 3) softmax-|logit| static
    for T in SOFT_TS:
        for after_hp in (False, True):
            suffix = "_hp30" if after_hp else ""
            variants.append(dict(
                name=f"softabs_static_T{_ttag(T)}{suffix}",
                family="softabs", p=None, tau=None,
                temperature=float(T), after_hp=after_hp, selectable=True,
            ))

    # 3b) softmax-EWMA(|logit|)
    for tau in SOFT_EWMA_TAUS:
        for T in SOFT_TS:
            for after_hp in (False, True):
                suffix = "_hp30" if after_hp else ""
                variants.append(dict(
                    name=f"softabs_ewma_t{int(tau)}_T{_ttag(T)}{suffix}",
                    family="softabs", p=None, tau=float(tau),
                    temperature=float(T), after_hp=after_hp, 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-power-trim CPU-only  p_stay {P_STAY} scale {SCALE}")
    log_line("honesty: past-only power-mean / trim / softabs; LODO Acc then H; no AASD/Carta labels")
    log_line("NOT rank-gauss; NOT seed-reliability; NOT multi-tau; NOT CORAL; NOT fuse↔hp30")
    log_line("select LODO Acc then H; always emit")

    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-power-trim: causal power-mean / trim / softabs-|logit| of 4 seeds",
        p_stay=P_STAY, scale=SCALE,
        honesty="past-only; 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"],
            p=v["p"], tau=v["tau"], temperature=v["temperature"], after_hp=v["after_hp"],
        )
        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:40s} {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:40s}  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"], p=v["p"], tau=v["tau"],
            temperature=v["temperature"], after_hp=v["after_hp"],
            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

    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:40s}  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"],
            p=v["p"], tau=v["tau"], temperature=v["temperature"], after_hp=v["after_hp"],
        )
        mu_e, sd_e = emissions_from(adapted_train, train_att, list(CORPUS))
        adapted_test = apply_variant(
            test_logits, v["family"],
            p=v["p"], tau=v["tau"], temperature=v["temperature"], after_hp=v["after_hp"],
        )
        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:40s} {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()
