"""CPU Acc fuse: soft-blend SW2 4-seed mean ↔ BMMS3 4-seed mean.

Weights selected by mean LODO Acc then H at the pre-specified HMM
(p_stay=0.994, scale=0.8). Emissions from blended LODO folds only.
External AASD/Carta scored once with the selected weight. Never uses
external labels for selection.

Distinct from tip Acc PP / IRM blends / SW2↔hp30 grids: this is a
front-end family mix (concat-vlaai SW2 vs BMMS correlation DensePath).
"""
from __future__ import annotations

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

import numpy as np

import eval_external as E
import score as S
from common import DS_KEYS
from common_exp import DATA_EXP, EXP, FS

P_STAY, SCALE = 0.994, 0.8
LOOKAHEAD = 0.75
WS = [0.0, 0.25, 0.5, 0.75, 1.0]
RUN_ID = "r3_accfuse_20261107"
RUN_DIR = os.path.join(EXP, "experiments", "multi_agent_opt", "runs", RUN_ID)
OUT_JSON = os.path.join(EXP, "results", "research", "acc_fuse_sw2_bmms.json")
RESULTS_MD = os.path.join(EXP, "multi_agent_opt", "results_acc_fuse_sw2_bmms.md")

SW2_LODO = "direct_clf__eaP_n5_t60_w10b3_ptSPK_aug-sw2_wts"
BMMS_LODO = [
    f"direct_clf__eaP_n5_t60_w10_bmms3enh_ptSPK_s{s}" for s in range(4)
]
SW2_EXT = "w10b3sw2P"
BMMS_EXT = "w10bmms3enhP"
EXT_DIR = os.path.join(DATA_EXP, "results", "research")


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 mean_signed(evs):
    """Average r0-r1 across seed evidence dicts that share keys."""
    keys = sorted(evs[0])
    out = {}
    for k in keys:
        e0 = evs[0][k]
        d = dict(e0)
        r0 = np.mean([ev[k]["r0"] for ev in evs], 0)
        r1 = np.mean([ev[k]["r1"] for ev in evs], 0)
        d["r0"], d["r1"] = r0.astype(np.float32), r1.astype(np.float32)
        if "r0_10" in e0:
            d["r0_10"] = np.mean([ev[k]["r0_10"] for ev in evs], 0).astype(np.float32)
            d["r1_10"] = np.mean([ev[k]["r1_10"] for ev in evs], 0).astype(np.float32)
        out[k] = d
    return out


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


def load_lodo_family(exps):
    """Load and average LODO fold evidence across experiment names (seeds)."""
    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:
                f = pickle.load(fh)
            per_ds[ds].append(f["evidence"]["causal"])
    return {ds: mean_signed(per_ds[ds]) for ds in DS_KEYS}


def blend_ev(a, b, w):
    """signed = (1-w)*a + w*b, stored as symmetric r0/r1."""
    out = {}
    for k in a:
        ea, eb = a[k], b[k]
        sa = (ea["r0"] - ea["r1"]).astype(np.float64)
        sb = (eb["r0"] - eb["r1"]).astype(np.float64)
        # Align lengths if hop grids differ (should match for same W/hop).
        n = min(len(sa), len(sb))
        s = (1.0 - w) * sa[:n] + w * sb[:n]
        d = dict(ea)
        for kk in ("r0", "r1", "att", "t_end", "r0_10", "r1_10", "att10"):
            if kk in ea and hasattr(ea[kk], "__len__"):
                d[kk] = ea[kk][:n] if len(ea[kk]) >= n else ea[kk]
        d["r0"] = (s / 2).astype(np.float32)
        d["r1"] = (-s / 2).astype(np.float32)
        d["att"] = ea["att"][:n]
        d["t_end"] = ea["t_end"][:n]
        out[k] = d
    return out


def score_lodo(ev, p_stay=P_STAY, scale=SCALE):
    la = LOOKAHEAD
    per = {}
    for ds in DS_KEYS:
        A = np.concatenate([
            (e["r0"] - e["r1"]) * 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, la, 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_mean(tag):
    out = {}
    for ds in ("AASD", "Carta2026"):
        evs = []
        for s in range(4):
            path = os.path.join(EXT_DIR, f"ext_clf_{ds}_{tag}_evidence_s{s}.pkl")
            with open(path, "rb") as fh:
                evs.append(pickle.load(fh))
        out[ds] = mean_signed(evs)
    return out


def main():
    os.makedirs(RUN_DIR, exist_ok=True)
    os.makedirs(os.path.dirname(OUT_JSON), exist_ok=True)
    log("=== Acc-fuse SW2 ↔ BMMS3 (CPU) ===")

    log(f"loading SW2 LODO {SW2_LODO}")
    sw2 = load_lodo_family([SW2_LODO])
    log(f"loading BMMS LODO seeds 0-3")
    bmms = load_lodo_family(BMMS_LODO)

    grid = []
    for w in WS:
        ev = {ds: blend_ev(sw2[ds], bmms[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=per[d]["H"], Acc=per[d]["Acc"]) for d in DS_KEYS}))
        log(f"  w={w:.2f} LODO mean H {mH:.4f} Acc {mA:.2f}")

    # Select by mean Acc then H (never external).
    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} LODO Acc {best['mean_Acc']:.2f} H {best['mean_H']:.4f}")

    # Emissions on full blended corpus (all 5 folds) for external.
    ev_star = {ds: blend_ev(sw2[ds], bmms[ds], w_star) for ds in DS_KEYS}
    A = np.concatenate([
        (e["r0"] - e["r1"]) * 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} (×scale {SCALE})")

    sw2_ext = load_ext_mean(SW2_EXT)
    bmms_ext = load_ext_mean(BMMS_EXT)
    ext = {}
    for ds in ("AASD", "Carta2026"):
        blended = blend_ev(sw2_ext[ds], bmms_ext[ds], w_star)
        r = E.score(blended, mu, sd * SCALE, P_STAY, LOOKAHEAD)
        ext[ds] = r
        log(f"  EXT {ds} H {r['H']:.4f} Acc {r['Acc']:.2f} L {r['L']:.3f}")

    out = dict(
        method="acc_fuse_sw2_bmms",
        p_stay=P_STAY, scale=SCALE, lookahead=LOOKAHEAD,
        selected_w=w_star, lodo_grid=grid, selected_lodo=best,
        emissions=dict(mu=mu, sd=sd),
        external=ext,
        targets=dict(AASD_Acc_gt_70=ext["AASD"]["Acc"] > 70,
                     Carta_Acc_gt_60=ext["Carta2026"]["Acc"] > 60,
                     Performance_H=dict(AASD=ext["AASD"]["H"], Carta=ext["Carta2026"]["H"])),
    )
    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_acc_fuse_sw2_bmms",
        "",
        f"Selected **w={w_star}** (BMMS weight) by mean LODO Acc then H @ HMM {P_STAY}/{SCALE}.",
        "",
        f"| Set | H | Acc % | vs tip Acc 54.05/60.60 |",
        f"|---|---:|---:|---|",
        f"| AASD | {ext['AASD']['H']:.4f} | {ext['AASD']['Acc']:.2f} | "
        f"{'PASS Acc>70' if ext['AASD']['Acc']>70 else 'FAIL Acc>70'} |",
        f"| Carta2026 | {ext['Carta2026']['H']:.4f} | {ext['Carta2026']['Acc']:.2f} | "
        f"{'PASS Acc>60' if ext['Carta2026']['Acc']>60 else 'FAIL Acc>60'} |",
        f"| LODO mean | {best['mean_H']:.4f} | {best['mean_Acc']:.2f} | |",
        "",
        f"Artifacts: `{OUT_JSON}`, `{RUN_DIR}/metrics.json`.",
    ]
    Path(RESULTS_MD).write_text("\n".join(lines) + "\n")
    log(f"wrote {OUT_JSON} and {RESULTS_MD}")
    # Mark claim done via note file
    Path(os.path.join(RUN_DIR, "DONE")).write_text("ok\n")


if __name__ == "__main__":
    main()
