"""Dual-family causal τ=30 HP ensemble: linear_hp30(SW2) ↔ BMMS3-mean4+hp30.

Novel vs closed methods:
  - Acc-fuse SW2↔BMMS (raw, no HP)
  - SW2↔linear_hp30 soft/hard (SW2 fuse vs clf hp30)
  - B1/hier dwell on single hp30 streams
  - multi-τ / B3 odd EMA on linear_hp30 alone

Hypothesis: both families already carry the shift-robust HP property that
makes linear_hp30 win on real switches; soft-mixing complementary front-ends
may lift LODO Acc/H above the 0.80/70 bar without destroying external H≥0.65.

Selection: mean LODO Acc then H @ HMM p_stay=0.994, scale=0.8.
External emissions from blended train corpus only (never AASD/Carta labels).
"""
from __future__ import annotations

import json
import os
import pickle
import time
from pathlib import Path

import numpy as np

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

P_STAY, SCALE = 0.994, 0.8
LOOKAHEAD = 0.75
WS = [0.0, 0.25, 0.5, 0.75, 1.0]
RUN_ID = "dual_hp30_sw2_bmms_20261108"
RUN_DIR = os.path.join(EXP, "experiments", "multi_agent_opt", "runs", RUN_ID)
OUT_JSON = os.path.join(EXP, "results", "research", "dual_hp30_sw2_bmms.json")
RESULTS_MD = os.path.join(EXP, "multi_agent_opt", "results_dual_hp30_sw2_bmms.md")
TEST_NAMES = ("AASD", "Carta2026")


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


def signed(e):
    return (np.asarray(e["r0"], np.float64) - np.asarray(e["r1"], np.float64))


def as_sym(template, s):
    d = dict(template)
    s = np.asarray(s, np.float64)
    d["r0"] = (s / 2).astype(np.float32)
    d["r1"] = (-s / 2).astype(np.float32)
    for kk in ("att", "t_end", "att10", "r0_10", "r1_10"):
        if kk in template and hasattr(template[kk], "__len__"):
            n = min(len(template[kk]), len(s))
            d[kk] = template[kk][:n]
    d["att"] = template["att"][: len(s)]
    d["t_end"] = template["t_end"][: len(s)]
    return d


def apply_hp30_ev(ev):
    out = {}
    for ds, table in ev.items():
        out[ds] = {}
        for k, e in table.items():
            h = V4.highpass(signed(e)[:, None], tau=30.0, hop=0.25)[:, 0]
            out[ds][k] = as_sym(e, h)
    return out


def blend_ev(a, b, w):
    out = {}
    for k in a:
        sa, sb = signed(a[k]), signed(b[k])
        n = min(len(sa), len(sb))
        s = (1.0 - w) * sa[:n] + w * sb[:n]
        out[k] = as_sym(a[k], s)
    return out


def fold_path(exp, ds):
    for root in (EXP, DATA_EXP):
        p = os.path.join(root, "folds", exp, f"{ds}.pkl")
        if os.path.exists(p):
            return p
    raise FileNotFoundError(exp, ds)


def load_mean4_family(exps):
    per_ds = {ds: [] for ds in DS_KEYS}
    for exp in exps:
        for ds in DS_KEYS:
            with open(fold_path(exp, ds), "rb") as fh:
                per_ds[ds].append(pickle.load(fh)["evidence"]["causal"])
    out = {}
    for ds in DS_KEYS:
        evs = per_ds[ds]
        table = {}
        for k in evs[0]:
            r0 = np.mean([e[k]["r0"] for e in evs], 0)
            r1 = np.mean([e[k]["r1"] for e in evs], 0)
            d = dict(evs[0][k])
            d["r0"], d["r1"] = r0.astype(np.float32), r1.astype(np.float32)
            table[k] = d
        out[ds] = table
    return out


def score_lodo(ev, p_stay=P_STAY, scale=SCALE):
    per = {}
    for ds in DS_KEYS:
        A = np.concatenate([
            signed(e) * np.where(e["att"] == 0, 1.0, -1.0)
            for d in DS_KEYS if d != ds for e in ev[d].values()
        ])
        mu, sd = float(A.mean()), float(A.std())
        r = S.score_dataset(ds, ev, LOOKAHEAD, emis=(mu, sd * scale), p_stay=p_stay)
        per[ds] = r
    mH = float(np.mean([per[d]["H"] for d in DS_KEYS]))
    mA = float(np.mean([per[d]["Acc"] for d in DS_KEYS]))
    return per, mH, mA


def load_ext_mean4(tag):
    out = {}
    for ds in TEST_NAMES:
        evs = []
        for s in range(4):
            name = f"ext_clf_{ds}_{tag}_evidence_s{s}.pkl"
            for root in (os.path.join(EXP, "results", "research"),
                         os.path.join(DATA_EXP, "results", "research")):
                p = os.path.join(root, name)
                if os.path.exists(p):
                    with open(p, "rb") as fh:
                        evs.append(pickle.load(fh))
                    break
            else:
                raise FileNotFoundError(name)
        table = {}
        for k in evs[0]:
            r0 = np.mean([e[k]["r0"] for e in evs], 0)
            r1 = np.mean([e[k]["r1"] for e in evs], 0)
            d = dict(evs[0][k])
            d["r0"], d["r1"] = r0.astype(np.float32), r1.astype(np.float32)
            table[k] = d
        out[ds] = table
    return out


def targets_ok(lodo_H, lodo_Acc, ext):
    # User bars: LODO H>0.80 Acc>70; test H>=0.65 (both AASD and Carta)
    aasd_h = ext["AASD"]["H"]
    carta_h = ext["Carta2026"]["H"]
    return (
        lodo_H > 0.80
        and lodo_Acc > 70.0
        and aasd_h >= 0.65
        and carta_h >= 0.65
    )


def main():
    t0 = time.time()
    os.makedirs(RUN_DIR, exist_ok=True)
    open(os.path.join(RUN_DIR, "run.log"), "w").close()
    log("=== dual-family hp30: SW2-linear_hp30 ↔ BMMS-hp30 ===")

    # Stream A: published linear_hp30 from 4 SW2-classifier seeds (V4 path)
    _, sw2_hp, la = V4._mean_and_hp_from_folds()
    log(f"SW2 linear_hp30 loaded la={la}")

    # Stream B: BMMS3 mean4 then τ=30 HP
    bmms_raw = load_mean4_family([
        f"direct_clf__eaP_n5_t60_w10_bmms3enh_ptSPK_s{s}" for s in range(4)
    ])
    bmms_hp = apply_hp30_ev(bmms_raw)
    log("BMMS3 mean4 + hp30 built")

    # Baselines alone @ preset HMM
    for name, ev in (("sw2_hp30", sw2_hp), ("bmms_hp30", bmms_hp)):
        per, mH, mA = score_lodo(ev)
        log(f"  baseline {name} LODO H={mH:.4f} Acc={mA:.2f} "
            f"AVGC={per['AVGC']['H']:.4f}/{per['AVGC']['Acc']:.2f}")

    grid = []
    for w in WS:
        ev = {ds: blend_ev(sw2_hp[ds], bmms_hp[ds], w) for ds in DS_KEYS}
        per, mH, mA = score_lodo(ev)
        grid.append(dict(
            w=w, mean_H=mH, mean_Acc=mA,
            per={d: dict(H=float(per[d]["H"]), Acc=float(per[d]["Acc"])) for d in DS_KEYS},
        ))
        log(f"  w={w:.2f} LODO mean H {mH:.4f} Acc {mA:.2f}")

    grid_sorted = sorted(grid, key=lambda r: (r["mean_Acc"], r["mean_H"]), reverse=True)
    best = grid_sorted[0]
    w_star = best["w"]
    log(f"SELECTED w={w_star:.2f} (BMMS weight) LODO Acc {best['mean_Acc']:.2f} H {best['mean_H']:.4f}")

    ev_star = {ds: blend_ev(sw2_hp[ds], bmms_hp[ds], w_star) for ds in DS_KEYS}
    A = np.concatenate([
        signed(e) * np.where(e["att"] == 0, 1.0, -1.0)
        for ds in DS_KEYS for e in ev_star[ds].values()
    ])
    mu, sd = float(A.mean()), float(A.std())
    log(f"external emis mu={mu:.4f} sd={sd:.4f}")

    sw2_ext_raw = load_ext_mean4("w10b3sw2P")
    bmms_ext_raw = load_ext_mean4("w10bmms3enhP")
    sw2_ext = apply_hp30_ev(sw2_ext_raw)
    bmms_ext = apply_hp30_ev(bmms_ext_raw)

    ext = {}
    for ds in TEST_NAMES:
        blended = blend_ev(sw2_ext[ds], bmms_ext[ds], w_star)
        r = E.score(blended, mu, sd * SCALE, P_STAY, LOOKAHEAD)
        ext[ds] = {k: float(r[k]) for k in ("H", "Acc", "L", "SDT", "miss", "acc1") if k in r}
        # fill missing keys safely
        for k in ("H", "Acc", "L", "SDT"):
            ext[ds].setdefault(k, float(r.get(k, np.nan)))
        log(f"  EXT {ds} H {ext[ds]['H']:.4f} Acc {ext[ds]['Acc']:.2f} "
            f"L {ext[ds].get('L', float('nan')):.3f} SDT {ext[ds].get('SDT', float('nan')):.2f}")

    ok = targets_ok(best["mean_H"], best["mean_Acc"], ext)
    out = dict(
        method="dual_hp30_sw2_bmms",
        p_stay=P_STAY, scale=SCALE, lookahead=LOOKAHEAD,
        selected_w_bmms=w_star,
        lodo_grid=grid,
        selected_lodo=best,
        emissions=dict(mu=mu, sd=sd),
        external=ext,
        targets=dict(
            LODO_H_gt_80=best["mean_H"] > 0.80,
            LODO_Acc_gt_70=best["mean_Acc"] > 70.0,
            AASD_H_ge_65=ext["AASD"]["H"] >= 0.65,
            Carta_H_ge_65=ext["Carta2026"]["H"] >= 0.65,
            all_pass=ok,
        ),
        vs_linear_hp30=dict(
            lodo="0.7899/69.21",
            aasd="0.6422/53.12",
            carta="0.6520/60.54",
        ),
        elapsed_s=time.time() - t0,
    )
    with open(OUT_JSON, "w") as fh:
        json.dump(out, fh, indent=1, default=float)
    with open(os.path.join(RUN_DIR, "metrics.json"), "w") as fh:
        json.dump(out, fh, indent=1, default=float)

    lines = [
        "# results_dual_hp30_sw2_bmms",
        "",
        f"Selected **w_bmms={w_star}** by mean LODO Acc then H @ HMM {P_STAY}/{SCALE}.",
        "",
        "| Set | H | Acc |",
        "|---|---:|---:|",
        f"| LODO mean | {best['mean_H']:.4f} | {best['mean_Acc']:.2f} |",
        f"| AASD | {ext['AASD']['H']:.4f} | {ext['AASD']['Acc']:.2f} |",
        f"| Carta2026 | {ext['Carta2026']['H']:.4f} | {ext['Carta2026']['Acc']:.2f} |",
        "",
        "vs linear_hp30 0.7899/69.21; AASD 0.6422/53.12; Carta 0.6520/60.54.",
        "",
        f"Gate LODO H>0.80 Acc>70 & test H≥0.65: **{'PASS' if ok else 'FAIL'}**.",
        "",
        f"Artifacts: `{OUT_JSON}`, `{RUN_DIR}/metrics.json`.",
    ]
    Path(RESULTS_MD).write_text("\n".join(lines) + "\n")
    Path(os.path.join(RUN_DIR, "DONE")).write_text("ok\n" if ok else "fail\n")
    log(f"VERDICT {'PASS' if ok else 'FAIL'} elapsed={time.time()-t0:.0f}s wrote {RESULTS_MD}")
    return 0 if ok else 1


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