"""Acc-fuse(raw w=0.5) soft-blended with hp30 streams; H-select among Acc>70.

Follow-up to capped_sw2_hp30_blend: Acc-fuse↔linear_hp30 reached LODO H=0.7995
at α=0.20 (Acc 72.36) but Acc-first selection picked α=0.10. Here:

  1) Finer α grid on Acc-fuse ↔ linear_hp30
  2) Acc-fuse ↔ BMMS-hp30 (BMMS-hp30 has stronger Carta H historically)
  3) Selection: among configs with Acc>70 pick max H; else Acc then H

Distinct from Acc-fuse alone, free SW2↔hp30, dual_hp30 soft-w, capped Acc-first.
"""
from __future__ import annotations

import json
import os
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 EXP
from dual_hp30_sw2_bmms import (
    LOOKAHEAD,
    P_STAY,
    SCALE,
    TEST_NAMES,
    apply_hp30_ev,
    as_sym,
    blend_ev,
    load_ext_mean4,
    load_mean4_family,
    score_lodo,
    signed,
)

RUN_ID = "accfuse_hp30_hselect_20261108"
RUN_DIR = os.path.join(EXP, "experiments", "multi_agent_opt", "runs", RUN_ID)
OUT_JSON = os.path.join(EXP, "results", "research", "accfuse_hp30_hselect.json")
RESULTS_MD = os.path.join(EXP, "multi_agent_opt", "results_accfuse_hp30_hselect.md")

ALPHAS = [round(x, 2) for x in np.arange(0.05, 0.56, 0.05)]


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 load_accfuse():
    from acc_fuse_sw2_bmms import BMMS_LODO, SW2_LODO, blend_ev as bf, load_lodo_family
    sw2 = load_lodo_family([SW2_LODO])
    bmms = load_lodo_family(BMMS_LODO)
    return {ds: bf(sw2[ds], bmms[ds], 0.5) for ds in DS_KEYS}


def align_hp(template_ev, hp_ev):
    out = {}
    for ds in DS_KEYS:
        out[ds] = {}
        for k, e in template_ev[ds].items():
            if k not in hp_ev[ds]:
                out[ds][k] = e
                continue
            h = signed(hp_ev[ds][k])
            t = signed(e)
            n = min(len(h), len(t))
            out[ds][k] = as_sym(e, h[:n])
    return out


def select(grid):
    ok = [r for r in grid if r["mean_Acc"] > 70.0]
    pool = ok if ok else grid
    return sorted(pool, key=lambda r: (r["mean_H"], r["mean_Acc"]), reverse=True)[0]


def run_family(name, base, hp, alphas):
    log(f"=== {name} ===")
    grid = []
    for a in alphas:
        ev = {ds: blend_ev(base[ds], hp[ds], a) for ds in DS_KEYS}
        per, mH, mA = score_lodo(ev)
        grid.append(dict(
            alpha=a, 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"  α={a:.2f} LODO H={mH:.4f} Acc={mA:.2f}")
    best = select(grid)
    log(f"  SELECTED α={best['alpha']:.2f} H={best['mean_H']:.4f} Acc={best['mean_Acc']:.2f}")
    return grid, best


def score_ext(base_ext, hp_ext, alpha, mu, sd):
    ext = {}
    for ds in TEST_NAMES:
        blended = blend_ev(base_ext[ds], hp_ext[ds], alpha)
        r = E.score(blended, mu, sd * SCALE, P_STAY, 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}")
    return ext


def main():
    t0 = time.time()
    os.makedirs(RUN_DIR, exist_ok=True)
    open(os.path.join(RUN_DIR, "run.log"), "w").close()
    log("=== AccFuse ↔ hp30 H-select among Acc>70 ===")

    af = load_accfuse()
    _, lin_hp, _ = V4._mean_and_hp_from_folds()
    lin_al = align_hp(af, lin_hp)
    bmms_hp = apply_hp30_ev(load_mean4_family([
        f"direct_clf__eaP_n5_t60_w10_bmms3enh_ptSPK_s{s}" for s in range(4)
    ]))
    bmms_al = align_hp(af, bmms_hp)

    families = {}
    g1, b1 = run_family("accfuse_x_linear_hp30", af, lin_al, ALPHAS)
    families["accfuse_x_linear_hp30"] = dict(grid=g1, selected=b1)
    g2, b2 = run_family("accfuse_x_bmms_hp30", af, bmms_al, ALPHAS)
    families["accfuse_x_bmms_hp30"] = dict(grid=g2, selected=b2)

    # Overall among Acc>70 by H
    pool = [
        dict(
            name=n,
            mean_H=families[n]["selected"]["mean_H"],
            mean_Acc=families[n]["selected"]["mean_Acc"],
            alpha=families[n]["selected"]["alpha"],
        )
        for n in families
    ]
    overall = select(pool)
    overall_name = overall["name"]
    log(f"OVERALL {overall_name} α={overall['alpha']:.2f}")

    if overall_name == "accfuse_x_linear_hp30":
        hp_use = lin_al
        tag_ext_hp = "linear"
    else:
        hp_use = bmms_al
        tag_ext_hp = "bmms"

    ev_star = {ds: blend_ev(af[ds], hp_use[ds], overall["alpha"]) 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())

    # External Acc-fuse raw
    sw2e = load_ext_mean4("w10b3sw2P")
    bmmse = load_ext_mean4("w10bmms3enhP")
    af_ext = {ds: blend_ev(sw2e[ds], bmmse[ds], 0.5) for ds in TEST_NAMES}
    if tag_ext_hp == "linear":
        # rebuild linear_hp30 external aligned to af_ext keys
        train_logits, _ = V4.load_train()
        test_logits, test_meta = V4.load_test()
        base = {}
        base.update(train_logits)
        base.update(test_logits)
        streams = V4.linear_streams(base, "hp30")
        hp_ext = {}
        for ds in TEST_NAMES:
            hp_ext[ds] = {}
            for k, d in streams[ds].items():
                if k not in af_ext[ds]:
                    continue
                n = min(len(d), len(af_ext[ds][k]["r0"]))
                hp_ext[ds][k] = as_sym(af_ext[ds][k], np.asarray(d, float)[:n])
    else:
        hp_ext = apply_hp30_ev(bmmse)

    ext = score_ext(af_ext, hp_ext, overall["alpha"], mu, sd)
    ok = (
        overall["mean_H"] > 0.80 and overall["mean_Acc"] > 70.0
        and ext["AASD"]["H"] >= 0.65 and ext["Carta2026"]["H"] >= 0.65
    )
    out = dict(
        method="accfuse_hp30_hselect",
        alphas=ALPHAS,
        families=families,
        overall=overall,
        external=ext,
        emissions=dict(mu=mu, sd=sd),
        targets=dict(all_pass=ok,
                     LODO_H_gt_80=overall["mean_H"] > 0.80,
                     LODO_Acc_gt_70=overall["mean_Acc"] > 70.0,
                     AASD_H_ge_65=ext["AASD"]["H"] >= 0.65,
                     Carta_H_ge_65=ext["Carta2026"]["H"] >= 0.65),
        elapsed_s=time.time() - t0,
    )
    # JSON-safe: drop huge per if needed — already small
    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)
    Path(RESULTS_MD).write_text(
        "# results_accfuse_hp30_hselect\n\n"
        f"Selected **{overall_name} α={overall['alpha']}** "
        f"(H-max among Acc>70).\n\n"
        f"| LODO | {overall['mean_H']:.4f} / {overall['mean_Acc']:.2f} |\n"
        f"| AASD | {ext['AASD']['H']:.4f} / {ext['AASD']['Acc']:.2f} |\n"
        f"| Carta | {ext['Carta2026']['H']:.4f} / {ext['Carta2026']['Acc']:.2f} |\n\n"
        f"Gate: **{'PASS' if ok else 'FAIL'}**.\n"
        f"Artifacts: `{OUT_JSON}`.\n"
    )
    log(f"VERDICT {'PASS' if ok else 'FAIL'} elapsed={time.time()-t0:.0f}s")
    return 0 if ok else 1


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