"""B3 successor: multi-scale odd EMA bank + tanh readout on frozen linear_hp30,
with residual skip blend α·B3 + (1-α)·hp30 (α selected on LODO inners only).

Inherits antisymmetric odd features from b3_e10_g0.5 but adds:
  - causal EMA bank τ∈{(4,10,30), (4,10), (10,30)} (not closed multi-τ HP on raw logits)
  - hp30 residual skip to preserve external shift calibration
  - honest per-outer ridge fit on train4 (unlike global-fit a4_b3 placeholder ev)

Gate: LODO H>0.80 Acc>70; AASD & Carta H>0.65 each @ p_stay=0.994 scale=0.8.
"""
from __future__ import annotations

import json
import os
import time
from collections import Counter

import numpy as np

import ensemble_clf_nested as N
import ensemble_clf_transformer_v4 as V4
import eval_external as E
from ablate_hp30_oneknob import (
    HOP,
    LOOKAHEAD,
    P_STAY,
    SCALE,
    TEST_NAMES,
    archive_fail,
    build_ext_ev,
    ema_1d,
    emis_on,
    load_ext_seed_stack,
    load_seed_stack,
    score_dataset_rich,
    score_ext_ev,
    write_md,
    write_subj_csv,
)
from common import DS_KEYS, SEED
from common_exp import EXP

RUN_ID = f"b3_multiscale_resid_{time.strftime('%Y%m%d')}"
RUN_DIR = os.path.join(EXP, "experiments", "multi_agent_opt", "runs", RUN_ID)
METHOD = "b3_multiscale_resid_hp30"

BANKS = {
    "e4_e10_e30": (4.0, 10.0, 30.0),
    "e4_e10": (4.0, 10.0),
    "e10_e30": (10.0, 30.0),
}
GAINS = (0.5, 1.0)
ALPHAS = (0.35, 0.5, 0.65, 0.8, 1.0)
LAMS = (1e-2, 5e-2)

BASELINE = dict(
    linear_hp30_lodo="0.7899/69.21",
    linear_hp30_aasd="0.6422/53.12",
    linear_hp30_carta="0.6520/60.54",
    b3_e10_g0p5_lodo="0.8048/73.21",
    b3_e10_g0p5_aasd="0.6144/50.21",
    b3_e10_g0p5_carta="0.6154/56.36",
)


def log(msg):
    print(f"{time.strftime('%F %T')} {msg}", flush=True)
    os.makedirs(RUN_DIR, exist_ok=True)
    with open(os.path.join(RUN_DIR, "run.log"), "a") as fh:
        fh.write(msg + "\n")


def gate_ok(lodo, ext):
    return (
        lodo["H"] > 0.80
        and lodo["Acc"] > 70.0
        and ext["AASD"]["H"] > 0.65
        and ext["Carta2026"]["H"] > 0.65
    )


def tag_name(bank, gain, alpha, lam):
    taus = "_".join(f"{t:g}" for t in BANKS[bank])
    return f"bank{bank}_g{gain:g}_a{alpha:g}_lam{lam:g}"


def hp_subset(hp_ev, datasets):
    return {ds: hp_ev[ds] for ds in datasets if ds in hp_ev}


def fit_b3_bank(train_hp_ev, taus, gain, lam):
    xs, ys = [], []
    for ds in train_hp_ev:
        for e in train_hp_ev[ds].values():
            d = (e["r0"] - e["r1"]).astype(np.float64)
            emas = [ema_1d(d, t) for t in taus]
            fe = np.stack([d] + emas, 1)
            lab = np.where(np.asarray(e["att"]) == 0, 1.0, -1.0)
            xs.append(fe)
            ys.append(lab)
    X = np.concatenate(xs, 0)
    y = np.concatenate(ys, 0)
    rng = np.random.default_rng(SEED)
    if len(X) > 200_000:
        idx = rng.choice(len(X), 200_000, replace=False)
        X, y = X[idx], y[idx]
    nfeat = X.shape[1]
    w = np.linalg.solve(X.T @ X + lam * np.eye(nfeat), X.T @ y)

    def b3_on_d(d):
        d = np.asarray(d, np.float64)
        emas = [ema_1d(d, t) for t in taus]
        fe = np.stack([d] + emas, 1)
        return (gain * np.tanh(fe @ w)).astype(np.float64)

    return b3_on_d, w


def stream_from_hp(hp_ev, bank, gain, alpha, lam, train_ds):
    train_hp = hp_subset(hp_ev, train_ds)
    taus = BANKS[bank]
    b3_fn, _w = fit_b3_bank(train_hp, taus, gain, lam)

    dmap = {}
    for ds, table in hp_ev.items():
        dmap[ds] = {}
        for k, e in table.items():
            d0 = (e["r0"] - e["r1"]).astype(np.float64)
            yb = b3_fn(d0)
            dmap[ds][k] = (alpha * yb + (1.0 - alpha) * d0).astype(np.float64)
    return dmap


def dmap_to_ev(dmap, hp_ev):
    ev = {}
    for ds, table in dmap.items():
        ev[ds] = {}
        for k, d in table.items():
            e = hp_ev[ds][k]
            ev[ds][k] = dict(
                r0=d,
                r1=np.zeros_like(d),
                att=e["att"],
                t_end=e["t_end"],
                pre_switched=True,
            )
    return ev


def build_grid():
    grid = []
    for bank in BANKS:
        for gain in GAINS:
            for alpha in ALPHAS:
                for lam in LAMS:
                    grid.append((tag_name(bank, gain, alpha, lam), bank, gain, alpha, lam))
    return grid


def nested_select(hp_ev, grid, log_path):
    picks = []
    for outer in DS_KEYS:
        inner_means = {}
        for tag, bank, gain, alpha, lam in grid:
            train4 = [d for d in DS_KEYS if d != outer]
            dmap = stream_from_hp(hp_ev, bank, gain, alpha, lam, train4)
            rows = []
            for inner in DS_KEYS:
                if inner == outer:
                    continue
                train3 = [d for d in DS_KEYS if d not in (outer, inner)]
                mu, sd = N.emis(dmap, train3)
                rows.append(N.evaluate(inner, dmap[inner], mu, sd * SCALE, P_STAY))
            inner_means[tag] = (
                float(np.mean([r["Acc"] for r in rows])),
                float(np.mean([r["H"] for r in rows])),
            )
        best_tag = max(inner_means.keys(), key=lambda t: inner_means[t])
        spec = next((bank, gain, alpha, lam) for t, bank, gain, alpha, lam in grid if t == best_tag)
        train4 = [d for d in DS_KEYS if d != outer]
        dmap = stream_from_hp(hp_ev, spec[0], spec[1], spec[2], spec[3], train4)
        cev = dmap_to_ev(dmap, hp_ev)
        mu, sd = emis_on(cev, train4)
        outer_r = score_dataset_rich(outer, cev, LOOKAHEAD, (mu, sd * SCALE), P_STAY)
        picks.append(
            dict(
                outer_ds=outer,
                selected=best_tag,
                inner_Acc=inner_means[best_tag][0],
                inner_H=inner_means[best_tag][1],
                metrics=outer_r,
            )
        )
        log(
            f"  {METHOD} outer={outer} sel={best_tag} "
            f"innerAcc={inner_means[best_tag][0]:.2f} innerH={inner_means[best_tag][1]:.4f} "
            f"→ H={outer_r['H']:.4f} Acc={outer_r['Acc']:.2f} "
            f"SDT={outer_r['SDT']:.2f} miss={outer_r['miss_rate']:.3f}"
        )

    votes = Counter(p["selected"] for p in picks)
    top_n = votes.most_common()[0][1]
    candidates = [t for t, n in votes.items() if n == top_n]

    def tag_outer_acc(t):
        rows = [p["metrics"] for p in picks if p["selected"] == t]
        return (
            float(np.mean([r["Acc"] for r in rows])),
            float(np.mean([r["H"] for r in rows])),
        )

    tag_ext = max(candidates, key=tag_outer_acc)
    bank, gain, alpha, lam = None, None, None, None
    for t, b, g, a, l in grid:
        if t == tag_ext:
            bank, gain, alpha, lam = b, g, a, l
            break

    per = {}
    subj_rows = []
    for outer in DS_KEYS:
        train4 = [d for d in DS_KEYS if d != outer]
        dmap = stream_from_hp(hp_ev, bank, gain, alpha, lam, train4)
        cev = dmap_to_ev(dmap, hp_ev)
        mu, sd = emis_on(cev, train4)
        per[outer] = score_dataset_rich(outer, cev, LOOKAHEAD, (mu, sd * SCALE), P_STAY)
        subj_rows.extend(per[outer]["subjects"])
    lodo = dict(
        H=float(np.mean([per[d]["H"] for d in DS_KEYS])),
        Acc=float(np.mean([per[d]["Acc"] for d in DS_KEYS])),
        L=float(np.mean([per[d]["L"] for d in DS_KEYS])),
        SDT=float(np.nanmean([per[d]["SDT"] for d in DS_KEYS])),
        miss_rate=float(np.mean([per[d]["miss_rate"] for d in DS_KEYS])),
        per=per,
    )
    log(f"  {METHOD} GLOBAL sel={tag_ext} votes={dict(votes)} LODO mean H={lodo['H']:.4f} Acc={lodo['Acc']:.2f}")
    return tag_ext, (bank, gain, alpha, lam), lodo, picks, subj_rows


def ext_transform_factory(bank, gain, alpha, lam, hp_ev):
    train_hp = hp_subset(hp_ev, DS_KEYS)
    taus = BANKS[bank]
    b3_fn, _ = fit_b3_bank(train_hp, taus, gain, lam)

    def transform_D(D):
        d0 = V4.highpass(D).mean(1).astype(np.float64)
        yb = b3_fn(d0)
        return (alpha * yb + (1.0 - alpha) * d0).astype(np.float64)

    return transform_D


def write_results_md(path, tag, lodo, ext):
    gate_line = (
        "Gate: LODO H>0.80 Acc>70; AASD H>0.65; Carta H>0.65 (Acc reported, not hard-gated)."
    )
    cmp_lines = [
        "",
        "## vs baselines",
        "",
        "| Model | LODO H/Acc | AASD H/Acc | Carta H/Acc |",
        "|---|---|---|---|",
        f"| linear_hp30 | {BASELINE['linear_hp30_lodo']} | {BASELINE['linear_hp30_aasd']} | "
        f"{BASELINE['linear_hp30_carta']} |",
        f"| b3_e10_g0.5 | {BASELINE['b3_e10_g0p5_lodo']} | {BASELINE['b3_e10_g0p5_aasd']} | "
        f"{BASELINE['b3_e10_g0p5_carta']} |",
        f"| **{tag}** | **{lodo['H']:.4f}/{lodo['Acc']:.2f}** | "
        f"{ext['AASD']['H']:.4f}/{ext['AASD']['Acc']:.2f} | "
        f"{ext['Carta2026']['H']:.4f}/{ext['Carta2026']['Acc']:.2f} |",
        "",
        gate_line,
    ]
    write_md(
        path,
        "b3_multiscale_resid",
        tag,
        lodo,
        ext,
        "Inherits B3 odd EMA+tanh on frozen τ=30 hp30; adds multi-τ bank + hp30 residual α.",
    )
    with open(path, "a") as fh:
        fh.write("\n".join(cmp_lines) + "\n")
        fh.write(f"\nVerdict: **{'PASS' if gate_ok(lodo, ext) else 'FAIL'}**.\n")


def archive_fail_custom(tag, lodo, ext, md_path):
    line = (
        f"- **{METHOD}** (`b3_multiscale_resid_hp30.py`; {tag}): "
        f"LODO **{lodo['H']:.4f}/{lodo['Acc']:.2f}**; "
        f"AASD **{ext['AASD']['H']:.4f}/{ext['AASD']['Acc']:.2f}**; "
        f"Carta **{ext['Carta2026']['H']:.4f}/{ext['Carta2026']['Acc']:.2f}**. "
        f"PASS-gate FAIL (ext H<0.65 and/or LODO bar). "
        f"Do not rerun this exact multi-τ bank + α-resid grid. `{os.path.basename(md_path)}`."
    )
    with open(os.path.join(EXP, "multi_agent_opt", "ALREADY_TRIED.md"), "a") as fh:
        fh.write("\n" + line + "\n")


def scrub(o):
    if isinstance(o, dict):
        return {k: scrub(v) for k, v in o.items()}
    if isinstance(o, (list, tuple)):
        return [scrub(v) for v in o]
    if isinstance(o, (np.floating, np.integer)):
        return float(o)
    return o


def main():
    t0 = time.time()
    os.makedirs(RUN_DIR, exist_ok=True)
    open(os.path.join(RUN_DIR, "run.log"), "w").close()
    log(f"=== {METHOD} start ===")
    grid = build_grid()
    log(f"grid size {len(grid)} configs")

    stack, mean_ev, hp_ev, la = load_seed_stack()
    V4._install_scorer_state(mean_ev, la)
    test_logits, test_meta = load_ext_seed_stack()

    tag, (bank, gain, alpha, lam), lodo, picks, subj_rows = nested_select(
        hp_ev, grid, os.path.join(RUN_DIR, "run.log")
    )
    write_subj_csv(
        os.path.join(EXP, "results", "research", f"{METHOD}_subjects.csv"),
        subj_rows,
    )

    train_all = stream_from_hp(hp_ev, bank, gain, alpha, lam, DS_KEYS)
    train_ev = dmap_to_ev(train_all, hp_ev)
    mu, sd = emis_on(train_ev, DS_KEYS)
    tf = ext_transform_factory(bank, gain, alpha, lam, hp_ev)
    ext_ev = build_ext_ev(test_logits, test_meta, tf)
    ext = score_ext_ev(ext_ev, mu, sd, os.path.join(RUN_DIR, "run.log"))

    ok = gate_ok(lodo, ext)
    out_json = os.path.join(EXP, "results", "research", f"{METHOD}.json")
    out_md = os.path.join(EXP, "multi_agent_opt", f"results_{METHOD}.md")
    payload = dict(
        method=METHOD,
        selected=tag,
        hyperparams=dict(bank=bank, taus=list(BANKS[bank]), gain=gain, alpha=alpha, lam=lam),
        lodo=dict(
            H=lodo["H"],
            Acc=lodo["Acc"],
            L=lodo["L"],
            SDT=lodo["SDT"],
            miss_rate=lodo["miss_rate"],
            per={
                d: {k: m[k] for k in ("H", "Acc", "L", "SDT", "miss_rate", "acc1", "nSwitches", "nUndetected")}
                for d, m in lodo["per"].items()
            },
        ),
        external=ext,
        picks=picks,
        baselines=BASELINE,
        verdict="PASS" if ok else "FAIL",
    )
    with open(out_json, "w") as fh:
        json.dump(scrub(payload), fh, indent=2)
    write_results_md(out_md, tag, lodo, ext)

    claim = (
        f"| {time.strftime('%Y-%m-%d %H:%M')} +07 | b3-multiscale-resid-hp30 | {tag} | done | "
        f"{payload['verdict']} LODO {lodo['H']:.4f}/{lodo['Acc']:.2f}; "
        f"AASD H={ext['AASD']['H']:.4f} Acc={ext['AASD']['Acc']:.2f}; "
        f"Carta H={ext['Carta2026']['H']:.4f} Acc={ext['Carta2026']['Acc']:.2f}. "
        f"`results_{METHOD}.md`. |"
    )
    with open(os.path.join(EXP, "multi_agent_opt", "CLAIMS.md"), "a") as fh:
        fh.write("\n" + claim + "\n")

    if not ok:
        archive_fail_custom(tag, lodo, ext, out_md)

    log(f"VERDICT {payload['verdict']} wall={time.time() - t0:.0f}s")
    print(f"wrote {out_md} and {out_json}", flush=True)
    return 0 if ok else 1


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