"""Multi-tau causal one-pole high-pass on 4-seed direct-classifier logits.

CPU-only. No new nets. No fuse↔stem / MoE / trial-mmd / emis-LL / cross-stream.

Variants (all causal, past-only):
  hp{τ}          mean of 4 seeds after one-pole HP with τ ∈ {10,15,20,25,35,40,45,50}
  med_hp{τ}      median across 4 seeds after HP
  bank_mean_*    equal-weight mean over a 2–4 τ subset (subset picked by LODO Acc then H)
  soft_hp{τ}     0.5 * raw_mean + 0.5 * hp{τ}
  linear_hp30    baseline row for ΔAcc (not a selectable method if we prefer novel;
                 still included so selection can keep it if LODO prefers it)

Selection: mean LODO Acc then H over 5 held-out folds at fixed HMM p_stay=0.994, scale=0.8.
Never use AASD/Carta labels to pick.

Scoring: LODO per-fold + AASD + Carta2026 at 0.994/0.8. Report ΔAcc vs linear_hp30 53.12.

usage:
  PYTHONPATH=.../reports/eda_full/scripts:$PYTHONPATH \\
    /root/disk_3tb/EEG-sAAD-Grand-Challenge-Training-Dataset/.venv/bin/python -u multi_tau_hp.py
"""
from __future__ import annotations

import itertools
import json
import os
import time

import numpy as np

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

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

# Explicitly NOT 30 (baseline only), NOT 60/120/240 (ensemble_clf_hpfrac).
TAUS = (10, 15, 20, 25, 35, 40, 45, 50)

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 highpass(D, tau, hop=HOP):
    return V4.highpass(np.asarray(D, np.float64), tau=float(tau), hop=hop)


def stream_mean_hp(logits_4d, tau):
    out = {}
    for ds, table in logits_4d.items():
        out[ds] = {}
        for k, D in table.items():
            X = highpass(D, tau)
            out[ds][k] = X.mean(1).astype(np.float64)
    return out


def stream_med_hp(logits_4d, tau):
    out = {}
    for ds, table in logits_4d.items():
        out[ds] = {}
        for k, D in table.items():
            X = highpass(D, tau)
            out[ds][k] = np.median(X, axis=1).astype(np.float64)
    return out


def stream_raw_mean(logits_4d):
    out = {}
    for ds, table in logits_4d.items():
        out[ds] = {}
        for k, D in table.items():
            out[ds][k] = np.asarray(D, np.float64).mean(1)
    return out


def stream_blend(a, b, wa=0.5, wb=0.5):
    out = {}
    for ds in a:
        out[ds] = {}
        for k in a[ds]:
            out[ds][k] = wa * np.asarray(a[ds][k], np.float64) + wb * np.asarray(b[ds][k], np.float64)
    return out


def stream_bank_mean(hp_by_tau, taus):
    taus = tuple(taus)
    out = {}
    ref = hp_by_tau[taus[0]]
    for ds, table in ref.items():
        out[ds] = {}
        for k in table:
            stack = np.stack([hp_by_tau[t][ds][k] for t in taus], 0)
            out[ds][k] = stack.mean(0).astype(np.float64)
    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 eligible_for_selection(name):
    """raw_mean is only a soft-blend ingredient, not a multi-tau-hp variant."""
    if name == "raw_mean":
        return False
    return (
        name == "linear_hp30"
        or name.startswith("hp")
        or name.startswith("med_hp")
        or name.startswith("soft_hp")
        or name.startswith("bank_mean_")
    )


def pick_variant(lodo_means):
    best_name, best_key = None, None
    for name, m in lodo_means.items():
        if not eligible_for_selection(name):
            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 score_lodo(name, streams, results, lodo_means):
    t0 = time.time()
    per = {}
    for held in DS_KEYS:
        off = N.official(held, N.to_ev(streams), P_STAY, SCALE)
        per[held] = off
        log_line(f"LODO {name:28s} {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:28s}  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(
        lodo=per, lodo_mean=dict(H=mean_h, Acc=mean_a),
    )
    return mean_h, mean_a


def score_ext(name, train_streams, test_streams, train_att, test_meta, results):
    mu_e, sd_e = emissions_from(train_streams, train_att, list(CORPUS))
    ext = {}
    for ds in TEST_NAMES:
        r = score_external(test_streams[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:28s} {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)
    return ext


def bank_candidates(ranked_taus):
    """2–4 τ banks from top-5 LODO hp{τ}, plus a few spaced banks."""
    top = list(ranked_taus[:5])
    cands = []
    for k in (2, 3, 4):
        if len(top) >= k:
            for combo in itertools.combinations(top, k):
                cands.append(tuple(sorted(combo)))
    spaced = [
        (10, 25),
        (20, 40),
        (15, 35, 50),
        (10, 25, 50),
        (20, 35, 50),
        (10, 20, 35, 50),
        (15, 25, 40, 50),
    ]
    for s in spaced:
        if all(t in TAUS for t in s):
            cands.append(tuple(sorted(s)))
    # unique preserve order
    seen, out = set(), []
    for c in cands:
        if c not in seen:
            seen.add(c)
            out.append(c)
    return out


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"multi-tau-hp CPU-only  p_stay {P_STAY} scale {SCALE}")
    log_line(f"taus={TAUS}  (excludes 30 except as baseline; excludes 60/120/240)")
    log_line("honesty: LODO Acc then H selection only; 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()

    results = dict(
        method="multi-tau causal one-pole high-pass on 4-seed direct-classifier logits",
        p_stay=P_STAY, scale=SCALE, taus=list(TAUS),
        honesty="Selection on LODO Acc then H only; never AASD/Carta labels. Causal HP only.",
        baselines=LINEAR_HP30_BASELINE,
        variants={},
    )
    lodo_means = {}

    # Precompute streams per tau for cache / test / lodo
    log_line("building per-tau HP streams (mean + median) + raw_mean + hp30")
    raw_lodo = stream_raw_mean(lodo_4d)
    raw_cache = stream_raw_mean(src_cache)
    raw_test = stream_raw_mean(test_logits)

    hp_lodo, hp_cache, hp_test = {}, {}, {}
    med_lodo, med_cache, med_test = {}, {}, {}
    for tau in TAUS:
        hp_lodo[tau] = stream_mean_hp(lodo_4d, tau)
        hp_cache[tau] = stream_mean_hp(src_cache, tau)
        hp_test[tau] = stream_mean_hp(test_logits, tau)
        med_lodo[tau] = stream_med_hp(lodo_4d, tau)
        med_cache[tau] = stream_med_hp(src_cache, tau)
        med_test[tau] = stream_med_hp(test_logits, tau)
        log_line(f"  built tau={tau}")

    hp30_lodo = stream_mean_hp(lodo_4d, 30)
    hp30_cache = stream_mean_hp(src_cache, 30)
    hp30_test = stream_mean_hp(test_logits, 30)

    stream_store = {
        "linear_hp30": (hp30_lodo, hp30_cache, hp30_test),
        "raw_mean": (raw_lodo, raw_cache, raw_test),
    }
    for tau in TAUS:
        stream_store[f"hp{tau}"] = (hp_lodo[tau], hp_cache[tau], hp_test[tau])
        stream_store[f"med_hp{tau}"] = (med_lodo[tau], med_cache[tau], med_test[tau])
        soft_l = stream_blend(raw_lodo, hp_lodo[tau], 0.5, 0.5)
        soft_c = stream_blend(raw_cache, hp_cache[tau], 0.5, 0.5)
        soft_t = stream_blend(raw_test, hp_test[tau], 0.5, 0.5)
        stream_store[f"soft_hp{tau}"] = (soft_l, soft_c, soft_t)

    # --- Phase 1: LODO for singles ---
    log_line("=== LODO phase1: baseline + hp/med/soft ===")
    phase1_names = ["linear_hp30", "raw_mean"]
    for tau in TAUS:
        phase1_names.extend([f"hp{tau}", f"med_hp{tau}", f"soft_hp{tau}"])

    for name in phase1_names:
        score_lodo(name, stream_store[name][0], results, lodo_means)
        results["variants"][name]["family"] = name.split("_")[0] if name != "linear_hp30" else "baseline"

    # Rank single-τ mean HP by LODO for bank construction
    hp_rank = sorted(
        [(tau, lodo_means[f"hp{tau}"]["Acc"], lodo_means[f"hp{tau}"]["H"]) for tau in TAUS],
        key=lambda x: (x[1], x[2]), reverse=True,
    )
    ranked_taus = [t for t, _, _ in hp_rank]
    log_line("hp{τ} LODO rank (Acc then H): " + ", ".join(
        f"{t}({a:.2f}/{h:.4f})" for t, a, h in hp_rank))

    banks = bank_candidates(ranked_taus)
    log_line(f"=== LODO phase2: {len(banks)} bank_mean subsets ===")
    for taus in banks:
        name = "bank_mean_" + "_".join(str(t) for t in taus)
        bl = stream_bank_mean(hp_lodo, taus)
        bc = stream_bank_mean(hp_cache, taus)
        bt = stream_bank_mean(hp_test, taus)
        stream_store[name] = (bl, bc, bt)
        score_lodo(name, bl, results, lodo_means)
        results["variants"][name]["family"] = "bank_mean"
        results["variants"][name]["taus"] = list(taus)

    selected = pick_variant(lodo_means)
    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
    results["hp_tau_lodo_rank"] = [
        dict(tau=t, Acc=a, H=h) for t, a, h in hp_rank
    ]

    # --- External for all variants ---
    log_line("=== external (all variants; headline = selected) ===")
    for name, (sl, sc, st) in stream_store.items():
        score_ext(name, sc, st, train_att, test_meta, results)

    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"],
        lodo_per_fold=prim["lodo"],
    )
    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}")

    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,
                       hp_tau_lodo_rank=results["hp_tau_lodo_rank"]), fh, indent=1)
    log_line(f"wrote {OUT} ({time.time() - t_all:.0f}s)")


if __name__ == "__main__":
    main()
