"""Rebuild AccFuse tip with per-frame CM-off across SW2/BMMS seeds, then ↔lin_hp30.

Train-time/front-end style bias control on tip seeds (no stem mix).
≠ ablate cm_off on linear_hp30 alone; ≠ tip↔stem soft mixes.

CPU.
"""
from __future__ import annotations

import json
import os
from pathlib import Path

import numpy as np

import ensemble_clf_transformer_v4 as V4
import eval_external as E
from common import DS_KEYS
from common_exp import EXP
from dual_hp30_sw2_bmms import (
    LOOKAHEAD, TEST_NAMES, as_sym, blend_ev, load_ext_mean4, score_lodo, signed,
)
from accfuse_hp30_hselect import align_hp
from stem_hp30_accfuse import TIP_ALPHA, emis_from

OUT = os.path.join(EXP, "results", "research", "cm_off_accfuse_tip.json")
MD = os.path.join(EXP, "multi_agent_opt", "results_cm_off_accfuse_tip.md")
EVID = "/root/disk_3tb/EEG-sAAD-Grand-Challenge-Training-Dataset/experiments/decoder_lodo/results/research"
GRID = [(0.994, 0.8), (0.996, 0.8), (0.998, 0.8), (0.998, 1.0)]


def log(m):
    print(m, flush=True)


def load_seed_stack(tag):
    """Return {ds:{key: (T,4) signed}} for 4 seeds."""
    import pickle
    out = {ds: {} for ds in DS_KEYS}
    for seed in range(4):
        for ds in DS_KEYS:
            # fold evidence paths vary; use V4 fold loaders via mean path
            pass
    # Use V4 train logits which are already (T,4)
    train, _ = V4.load_train()
    return train  # {ds:{key:(T,4)}}


def cm_off_mean(D):
    """D (T,S) → CM-off across seeds then mean."""
    D = np.asarray(D, np.float64)
    if D.ndim == 1:
        return D
    cm = D.mean(1, keepdims=True)
    return (D - cm).mean(1)


def stack_to_ev(stack, template):
    ev = {}
    for ds in stack:
        ev[ds] = {}
        for k, D in stack[ds].items():
            if k not in template[ds]:
                continue
            d = cm_off_mean(D)
            n = min(len(d), len(template[ds][k]["att"]))
            ev[ds][k] = as_sym(template[ds][k], d[:n])
    return ev


def main():
    # AccFuse templates from SW2/BMMS mean4
    sw2 = load_ext_mean4  # wrong for LODO
    # LODO: load published AccFuse via SW2+BMMS fold evidence
    from dual_hp30_sw2_bmms import load_lodo_mean4
    try:
        sw2_l = load_lodo_mean4("w10b3sw2P")
        bmms_l = load_lodo_mean4("w10bmms3enhP")
    except Exception:
        # fallback: use V4 seed stacks for linear family only
        log("trying V4 seed stacks for cm_off mean as tip proxy")
        train, _ = V4.load_train()
        tip_cm = {}
        for ds in DS_KEYS:
            tip_cm[ds] = {}
            for k, D in train[ds].items():
                tip_cm[ds][k] = cm_off_mean(D)
        # need template att — from af
        from accfuse_hp30_hselect import load_accfuse
        af = load_accfuse()
        tip_ev = {ds: {k: as_sym(af[ds][k], tip_cm[ds][k][:len(af[ds][k]["att"])])
                       for k in af[ds] if k in tip_cm[ds]} for ds in DS_KEYS}
        _, lin_hp, _ = V4._mean_and_hp_from_folds()
        tip_ev = {ds: blend_ev(tip_ev[ds], align_hp(tip_ev, lin_hp)[ds], TIP_ALPHA) for ds in DS_KEYS}
        grid = []
        for p, sc in GRID:
            per, mH, mA = score_lodo(tip_ev, p_stay=p, scale=sc)
            grid.append(dict(p=p, sc=sc, H=mH, Acc=mA))
            log(f"  proxy tip cm_off↔hp30 p={p} sc={sc} H={mH:.4f} Acc={mA:.2f}")
        best = sorted(grid, key=lambda r: (r["Acc"], r["H"]), reverse=True)[0]
        # external
        test, meta = V4.load_test()
        # emissions
        mu, sd = emis_from(tip_ev)
        ext = {}
        for ds in TEST_NAMES:
            ev = {}
            for k, D in test[ds].items():
                d = cm_off_mean(D)
                # need meta template
                mk = meta[ds][k] if False else None
            # use E via as_sym from load_ext
            sw2e = load_ext_mean4("w10b3sw2P")
            # build from test logits cm_off
            streams = V4.linear_streams({**{d: train[d] for d in train}, **test}, "hp30")
            # simpler: score cm_off mean of 4-seed test as linear tip
            for ds in TEST_NAMES:
                ev = {}
                for k, D in test[ds].items():
                    d = cm_off_mean(D)
                    h = V4.highpass(d[:, None])[:, 0]
                    s = (1 - TIP_ALPHA) * d + TIP_ALPHA * h
                    # build meta from sw2e
                    if k not in sw2e[ds]:
                        continue
                    ev[k] = as_sym(sw2e[ds][k], s[:len(sw2e[ds][k]["att"])])
                r = E.score(ev, mu, sd * best["sc"], best["p"], LOOKAHEAD)
                ext[ds] = {k: float(r[k]) for k in ("H", "Acc", "L", "SDT") if k in r}
                log(f"  EXT {ds} H={ext[ds]['H']:.4f} Acc={ext[ds]['Acc']:.2f}")
        gate = best["H"] > 0.85 and best["Acc"] > 75 and ext["AASD"]["H"] >= 0.65 and ext["Carta2026"]["H"] >= 0.65
        out = dict(selected=best, grid=grid, external=ext, pass_joint=gate, note="cm_off on 4-seed then ↔hp30 proxy")
        with open(OUT, "w") as fh:
            json.dump(out, fh, indent=1, default=float)
        Path(MD).write_text(
            f"# results_cm_off_accfuse_tip\n\n{out}\n"
        )
        log(f"DONE pass={gate}")
        return 0 if gate else 1

    # proper AccFuse path if loaders exist
    log("AccFuse CM-off path")
    return 1


if __name__ == "__main__":
    raise SystemExit(main())
