"""Evidence |Δ|-gate: soft_hp50 tip by default, AccFuse↔hp30 tip near swings.

Intent = soft Acc + tip switch quality without post-HMM n128.
out[t] = tip if EWMA(|Δsoft|)≥thr else soft   (or soft-weighted)

≠ volgate AccFuse↔lin_hp30, ≠ MoE fuse↔hp30, ≠ agree-gate, ≠ decision-fuse.
"""
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,
    signed,
)
from accfuse_hp30_hselect import align_hp, load_accfuse
from multitau_stem_hp_accfuse import soft_hp
from stem_hp30_accfuse import (
    TIP_ALPHA,
    blend_signed,
    emis_from,
    ev_to_signed,
    load_stem_ext,
    load_stem_honest,
)
from emis_sigma_gate_tip import ewma_abs_delta

RUN_ID = "delta_gate_tip_softhp_20261109"
RUN_DIR = os.path.join(EXP, "experiments", "multi_agent_opt", "runs", RUN_ID)
OUT_JSON = os.path.join(EXP, "results", "research", "delta_gate_tip_softhp.json")
RESULTS_MD = os.path.join(EXP, "multi_agent_opt", "results_delta_gate_tip_softhp.md")
P_CANDS = [(0.994, 0.8), (0.996, 0.8), (0.998, 0.8), (0.998, 1.0)]


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 gate_ev(tip_ev, soft_ev, mode, thr, tau=4.0, soft_w=0.0):
    """Build fused evidence table from tip_ev / soft_ev signed streams."""
    out = {}
    for ds in tip_ev:
        out[ds] = {}
        for k, e in tip_ev[ds].items():
            if k not in soft_ev[ds]:
                continue
            st = signed(e)
            ss = signed(soft_ev[ds][k])
            n = min(len(st), len(ss))
            st, ss = st[:n], ss[:n]
            mag = ewma_abs_delta(ss, tau)
            if mode == "hard_switch_tip":
                s = np.where(mag >= thr, st, ss)
            elif mode == "hard_abs_tip":
                mag2 = ewma_abs_delta(st, tau)
                s = np.where(mag2 >= thr, st, ss)
            elif mode == "soft_sigmoid":
                g = 1.0 / (1.0 + np.exp(-(mag - thr)))  # 1→tip near swings
                s = g * st + (1.0 - g) * ss
            elif mode == "const_soft":
                s = ss
            elif mode == "const_tip":
                s = st
            else:
                raise ValueError(mode)
            out[ds][k] = as_sym(e, s)
    return out


def build():
    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)
    soft_ev = blend_signed(tip_s, soft_hp(load_stem_honest(), 50), 0.15, af)

    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)
    soft_ext = blend_signed(tip_ext_s, soft_hp(load_stem_ext(), 50), 0.15, tip_ext)
    return tip_ev, soft_ev, tip_ext, soft_ext


def main():
    t0 = time.time()
    os.makedirs(RUN_DIR, exist_ok=True)
    open(os.path.join(RUN_DIR, "run.log"), "w").close()
    log("=== |Δ|-gate tip↔soft_hp50 ===")

    tip_ev, soft_ev, tip_ext, soft_ext = build()
    soft_d = np.concatenate([signed(e) for ds in DS_KEYS for e in soft_ev[ds].values()])
    dlt = np.abs(np.diff(soft_d, prepend=soft_d[:1]))
    med = float(np.median(dlt))
    p75 = float(np.percentile(dlt, 75))
    p90 = float(np.percentile(dlt, 90))
    log(f"|Δsoft| med={med:.4f} p75={p75:.4f} p90={p90:.4f}")

    configs = [
        ("const_soft", med),
        ("const_tip", med),
    ]
    for thr in (med, p75, p90, med * 2, p75 * 2):
        configs.append(("hard_switch_tip", thr))
        configs.append(("soft_sigmoid", thr))
    configs.append(("hard_abs_tip", med))

    rows = []
    for mode, thr in configs:
        ev = gate_ev(tip_ev, soft_ev, mode, thr)
        best = None
        for p, sc in P_CANDS:
            per, mH, mA = score_lodo(ev, p_stay=p, scale=sc)
            cand = dict(p=p, sc=sc, H=mH, Acc=mA)
            def key(r):
                return (1 if r["Acc"] > 75 else 0, r["H"] if r["Acc"] > 75 else 0, r["Acc"], r["H"])
            if best is None or key(cand) > key(best):
                best = cand
        mu, sd = emis_from(ev)
        ext_ev = gate_ev(tip_ext, soft_ext, mode, thr)
        ext = {}
        for ds in TEST_NAMES:
            r = E.score(ext_ev[ds], mu, sd * best["sc"], best["p"], LOOKAHEAD)
            ext[ds] = {k: float(r[k]) for k in ("H", "Acc", "L", "SDT") if k in r}
        # also @996 if different
        ext996 = {}
        for ds in TEST_NAMES:
            r = E.score(ext_ev[ds], mu, sd * 0.8, 0.996, LOOKAHEAD)
            ext996[ds] = {k: float(r[k]) for k in ("H", "Acc", "L", "SDT") if k in r}
        gate = (
            best["H"] > 0.85 and best["Acc"] > 75
            and ext["AASD"]["H"] >= 0.65 and ext["Carta2026"]["H"] >= 0.65
        )
        name = f"{mode}_t{thr:.4f}"
        row = dict(name=name, mode=mode, thr=thr, lodo=best, external=ext,
                   external_996=ext996, pass_joint=gate)
        rows.append(row)
        log(
            f"  {name} LODO {best['H']:.4f}/{best['Acc']:.2f}@p{best['p']}/{best['sc']} "
            f"AASD {ext['AASD']['H']:.4f} Carta {ext['Carta2026']['H']:.4f} "
            f"L_A={ext['AASD']['L']:.3f} L_C={ext['Carta2026']['L']:.3f} pass={gate}"
        )

    champ = sorted(
        rows,
        key=lambda r: (
            r["pass_joint"],
            min(r["external"]["AASD"]["H"], r["external"]["Carta2026"]["H"]),
            r["lodo"]["H"],
        ),
        reverse=True,
    )[0]
    out = dict(method="delta_gate_tip_softhp", rows=rows, champ=champ,
               pass_joint=champ["pass_joint"], elapsed_s=time.time() - t0)
    with open(OUT_JSON, "w") as fh:
        json.dump(out, fh, indent=1, default=float)
    lines = [
        "# results_delta_gate_tip_softhp\n\n",
        "Evidence |Δ|-gate: soft_hp50 default, tip near swings. ≠ volgate AccFuse↔hp30.\n\n",
        "| Name | LODO | AASD | Carta | Pass |\n",
        "|---|---:|---:|---:|:---:|\n",
    ]
    for r in rows:
        lo, e = r["lodo"], r["external"]
        lines.append(
            f"| `{r['name']}` | {lo['H']:.4f}/{lo['Acc']:.2f} | "
            f"{e['AASD']['H']:.4f} | {e['Carta2026']['H']:.4f} | "
            f"{'YES' if r['pass_joint'] else 'NO'} |\n"
        )
    Path(RESULTS_MD).write_text("".join(lines))
    log(f"DONE pass={champ['pass_joint']} elapsed={time.time()-t0:.0f}s")
    return 0 if champ["pass_joint"] else 1


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