"""Causal multi-τ one-pole high-pass on published SW2 fuse evidence alone.

DISTINCT from:
  - multi-tau-hp (same idea on **4-seed** direct-clf logits)
  - Acc-stream blends (SW2↔swmix / SW2↔hp30 / tri-acc-blend)

Applies HP to the Acc-leader SW2 fuse stream (fuse_general a=0.5; AASD Acc ~53.46).

τ∈{10,15,20,25,30,35,40,45,50}
Candidates: hp{τ}, soft_hp{τ}=0.5·raw+0.5·hp{τ}, bank_med of 2–3 τ (median across τ).
raw_sw2 scored for reference / soft construction but excluded from selection.

Select mean LODO Acc then H @ HMM p_stay=0.994 scale=0.8 (never AASD/Carta).
Score AASD + Carta with selected rule. CPU only. No retrain.

Reuse SW2 evidence loaders from sw2_hp30_blend.py / sw2_swmix_blend.py.

usage:
  /root/disk_3tb/EEG-sAAD-Grand-Challenge-Training-Dataset/.venv/bin/python -u sw2_multi_tau.py
"""
from __future__ import annotations

import itertools
import json
import os
import time

import numpy as np

import ensemble_clf_nested as N
import ensemble_clf_transformer_v4 as V4
import eval_external as E
import sw2_hp30_blend as SW2
import sw2_swmix_blend as SM
from common import DS_KEYS
from fuse_evidence import LA

EXP = os.path.dirname(os.path.abspath(__file__))
CACHE_DIR = os.path.join(EXP, "models", "sw2_multi_tau", "cache")
LOG = os.path.join(EXP, "experiments", "sw2_multi_tau.log")
OUT = os.path.join(EXP, "results", "research", "sw2_multi_tau.json")
RESULTS_MD = os.path.join(EXP, "multi_agent_opt", "results_sw2_multi_tau.md")
CKPT = os.path.join(EXP, "models", "sw2_multi_tau")

P_STAY = 0.994
SCALE = 0.8
LOOKAHEAD = float(LA)
A_SW2 = SW2.A_SW2
HOP = 0.25

# Includes τ=30 (unlike multi-tau-hp which reserved 30 as baseline-only).
TAUS = (10, 15, 20, 25, 30, 35, 40, 45, 50)

LINEAR_HP30_EXT = dict(AASD=dict(H=0.6422, Acc=53.12), Carta2026=dict(H=0.6520, Acc=60.54))
SW2_ALONE_EXT = dict(AASD=dict(H=0.6439, Acc=53.46), Carta2026=dict(H=0.6470, Acc=59.60))
SW2_SWMIX_LEADER = dict(AASD=dict(H=0.6424, Acc=53.53), Carta2026=dict(H=0.6460, Acc=59.71))


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_1d(x, tau, hop=HOP):
    """Causal one-pole HP on a 1-D evidence stream."""
    x = np.asarray(x, np.float64).reshape(-1)
    return np.asarray(V4.highpass(x, tau=float(tau), hop=hop), np.float64).reshape(-1)


def map_stream(stream, fn):
    out = {}
    for ds, table in stream.items():
        out[ds] = {k: fn(d) for k, d in table.items()}
    return out


def hp_stream(stream, tau):
    return map_stream(stream, lambda d: highpass_1d(d, tau))


def soft_stream(raw, hp, w_raw=0.5, w_hp=0.5):
    out = {}
    for ds in raw:
        out[ds] = {}
        for k in raw[ds]:
            out[ds][k] = (
                w_raw * np.asarray(raw[ds][k], np.float64)
                + w_hp * np.asarray(hp[ds][k], np.float64)
            )
    return out


def bank_med_stream(hp_by_tau, taus):
    taus = tuple(taus)
    ref = hp_by_tau[taus[0]]
    out = {}
    for ds, table in ref.items():
        out[ds] = {}
        for k in table:
            stack = np.stack([np.asarray(hp_by_tau[t][ds][k], np.float64) for t in taus], 0)
            out[ds][k] = np.median(stack, axis=0).astype(np.float64)
    return out


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


def score_lodo_held(stream_all, meta, held):
    ev = SW2.ev_from_stream(stream_all, meta)
    V4._install_scorer_state(ev, LOOKAHEAD)
    return N.official(held, ev, P_STAY, SCALE)


def mean_lodo(streams_by_held, meta, name):
    t0 = time.time()
    hs, acs, per = [], [], {}
    for held in DS_KEYS:
        r = score_lodo_held(streams_by_held[held], meta, held)
        hs.append(r["H"])
        acs.append(r["Acc"])
        per[held] = dict(H=r["H"], Acc=r["Acc"], SDT=r["SDT"], L=r.get("L"))
        log_line(f"LODO {name:28s} {held:5s}  H {r['H']:.4f} Acc {r['Acc']:.2f}")
    mean_h = float(np.mean(hs))
    mean_a = float(np.mean(acs))
    log_line(f"LODO_MEAN {name:28s}  H {mean_h:.4f} Acc {mean_a:.2f}  ({time.time()-t0:.0f}s)")
    return mean_h, mean_a, per


def corpus_emis(streams_by_held, meta):
    """Average held-specific streams, then signed μ/σ on corpus."""
    acc = {ds: {} for ds in DS_KEYS}
    counts = {ds: {} for ds in DS_KEYS}
    for held in DS_KEYS:
        stream = streams_by_held[held]
        for ds in DS_KEYS:
            for k, d in stream[ds].items():
                d = np.asarray(d, np.float64)
                if k not in acc[ds]:
                    acc[ds][k] = np.zeros_like(d, np.float64)
                    counts[ds][k] = 0
                n = min(len(acc[ds][k]), len(d))
                acc[ds][k][:n] += d[:n]
                counts[ds][k] += 1
    parts = []
    for ds in DS_KEYS:
        for k, d in acc[ds].items():
            att = meta[ds][k][0]
            n = min(len(d), len(att))
            parts.append((d[:n] / max(counts[ds][k], 1)) * np.where(np.asarray(att)[:n] == 0, 1.0, -1.0))
    A = np.concatenate(parts)
    return float(A.mean()), float(A.std())


def transform_ext_ev(sw2_ev, fn):
    out = {}
    for k, e in sw2_ev.items():
        d = fn(np.asarray(e["r0"], np.float64))
        n = len(d)
        out[k] = dict(
            r0=d,
            r1=np.zeros(n),
            att=e["att"][:n],
            t_end=e["t_end"][:n],
            att128=e["att128"],
            n128=e["n128"],
            subject=e["subject"],
        )
    return out


def eligible_for_selection(name):
    if name == "raw_sw2":
        return False
    return (
        name.startswith("hp")
        or name.startswith("soft_hp")
        or name.startswith("bank_med_")
    )


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 _json_default(o):
    if isinstance(o, (np.floating, np.integer)):
        return float(o)
    if isinstance(o, np.ndarray):
        return o.tolist()
    raise TypeError(type(o))


def write_md(summary):
    sel_name = summary["selected"]
    sel = summary["variants"][sel_name]
    ext = sel["external"]
    lines = []
    lines.append("# results_sw2_multi_tau\n")
    lines.append(
        "**Claim:** `sw2-multi-tau` — causal one-pole high-pass on **published SW2 fuse** "
        "evidence alone (fuse_general a=0.5 Acc-leader family). "
        f"τ∈{{{','.join(str(t) for t in TAUS)}}}. "
        "Variants: `hp{τ}`, `soft_hp{τ}`=0.5·raw+0.5·hp, `bank_med_*` median over 2–3 τ.\n"
    )
    lines.append(
        "**DISTINCT** from `multi-tau-hp` (4-seed logits) and Acc-stream blends "
        "(SW2↔swmix / SW2↔hp30 / tri-acc-blend). CPU only; no retrain.\n"
    )
    lines.append(
        f"HMM preset **{P_STAY} / {SCALE}**. Code: `sw2_multi_tau.py`. "
        f"JSON: `results/research/sw2_multi_tau.json`.\n"
    )
    lines.append("## Selection (mean LODO Acc then H; never AASD/Carta)\n")
    lines.append(
        f"**SELECTED `{sel_name}`** — mean LODO H **{sel['lodo_mean']['H']:.4f}** "
        f"Acc **{sel['lodo_mean']['Acc']:.2f}**\n"
    )
    lines.append("| Held-out | H | Acc % |")
    lines.append("|---|---:|---:|")
    for ds in DS_KEYS:
        p = sel["lodo"][ds]
        lines.append(f"| {ds} | {p['H']:.4f} | {p['Acc']:.2f} |")
    lines.append(
        f"| **mean** | **{sel['lodo_mean']['H']:.4f}** | **{sel['lodo_mean']['Acc']:.2f}** |\n"
    )

    lines.append("### hp{τ} LODO rank (bank construction)\n")
    lines.append("| τ | LODO H / Acc |")
    lines.append("|---|---|")
    for row in summary["hp_tau_lodo_rank"]:
        lines.append(f"| {row['tau']} | {row['H']:.4f} / {row['Acc']:.2f} |")

    lines.append("\n### Variant table (LODO Acc desc; selected first)\n")
    lines.append("| Variant | LODO H / Acc | AASD H / Acc | ΔAcc vs 53.53 | ΔAcc vs 53.12 | Carta H / Acc |")
    lines.append("|---------|--------------|--------------|---------------|---------------|---------------|")
    ranked = sorted(
        summary["variants"].items(),
        key=lambda kv: (
            0 if kv[0] == sel_name else 1,
            -float(kv[1]["lodo_mean"]["Acc"]),
            -float(kv[1]["lodo_mean"]["H"]),
        ),
    )
    for name, v in ranked:
        if "external" not in v:
            continue
        a = v["external"]["AASD"]
        c = v["external"]["Carta2026"]
        mark = " **←**" if name == sel_name else ""
        lines.append(
            f"| `{name}`{mark} | {v['lodo_mean']['H']:.4f} / {v['lodo_mean']['Acc']:.2f} | "
            f"{a['H']:.4f} / {a['Acc']:.2f} | {a['Acc']-53.53:+.2f} | {a['Acc']-53.12:+.2f} | "
            f"{c['H']:.4f} / {c['Acc']:.2f} |"
        )

    aasd = ext["AASD"]
    carta = ext["Carta2026"]
    lines.append("\n## Targets\n")
    lines.append("| Target | Result |")
    lines.append("|---|---|")
    lines.append(
        f"| AASD Acc vs lead 53.53 / hp30 53.12 | Acc **{aasd['Acc']:.2f}** "
        f"(Δ {aasd['Acc']-53.53:+.2f} / {aasd['Acc']-53.12:+.2f}); H {aasd['H']:.4f} |"
    )
    lines.append(
        f"| Carta vs linear_hp30 60.54 | Acc **{carta['Acc']:.2f}** "
        f"(Δ {carta['Acc']-60.54:+.2f}); H {carta['H']:.4f} |"
    )
    lines.append(
        f"| Acc>60? | **{'YES' if aasd['Acc'] > 60 else 'NO'}** (AASD Acc {aasd['Acc']:.2f}) |"
    )
    lines.append(
        f"| LODO mean | H {sel['lodo_mean']['H']:.4f} Acc {sel['lodo_mean']['Acc']:.2f} |\n"
    )

    lines.append("## Verdict\n")
    if aasd["Acc"] > 53.53 + 0.15 and aasd["H"] > 0.63:
        lines.append(
            "Selected multi-τ HP on SW2 fuse improves AASD Acc vs Acc-leader with H>0.63.\n"
        )
    elif aasd["Acc"] > 53.12 + 0.2 and aasd["H"] > 0.63:
        lines.append(
            "Selected rule beats linear_hp30 AASD Acc but does not clear the SW2↔swmix Acc leader 53.53.\n"
        )
    else:
        lines.append(
            "Honest LODO Acc/H selector on multi-τ HP of SW2 fuse does not lift AASD Acc past the "
            "Acc-leader family (~53.46–53.53). Same qualitative failure as 4-seed multi-τ HP, now on "
            "the SW2 fuse stream alone.\n"
        )

    lines.append("## NEXT IDEA\n")
    lines.append(
        "**decoder-sw3** Acc front-end (denser-switch decoder; already in flight — do not steal GPU) "
        "or a qualitatively new prep/backbone that clears chance and lifts AASD acc1. "
        "Do not re-grid multi-τ HP on SW2 fuse, 4-seed multi-τ HP, or Acc-stream blends "
        "(SW2↔swmix/hp30/tri).\n"
    )
    with open(RESULTS_MD, "w") as fh:
        fh.write("\n".join(lines))


def main():
    os.makedirs(CACHE_DIR, exist_ok=True)
    os.makedirs(CKPT, exist_ok=True)
    os.makedirs(os.path.dirname(LOG), exist_ok=True)
    os.makedirs(os.path.dirname(OUT), exist_ok=True)
    open(LOG, "w").close()
    t_all = time.time()
    log_line(
        f"sw2-multi-tau start  p_stay={P_STAY} scale={SCALE} a_sw2={A_SW2} taus={TAUS}"
    )
    log_line("honesty: LODO Acc then H only; never AASD/Carta labels; CPU only")

    try:
        Z, meta = SM.ensure_sw2_lodo()
    except FileNotFoundError as e:
        log_line(f"ABORT: {e}")
        summary = dict(status="abandoned", reason=str(e))
        with open(OUT, "w") as fh:
            json.dump(summary, fh, indent=2)
        with open(RESULTS_MD, "w") as fh:
            fh.write(f"# results_sw2_multi_tau\n\n**Status: abandoned**\n\n{e}\n")
        return

    # Precompute raw SW2 fuse per held-out fold
    log_line("building raw SW2 fuse streams per held …")
    raw_held = {held: SW2.fuse_sw2_held(Z, held, a=A_SW2) for held in DS_KEYS}

    # Sanity: raw SW2 AVGC
    r0 = score_lodo_held(raw_held["AVGC"], meta, "AVGC")
    log_line(
        f"sanity AVGC raw_sw2 H {r0['H']:.4f} Acc {r0['Acc']:.2f} "
        f"(expect ~0.71 / ~67.8 @0.994/0.8)"
    )

    # Per-τ HP streams per held
    log_line("building per-τ HP streams on SW2 fuse …")
    hp_held = {tau: {} for tau in TAUS}
    for tau in TAUS:
        for held in DS_KEYS:
            hp_held[tau][held] = hp_stream(raw_held[held], tau)
        log_line(f"  built tau={tau}")

    results = dict(
        status="running",
        method="sw2-multi-tau",
        p_stay=P_STAY,
        scale=SCALE,
        a_sw2=A_SW2,
        taus=list(TAUS),
        honesty="Selection on LODO Acc then H only; never AASD/Carta labels. Causal HP on SW2 fuse alone.",
        baselines=dict(
            linear_hp30_ext=LINEAR_HP30_EXT,
            sw2_alone_ext=SW2_ALONE_EXT,
            sw2_swmix_leader=SW2_SWMIX_LEADER,
        ),
        variants={},
    )
    lodo_means = {}
    streams_store = {}  # name -> streams_by_held

    def register(name, streams_by_held, family, extra=None):
        mean_h, mean_a, per = mean_lodo(streams_by_held, meta, name)
        lodo_means[name] = dict(H=mean_h, Acc=mean_a)
        streams_store[name] = streams_by_held
        row = dict(
            family=family,
            lodo=per,
            lodo_mean=dict(H=mean_h, Acc=mean_a),
        )
        if extra:
            row.update(extra)
        results["variants"][name] = row

    # Phase 1: raw + hp + soft
    log_line("=== LODO phase1: raw_sw2 + hp/soft ===")
    register("raw_sw2", raw_held, "raw")
    for tau in TAUS:
        register(f"hp{tau}", hp_held[tau], "hp", extra=dict(tau=tau))
        soft_by_held = {
            held: soft_stream(raw_held[held], hp_held[tau][held]) for held in DS_KEYS
        }
        register(f"soft_hp{tau}", soft_by_held, "soft_hp", extra=dict(tau=tau))

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

    banks = bank_candidates(ranked_taus)
    log_line(f"=== LODO phase2: {len(banks)} bank_med subsets ===")
    for taus in banks:
        name = "bank_med_" + "_".join(str(t) for t in taus)
        by_held = {}
        for held in DS_KEYS:
            hp_by_tau = {t: hp_held[t][held] for t in taus}
            by_held[held] = bank_med_stream(hp_by_tau, taus)
        register(name, by_held, "bank_med", extra=dict(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

    # External
    try:
        EV_sw2, emis_sw2 = SM.ensure_sw2_external()
    except FileNotFoundError as e:
        log_line(f"ABORT external: {e}")
        results["status"] = "partial"
        results["reason"] = str(e)
        with open(OUT, "w") as fh:
            json.dump(results, fh, indent=2, default=_json_default)
        write_md(results)
        return

    log_line("=== external (all variants; headline = selected) ===")

    def ext_fn_for(name):
        """Return a callable r0 -> transformed 1d for external SW2 evidence."""
        if name == "raw_sw2":
            return lambda x: np.asarray(x, np.float64)
        if name.startswith("hp") and name[2:].isdigit():
            tau = int(name[2:])
            return lambda x, t=tau: highpass_1d(x, t)
        if name.startswith("soft_hp"):
            tau = int(name.replace("soft_hp", ""))
            return lambda x, t=tau: 0.5 * np.asarray(x, np.float64) + 0.5 * highpass_1d(x, t)
        if name.startswith("bank_med_"):
            taus = tuple(int(p) for p in name.replace("bank_med_", "").split("_"))
            def _fn(x, ts=taus):
                stack = np.stack([highpass_1d(x, t) for t in ts], 0)
                return np.median(stack, axis=0).astype(np.float64)
            return _fn
        raise ValueError(name)

    for name, streams_by_held in streams_store.items():
        mu_c, sd_c = corpus_emis(streams_by_held, meta)
        fn = ext_fn_for(name)
        ext = {}
        for ds in ("AASD", "Carta2026"):
            sw2_ev = EV_sw2[ds][A_SW2]
            if name == "raw_sw2":
                # Use published FE emissions for pure SW2 (matches prior reports)
                mu, sd = emis_sw2[A_SW2]
                ev_use = sw2_ev
            else:
                mu, sd = mu_c, sd_c
                ev_use = transform_ext_ev(sw2_ev, fn)
            r = E.score(ev_use, mu, sd * SCALE, P_STAY, LOOKAHEAD)
            ext[ds] = dict(
                H=r["H"], Acc=r["Acc"], SDT=r["SDT"], L=r["L"],
                nSwitches=r["nSwitches"], nUndetected=r["nUndetected"],
            )
            base = SW2_SWMIX_LEADER[ds]["Acc"] if ds == "AASD" else LINEAR_HP30_EXT[ds]["Acc"]
            log_line(
                f"EXT {name:28s} {ds:10s}  H {r['H']:.4f} Acc {r['Acc']:.2f}  "
                f"Δ vs ref {r['Acc']-base:+.2f}"
            )
        results["variants"][name]["external"] = ext
        results["variants"][name]["emis"] = dict(mu=mu_c if name != "raw_sw2" else float(emis_sw2[A_SW2][0]),
                                                 sd=sd_c if name != "raw_sw2" else float(emis_sw2[A_SW2][1]))

    prim = results["variants"][selected]
    aasd = prim["external"]["AASD"]
    carta = prim["external"]["Carta2026"]
    results["headline"] = dict(
        selected=selected,
        AASD=aasd,
        Carta2026=carta,
        AASD_Acc_delta_vs_leader_53_53=aasd["Acc"] - 53.53,
        AASD_Acc_delta_vs_hp30_53_12=aasd["Acc"] - 53.12,
        Carta_Acc_delta_vs_hp30_60_54=carta["Acc"] - 60.54,
        lodo_mean=prim["lodo_mean"],
        Acc_gt_60=bool(aasd["Acc"] > 60),
    )
    results["status"] = "done"
    results["elapsed_s"] = time.time() - t_all

    with open(OUT, "w") as fh:
        json.dump(results, fh, indent=2, default=_json_default)
    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=2, default=_json_default,
        )
    write_md(results)
    log_line(
        f"HEADLINE {selected} AASD H {aasd['H']:.4f} Acc {aasd['Acc']:.2f} "
        f"(Δ {aasd['Acc']-53.53:+.2f} vs 53.53; Δ {aasd['Acc']-53.12:+.2f} vs 53.12)  "
        f"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}"
    )
    log_line(f"done in {time.time()-t_all:.0f}s → {OUT}")


if __name__ == "__main__":
    main()
