"""Score 5-seed linear_mean / linear_hp30 after adding vlaai_ws seed s4.

Uses published seeds s0–s3 plus new seed s4 (LODO folds + all5 external evidence).
HMM fixed at p_stay=0.994, emission scale=0.8. Never fits on AASD/Carta labels.

usage (after train):
  /root/disk_3tb/EEG-sAAD-Grand-Challenge-Training-Dataset/.venv/bin/python -u newseed_hp30.py
"""
from __future__ import annotations

import json
import os
import pickle
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
import score as S
from common import DS_KEYS
from common_exp import DATA_EXP, EXP

LOG = os.path.join(EXP, "experiments", "newseed_hp30.log")
OUT_JSON = os.path.join(EXP, "results", "research", "newseed_hp30.json")
OUT_MD = os.path.join(EXP, "multi_agent_opt", "results_newseed_hp30.md")

SEED = 4
NEW_LODO = f"direct_clf__eaP_n5_t60_w10b3_ptSPK_s{SEED}_aug-sw2"
EXT_TAG = "_w10b3sw2P"
P_STAY, SCALE = 0.994, 0.8
LOOKAHEAD = 0.75
TEST_NAMES = ("AASD", "Carta2026")
BASE_AASD = 53.12

SEEDS5 = list(EC.SEEDS) + [(SEED, NEW_LODO)]


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_lodo_nd(seeds):
    """(ds -> key -> (T, n_seeds)) signed deltas from LODO folds."""
    evs, lookahead = [], None
    for seed, exp in seeds:
        ev, info = S.load_folds(exp, "causal")
        evs.append(ev)
        log_line(f"loaded LODO seed{seed} {exp}")
        for ds in DS_KEYS:
            la = float(info[ds]["lookahead_s"])
            lookahead = la if lookahead is None else lookahead
            if abs(la - lookahead) > 1e-9:
                raise RuntimeError(f"lookahead mismatch {exp} {ds}")
    out = {}
    for ds in DS_KEYS:
        out[ds] = {}
        keys = evs[0][ds].keys()
        for k in keys:
            cols = [EC.delta(ev[ds][k]) for ev in evs]
            out[ds][k] = np.stack(cols, 1).astype(np.float32)
    return out, lookahead, evs


def ext_evidence_path(ds, seed):
    name = f"ext_clf_{ds}{EXT_TAG}_evidence_s{seed}.pkl"
    local = os.path.join(EXP, "results", "research", name)
    if os.path.exists(local):
        return local
    shared = os.path.join(DATA_EXP, "results", "research", name)
    if os.path.exists(shared):
        return shared
    raise FileNotFoundError(name)


def load_ext_nd(n_seeds):
    logits, meta = {}, {}
    for ds in TEST_NAMES:
        evs = []
        for i in range(n_seeds):
            path = ext_evidence_path(ds, i)
            with open(path, "rb") as fh:
                evs.append(pickle.load(fh))
            log_line(f"loaded EXT {ds} seed{i} {path}")
        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"]),
            )
    return logits, meta


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


def hp30_stream(nd):
    out = {}
    for ds, table in nd.items():
        out[ds] = {}
        for k, D in table.items():
            out[ds][k] = V4.highpass(D).mean(1).astype(np.float64)
    return out


def to_ev(stream, ref_ev):
    """Pack 1-d stream as r0/r1=0 using att/t_end from a reference LODO evidence dict."""
    out = {}
    for ds in DS_KEYS:
        out[ds] = {}
        for k, d in stream[ds].items():
            e0 = ref_ev[ds][k]
            d = np.asarray(d, np.float64)
            out[ds][k] = dict(
                r0=d, r1=np.zeros_like(d), att=e0["att"], t_end=e0["t_end"], pre_switched=True
            )
    return out


def score_lodo(name, stream, ref_ev):
    ev = to_ev(stream, ref_ev)
    per = {}
    for held in DS_KEYS:
        r = N.official(held, ev, P_STAY, SCALE)
        per[held] = r
        log_line(f"LODO {name:14s} {held:5s}  H {r['H']:.4f} Acc {r['Acc']:.2f}")
    mH = float(np.mean([per[d]["H"] for d in DS_KEYS]))
    mA = float(np.mean([per[d]["Acc"] for d in DS_KEYS]))
    log_line(f"LODO_MEAN {name:14s}  H {mH:.4f} Acc {mA:.2f}")
    return per, mH, mA


def score_ext(name, stream, meta, mu, sd):
    out = {}
    for ds in TEST_NAMES:
        ev = V4.pack_ev(stream[ds], meta[ds])
        plain = E.plain(ev)
        r = E.score(ev, mu, sd * SCALE, P_STAY, LOOKAHEAD)
        out[ds] = dict(**r, acc1=plain["acc1"], snr1=plain["snr1"])
        dacc = r["Acc"] - BASE_AASD if ds == "AASD" else None
        extra = f"  ΔAcc vs 4seed-hp30 {dacc:+.2f}" if dacc is not None else ""
        log_line(
            f"EXT  {name:14s} {ds:10s}  H {r['H']:.4f} Acc {r['Acc']:.2f} "
            f"acc1 {plain['acc1']:.3f}{extra}"
        )
    return out


def write_md(results):
    a4 = results["external_4"]["linear_hp30"]["AASD"]
    a5 = results["external_5"]["linear_hp30"]["AASD"]
    m4 = results["external_4"]["linear_mean"]["AASD"]
    m5 = results["external_5"]["linear_mean"]["AASD"]
    l4 = results["lodo_4"]
    l5 = results["lodo_5"]
    lines = [
        "# results_newseed_hp30",
        "",
        f"**New seed:** train_seed={SEED}, vlaai_ws 10 s, eaP_n5_t60, 3 blocks, sw2, "
        f"SPK init `models/pretrain_spk_direct_clf_w10_b3_s{SEED}.pt`.",
        "",
        f"LODO exp: `{NEW_LODO}`. External all5 tag `{EXT_TAG}` seed {SEED}.",
        f"HMM p_stay={P_STAY} scale={SCALE}. Script: `newseed_hp30.py` / `experiments/run_newseed_hp30.sh`.",
        "",
        "## Headline vs 4-seed linear_hp30 AASD Acc 53.12",
        "",
        f"| Readout | n seeds | AASD H | AASD Acc | ΔAcc vs 53.12 |",
        f"|---|---:|---:|---:|---:|",
        f"| linear_hp30 | 4 | {a4['H']:.4f} | {a4['Acc']:.2f} | {a4['Acc'] - BASE_AASD:+.2f} |",
        f"| linear_hp30 | **5** | **{a5['H']:.4f}** | **{a5['Acc']:.2f}** | **{a5['Acc'] - BASE_AASD:+.2f}** |",
        f"| linear_mean | 4 | {m4['H']:.4f} | {m4['Acc']:.2f} | {m4['Acc'] - BASE_AASD:+.2f} |",
        f"| linear_mean | 5 | {m5['H']:.4f} | {m5['Acc']:.2f} | {m5['Acc'] - BASE_AASD:+.2f} |",
        "",
        "## LODO (preset 0.994/0.8)",
        "",
        "| n | linear_mean H/Acc | linear_hp30 H/Acc | AVGC mean H/Acc |",
        "|---:|---|---|---|",
        f"| 4 | {l4['linear_mean']['mean_H']:.4f}/{l4['linear_mean']['mean_Acc']:.2f} | "
        f"{l4['linear_hp30']['mean_H']:.4f}/{l4['linear_hp30']['mean_Acc']:.2f} | "
        f"{l4['linear_mean']['per']['AVGC']['H']:.4f}/{l4['linear_mean']['per']['AVGC']['Acc']:.2f} |",
        f"| 5 | {l5['linear_mean']['mean_H']:.4f}/{l5['linear_mean']['mean_Acc']:.2f} | "
        f"{l5['linear_hp30']['mean_H']:.4f}/{l5['linear_hp30']['mean_Acc']:.2f} | "
        f"{l5['linear_mean']['per']['AVGC']['H']:.4f}/{l5['linear_mean']['per']['AVGC']['Acc']:.2f} |",
        "",
        "## External Carta",
        "",
        f"| n | linear_hp30 H/Acc | linear_mean H/Acc |",
        f"|---:|---|---|",
        f"| 4 | {results['external_4']['linear_hp30']['Carta2026']['H']:.4f}/"
        f"{results['external_4']['linear_hp30']['Carta2026']['Acc']:.2f} | "
        f"{results['external_4']['linear_mean']['Carta2026']['H']:.4f}/"
        f"{results['external_4']['linear_mean']['Carta2026']['Acc']:.2f} |",
        f"| 5 | {results['external_5']['linear_hp30']['Carta2026']['H']:.4f}/"
        f"{results['external_5']['linear_hp30']['Carta2026']['Acc']:.2f} | "
        f"{results['external_5']['linear_mean']['Carta2026']['H']:.4f}/"
        f"{results['external_5']['linear_mean']['Carta2026']['Acc']:.2f} |",
        "",
        "## Verdict",
        "",
        f"5-seed linear_hp30 AASD Acc **{a5['Acc']:.2f}** vs 4-seed **53.12** "
        f"(Δ {a5['Acc'] - BASE_AASD:+.2f}). "
        + (
            "Moved AASD Acc toward 60."
            if a5["Acc"] > BASE_AASD + 0.05
            else (
                "Regressed."
                if a5["Acc"] < BASE_AASD - 0.05
                else "Flat vs 4-seed baseline."
            )
        ),
        "",
        "## NEXT IDEA",
        "",
        results.get(
            "next_idea",
            "If flat: try a sixth seed or seed-diversity (different SPK pretrain / longer min-epochs) "
            "only if s4 frame evidence is not near-duplicate of s0–s3; else leave hp30 bank alone.",
        ),
        "",
    ]
    os.makedirs(os.path.dirname(OUT_MD), exist_ok=True)
    with open(OUT_MD, "w") as fh:
        fh.write("\n".join(lines) + "\n")
    log_line(f"wrote {OUT_MD}")


def main():
    open(LOG, "w").close()
    t0 = time.time()
    log_line(f"newseed-hp30 score  seed={SEED}  p_stay={P_STAY} scale={SCALE}")

    # LODO 4 vs 5
    lodo4, _la, evs4 = load_lodo_nd(EC.SEEDS)
    lodo5, _, evs5 = load_lodo_nd(SEEDS5)
    ref4, ref5 = evs4[0], evs5[0]
    N.load_all()  # sets G["lookahead"] / prep for official()

    results = dict(seed=SEED, p_stay=P_STAY, scale=SCALE, lodo_exp=NEW_LODO, lodo_4={}, lodo_5={})
    for nlabel, nd, ref in (("lodo_4", lodo4, ref4), ("lodo_5", lodo5, ref5)):
        for kind, fn in (("linear_mean", mean_stream), ("linear_hp30", hp30_stream)):
            stream = fn(nd)
            per, mH, mA = score_lodo(f"{kind}/{nlabel[-1]}", stream, ref)
            results[nlabel][kind] = dict(per=per, mean_H=mH, mean_Acc=mA)

    # External: match v4 recipe — corpus emissions from CACHE logit_v2 (4-seed),
    # plus s4 LODO column when scoring the 5-seed bank. Test streams = all5 evidence.
    log_line("loading CACHE train logits (v4 corpus) for external emissions")
    cache_logits, cache_att = V4.load_train()
    cache4 = {ds: cache_logits[ds] for ds in DS_KEYS}
    # Align s4 LODO onto CACHE trial keys for a 5th column
    cache5 = {}
    for ds in DS_KEYS:
        cache5[ds] = {}
        miss = 0
        for k, D4 in cache4[ds].items():
            if k not in lodo5[ds]:
                miss += 1
                continue
            s4 = np.asarray(lodo5[ds][k], np.float32)
            # lodo5[k] is (T,5); take last col. Lengths must match CACHE.
            col = s4[:, -1]
            D4 = np.asarray(D4, np.float32)
            T = min(len(D4), len(col))
            cache5[ds][k] = np.concatenate([D4[:T], col[:T, None]], 1)
        log_line(f"  cache5 {ds}: {len(cache5[ds])} trials (miss {miss})")

    ext4, meta4 = load_ext_nd(4)
    ext5, meta5 = load_ext_nd(5)
    results["external_4"], results["external_5"] = {}, {}
    for nlabel, nd_corp, nd_ext, meta in (
        ("external_4", cache4, ext4, meta4),
        ("external_5", cache5, ext5, meta5),
    ):
        for kind, fn in (("linear_mean", mean_stream), ("linear_hp30", hp30_stream)):
            corp = fn(nd_corp)
            att = {ds: cache_att[ds] for ds in DS_KEYS}
            # drop keys missing from corp (s4 miss)
            att_use = {
                ds: {k: att[ds][k] for k in corp[ds] if k in att[ds]} for ds in DS_KEYS
            }
            corp_use = {
                ds: {k: corp[ds][k] for k in att_use[ds]} for ds in DS_KEYS
            }
            mu, sd = V4.emissions(corp_use, att_use)
            log_line(f"emis {nlabel} {kind} mu {mu:.4f} sd {sd:.4f}")
            test = fn(nd_ext)
            results[nlabel][kind] = score_ext(f"{kind}/{nlabel[-1]}", test, meta, mu, sd)

    a5 = results["external_5"]["linear_hp30"]["AASD"]["Acc"]
    if a5 > BASE_AASD + 0.2:
        results["next_idea"] = (
            "5-seed hp30 helped AASD Acc; try seed s5 or seed-reliability weights over 5."
        )
    elif a5 < BASE_AASD - 0.2:
        results["next_idea"] = (
            "s4 hurt the bank; keep 4-seed hp30. Next: different frame evidence "
            "(not another identical vlaai seed)."
        )
    else:
        results["next_idea"] = (
            "Extra vlaai seed flat on AASD Acc. Do not stack more identical seeds; "
            "need qualitatively different frame evidence (or accept 53.12 ceiling)."
        )

    write_md(results)
    os.makedirs(os.path.dirname(OUT_JSON), exist_ok=True)
    with open(OUT_JSON, "w") as fh:
        json.dump(results, fh, indent=1, default=float)
    log_line(f"wrote {OUT_JSON}  ({time.time() - t0:.0f}s)")
    log_line(
        f"HEADLINE 5seed linear_hp30 AASD Acc {a5:.2f}  "
        f"Δ {a5 - BASE_AASD:+.2f} vs 53.12"
    )


if __name__ == "__main__":
    main()
