"""AC-transplant: keep tip DC/LP, import stem AC — NOT soft-w tip↔soft_hp(stem).

Structural novelty vs ALREADY_TRIED soft_hp50 / capped_stemhp_resid / multitau:
  capped resid used tip + α·clip(stem_hp − tip)  (= soft-w with pure hp)
  soft_hp50 used (1-w)·tip + w·(0.5·stem + 0.5·stem_hp)  (injects stem DC)

Here:
  A) tip + α · (stem_hp_τ − tip_hp_τ)          # AC residual transplant
  B) tip_lp_τ + β·stem_hp_τ + (1−β)·tip_hp_τ   # spectral split remix
  C) tip + α · (stem_hp_τ1 − stem_hp_τ2)       # mid-band only (τ1<τ2)

Selection: LODO Acc>75 then H; external acceptance only. Never AASD/Carta labels.
"""
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
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,
)
from accfuse_hp30_hselect import align_hp, load_accfuse
from stem_hp30_accfuse import (
    TIP_ALPHA,
    apply_hp30_signed,
    emis_from,
    ev_to_signed,
    load_stem_ext,
    load_stem_honest,
    select,
)

RUN_ID = "ac_transplant_tip_stem_20261109"
RUN_DIR = os.path.join(EXP, "experiments", "multi_agent_opt", "runs", RUN_ID)
OUT_JSON = os.path.join(EXP, "results", "research", "ac_transplant_tip_stem.json")
RESULTS_MD = os.path.join(EXP, "multi_agent_opt", "results_ac_transplant_tip_stem.md")
P_CANDS = [(0.994, 0.8), (0.996, 0.8), (0.998, 0.8), (0.998, 1.0)]
ALPHAS = (0.25, 0.50, 0.75, 1.00, 1.25)
BETAS = (0.25, 0.50, 0.75, 1.00)
TAUS = (30, 40, 50)
MIDBAND = ((15, 50), (20, 50), (30, 60))


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 map_streams(a, b, fn):
    out = {}
    for ds in a:
        out[ds] = {}
        for k in a[ds]:
            if k not in b[ds]:
                continue
            sa, sb = a[ds][k], b[ds][k]
            n = min(len(sa), len(sb))
            out[ds][k] = fn(sa[:n], sb[:n])
    return out


def signed_to_ev(streams, template_ev):
    out = {}
    for ds in streams:
        out[ds] = {}
        tmpl = template_ev[ds]
        for k, s in streams[ds].items():
            if k not in tmpl:
                continue
            n = min(len(s), len(tmpl[k]["att"]))
            out[ds][k] = as_sym(tmpl[k], np.asarray(s, np.float64)[:n])
    return out


def score_family(name, signed_streams, tmpl, all_rows):
    ev = signed_to_ev(signed_streams, tmpl)
    grid = []
    for p, sc in P_CANDS:
        per, mH, mA = score_lodo(ev, p_stay=p, scale=sc)
        row = dict(
            family=name, p=p, sc=sc, mean_H=mH, mean_Acc=mA,
            per={d: dict(H=float(per[d]["H"]), Acc=float(per[d]["Acc"])) for d in DS_KEYS},
        )
        grid.append(row)
    best_full = select(grid)  # grid rows already have mean_H / mean_Acc
    log(
        f"  {name}: best p={best_full['p']} sc={best_full['sc']} "
        f"LODO {best_full['mean_H']:.4f}/{best_full['mean_Acc']:.2f}"
    )
    all_rows.extend(grid)
    return ev, best_full


def build_ext_tip_and_stem():
    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}
    train_logits, _ = V4.load_train()
    test_logits, _ = 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])
    tip_ext = {ds: blend_ev(af_ext[ds], hp_ext[ds], TIP_ALPHA) for ds in TEST_NAMES}
    tip_ext_s = ev_to_signed(tip_ext)
    stem_ext_s = load_stem_ext()
    return tip_ext, tip_ext_s, stem_ext_s


def score_ext(ev_ext, mu, sd, p, sc):
    out = {}
    for ds in TEST_NAMES:
        r = E.score(ev_ext[ds], mu, sd * sc, p, LOOKAHEAD)
        out[ds] = {k: float(r[k]) for k in ("H", "Acc", "L", "SDT") if k in r}
        log(f"    EXT {ds} H={out[ds]['H']:.4f} Acc={out[ds]['Acc']:.2f}")
    return out


def main():
    t0 = time.time()
    os.makedirs(RUN_DIR, exist_ok=True)
    open(os.path.join(RUN_DIR, "run.log"), "w").close()
    log("=== AC-transplant tip↔stem (preserve tip DC) ===")

    af = load_accfuse()
    _, lin_hp, _ = V4._mean_and_hp_from_folds()
    lin_al = align_hp(af, lin_hp)
    tip_ev = {ds: blend_ev(af[ds], lin_al[ds], TIP_ALPHA) for ds in DS_KEYS}
    tip_s = ev_to_signed(tip_ev)
    stem_s = load_stem_honest()
    tmpl = af

    tip_ext, tip_ext_s, stem_ext_s = build_ext_tip_and_stem()

    # Sanity tip
    per, mH, mA = score_lodo(tip_ev, p_stay=0.996, scale=0.8)
    log(f"SANITY tip@0.996/0.8 LODO {mH:.4f}/{mA:.2f} (expect ~0.8011/71.43)")

    all_rows = []
    candidates = []  # (name, lodo_ev, ext_builder, best_row)

    # --- Family A: AC residual transplant ---
    for tau in TAUS:
        tip_hp = apply_hp30_signed(tip_s, tau=tau)
        stem_hp = apply_hp30_signed(stem_s, tau=tau)
        tip_hp_e = apply_hp30_signed(tip_ext_s, tau=tau)
        stem_hp_e = apply_hp30_signed(stem_ext_s, tau=tau)
        for a in ALPHAS:
            name = f"A_acresid_t{tau}_a{a:.2f}"
            # tip + a*(stem_hp - tip_hp) — preserves tip DC exactly
            signed = {}
            for ds in tip_s:
                signed[ds] = {}
                for k in tip_s[ds]:
                    if k not in stem_hp[ds] or k not in tip_hp[ds]:
                        continue
                    n = min(len(tip_s[ds][k]), len(stem_hp[ds][k]), len(tip_hp[ds][k]))
                    signed[ds][k] = tip_s[ds][k][:n] + a * (
                        stem_hp[ds][k][:n] - tip_hp[ds][k][:n]
                    )
            ev, best = score_family(name, signed, tmpl, all_rows)

            def _ext_builder(
                tip_e=tip_ext_s, shp=stem_hp_e, thp=tip_hp_e, aa=a, te=tip_ext
            ):
                s = {}
                for ds in tip_e:
                    s[ds] = {}
                    for k in tip_e[ds]:
                        if k not in shp[ds] or k not in thp[ds]:
                            continue
                        n = min(len(tip_e[ds][k]), len(shp[ds][k]), len(thp[ds][k]))
                        s[ds][k] = tip_e[ds][k][:n] + aa * (
                            shp[ds][k][:n] - thp[ds][k][:n]
                        )
                return signed_to_ev(s, te)

            candidates.append((name, ev, _ext_builder, best))

    # --- Family B: spectral LP keep + AC remix ---
    for tau in (30, 50):
        tip_hp = apply_hp30_signed(tip_s, tau=tau)
        stem_hp = apply_hp30_signed(stem_s, tau=tau)
        tip_hp_e = apply_hp30_signed(tip_ext_s, tau=tau)
        stem_hp_e = apply_hp30_signed(stem_ext_s, tau=tau)
        for b in BETAS:
            name = f"B_lpsplit_t{tau}_b{b:.2f}"
            signed = {}
            for ds in tip_s:
                signed[ds] = {}
                for k in tip_s[ds]:
                    if k not in stem_hp[ds] or k not in tip_hp[ds]:
                        continue
                    n = min(len(tip_s[ds][k]), len(stem_hp[ds][k]), len(tip_hp[ds][k]))
                    tip = tip_s[ds][k][:n]
                    th = tip_hp[ds][k][:n]
                    sh = stem_hp[ds][k][:n]
                    tip_lp = tip - th
                    signed[ds][k] = tip_lp + b * sh + (1.0 - b) * th
            ev, best = score_family(name, signed, tmpl, all_rows)

            def _ext_builder(
                tip_e=tip_ext_s, shp=stem_hp_e, thp=tip_hp_e, bb=b, te=tip_ext
            ):
                s = {}
                for ds in tip_e:
                    s[ds] = {}
                    for k in tip_e[ds]:
                        if k not in shp[ds] or k not in thp[ds]:
                            continue
                        n = min(len(tip_e[ds][k]), len(shp[ds][k]), len(thp[ds][k]))
                        tip = tip_e[ds][k][:n]
                        th = thp[ds][k][:n]
                        sh = shp[ds][k][:n]
                        s[ds][k] = (tip - th) + bb * sh + (1.0 - bb) * th
                return signed_to_ev(s, te)

            candidates.append((name, ev, _ext_builder, best))

    # --- Family C: mid-band stem into tip ---
    for t1, t2 in MIDBAND:
        stem_h1 = apply_hp30_signed(stem_s, tau=t1)
        stem_h2 = apply_hp30_signed(stem_s, tau=t2)
        stem_h1e = apply_hp30_signed(stem_ext_s, tau=t1)
        stem_h2e = apply_hp30_signed(stem_ext_s, tau=t2)
        for a in (0.5, 0.75, 1.0, 1.25):
            name = f"C_mid_t{t1}_{t2}_a{a:.2f}"
            signed = {}
            for ds in tip_s:
                signed[ds] = {}
                for k in tip_s[ds]:
                    if k not in stem_h1[ds] or k not in stem_h2[ds]:
                        continue
                    n = min(len(tip_s[ds][k]), len(stem_h1[ds][k]), len(stem_h2[ds][k]))
                    bp = stem_h1[ds][k][:n] - stem_h2[ds][k][:n]
                    signed[ds][k] = tip_s[ds][k][:n] + a * bp
            ev, best = score_family(name, signed, tmpl, all_rows)

            def _ext_builder(
                tip_e=tip_ext_s, h1=stem_h1e, h2=stem_h2e, aa=a, te=tip_ext
            ):
                s = {}
                for ds in tip_e:
                    s[ds] = {}
                    for k in tip_e[ds]:
                        if k not in h1[ds] or k not in h2[ds]:
                            continue
                        n = min(len(tip_e[ds][k]), len(h1[ds][k]), len(h2[ds][k]))
                        bp = h1[ds][k][:n] - h2[ds][k][:n]
                        s[ds][k] = tip_e[ds][k][:n] + aa * bp
                return signed_to_ev(s, te)

            candidates.append((name, ev, _ext_builder, best))

    # Pick LODO-pass candidates (H>0.85 Acc>75), else best Acc>70, else Acc then H
    lodo_pass = [c for c in candidates if c[3]["mean_H"] > 0.85 and c[3]["mean_Acc"] > 75]
    pool = lodo_pass if lodo_pass else [
        c for c in candidates if c[3]["mean_Acc"] > 70
    ] or candidates
    pool = sorted(pool, key=lambda c: (c[3]["mean_H"], c[3]["mean_Acc"]), reverse=True)
    top = pool[:8]
    log(f"=== scoring external for top {len(top)} (lodo_pass={len(lodo_pass)}) ===")

    results = []
    best_joint = None
    for name, ev, ext_builder, best in top:
        mu, sd = emis_from(ev)
        ext_ev = ext_builder()
        ext = score_ext(ext_ev, mu, sd, best["p"], best["sc"])
        # also report @0.996/0.8 if different
        ext996 = None
        if not (best["p"] == 0.996 and best["sc"] == 0.8):
            ext996 = score_ext(ext_ev, mu, sd, 0.996, 0.8)
        gate = (
            best["mean_H"] > 0.85
            and best["mean_Acc"] > 75
            and ext["AASD"]["H"] >= 0.65
            and ext["Carta2026"]["H"] >= 0.65
        )
        row = dict(
            name=name,
            lodo=dict(H=best["mean_H"], Acc=best["mean_Acc"], p=best["p"], sc=best["sc"]),
            external=ext,
            external_996=ext996,
            pass_joint=gate,
        )
        results.append(row)
        log(
            f"  {name} LODO {best['mean_H']:.4f}/{best['mean_Acc']:.2f} "
            f"AASD {ext['AASD']['H']:.4f} Carta {ext['Carta2026']['H']:.4f} pass={gate}"
        )
        if gate and (
            best_joint is None
            or (best["mean_H"], best["mean_Acc"])
            > (best_joint["lodo"]["H"], best_joint["lodo"]["Acc"])
        ):
            best_joint = row

    # Also evaluate best Carta-preserving among Acc>75 if any
    out = dict(
        method="ac_transplant_tip_stem",
        n_candidates=len(candidates),
        n_lodo_pass=len(lodo_pass),
        top_results=results,
        best_joint=best_joint,
        elapsed_s=time.time() - t0,
    )
    with open(OUT_JSON, "w") as fh:
        json.dump(out, fh, indent=1, default=float)

    lines = [
        "# results_ac_transplant_tip_stem\n",
        "Preserve tip DC/LP; import stem AC (≠ soft-w tip↔soft_hp / capped tip+α(stem_hp−tip)).\n\n",
        f"Candidates: {len(candidates)}; LODO-pass (H>0.85 Acc>75): {len(lodo_pass)}.\n\n",
        "| Name | LODO H/Acc @p/sc | AASD H/Acc | Carta H/Acc | Pass |\n",
        "|---|---:|---:|---:|:---:|\n",
    ]
    for r in results:
        lo = r["lodo"]
        e = r["external"]
        lines.append(
            f"| `{r['name']}` | {lo['H']:.4f}/{lo['Acc']:.2f} @ {lo['p']}/{lo['sc']} | "
            f"{e['AASD']['H']:.4f}/{e['AASD']['Acc']:.2f} | "
            f"{e['Carta2026']['H']:.4f}/{e['Carta2026']['Acc']:.2f} | "
            f"{'YES' if r['pass_joint'] else 'NO'} |\n"
        )
    lines.append(
        f"\nBest joint: **{'PASS ' + best_joint['name'] if best_joint else 'NONE'}**.\n"
        f"Artifacts: `{OUT_JSON}`, `ac_transplant_tip_stem.py`.\n"
    )
    Path(RESULTS_MD).write_text("".join(lines))
    log(f"DONE joint={'PASS' if best_joint else 'FAIL'} elapsed={time.time()-t0:.0f}s")
    return 0 if best_joint else 1


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