"""H1: Hierarchical dual-dwell integrator on linear_hp30 evidence.

NEW vs ALREADY_TRIED:
  - B1 picked ONE global Weibull/geo prior on hp30 (closed, FAIL).
  - MoE gated fuse↔hp30 streams (closed).
  - multi-τ changed HP τ (closed). Here τ=30 HP evidence is frozen.
  - This run keeps two geometric HMM branches (long + short) on the SAME
    hp30 stream and blends their soft posteriors with a causal, label-free
    volatility gate (past-only EWMA of |Δd|). Selection on LODO Acc then H only.

Priority B gate: LODO H>0.80 Acc>70; Carta H>0.60 Acc>60; AASD H>0.60
(AASD Acc soft / not hard-required).

usage:
  .../python -u hier_dwell_hp30.py
"""
from __future__ import annotations

import json
import os
import time

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 e1_switch import hmm_filter

RUN_ID = "hier_dwell_hp30_20261107"
RUN_DIR = os.path.join(EXP, "experiments", "multi_agent_opt", "runs", RUN_ID)
LOG = os.path.join(RUN_DIR, "run.log")
OUT_JSON = os.path.join(EXP, "results", "research", "hier_dwell_hp30.json")
OUT_MD = os.path.join(EXP, "multi_agent_opt", "results_hier_dwell_hp30.md")

SCALE = 0.8
LOOKAHEAD = 0.75
HOP = 0.25
TEST_NAMES = ("AASD", "Carta2026")

# Compact grid (screened: p_long=0.998 lifts Acc vs 0.994; short 0.9 beats 0.95).
# No AASD/Carta labels.
P_LONG = (0.998,)
P_SHORT = (0.90, 0.95)
TAU_VOL_S = (5.0,)
BETA = (5.0, 10.0)
V0_MODES = ("median_train", "causal_runmed")


def log(msg: str) -> None:
    print(f"{time.strftime('%F %T')} {msg}", flush=True)
    os.makedirs(RUN_DIR, exist_ok=True)
    with open(LOG, "a") as fh:
        fh.write(msg + "\n")


def sigmoid(x):
    x = np.clip(x, -60.0, 60.0)
    return 1.0 / (1.0 + np.exp(-x))


def causal_volatility(d, tau_s):
    """Past-only EWMA of |Δd|. v[t] uses samples < t only (Δ at t-1)."""
    d = np.asarray(d, np.float64)
    n = len(d)
    v = np.zeros(n, np.float64)
    if n == 0:
        return v
    alpha = 1.0 - np.exp(-HOP / float(tau_s))
    ema = 0.0
    for t in range(n):
        v[t] = ema  # past-only: Δ at t is applied after emitting v[t]
        if t > 0:
            ema = ema + alpha * (abs(d[t] - d[t - 1]) - ema)
    return v


def train_median_vol(ev, tau_s):
    """Label-free median of causal volatility on corpus hp30 folds."""
    parts = []
    for ds in DS_KEYS:
        for e in ev[ds].values():
            d = (e["r0"] - e["r1"]).astype(np.float64)
            vv = causal_volatility(d, tau_s)
            if len(vv) > 8:
                parts.append(vv[8:])  # skip cold start
    if not parts:
        return 0.0
    return float(np.median(np.concatenate(parts)))


def causal_running_median(v, win=40):
    """Causal running median of v (past window including present)."""
    out = np.empty_like(v)
    for t in range(len(v)):
        lo = max(0, t - win + 1)
        out[t] = np.median(v[lo : t + 1])
    return out


def make_hier_integ(p_long, p_short, tau_vol, beta, v0_mode, v0_fixed):
    def integ(d, p):
        mu, sd = float(p["mu"]), float(p["sd"])
        d = np.asarray(d, np.float64)
        ll0 = -0.5 * ((d - mu) / sd) ** 2
        ll1 = -0.5 * ((d + mu) / sd) ** 2
        post_l = hmm_filter(ll0, ll1, float(p_long))
        post_s = hmm_filter(ll0, ll1, float(p_short))
        vol = causal_volatility(d, tau_vol)
        if v0_mode == "median_train":
            v0 = float(v0_fixed)
        else:
            v0 = causal_running_median(vol)
        w_s = sigmoid(float(beta) * (vol - v0))
        soft = (1.0 - w_s) * post_l + w_s * post_s
        return (soft > 0.5).astype(int)

    return integ


def make_geo_integ(p_stay):
    def integ(d, p):
        from e1_switch import integ_hmm as geo

        return geo(d, dict(p_stay=float(p_stay), mu=p["mu"], sd=p["sd"]))

    return integ


def install(integ):
    S.integ_hmm = integ
    E.integ_hmm = integ


def restore():
    from e1_switch import integ_hmm as geo

    S.integ_hmm = geo
    E.integ_hmm = geo


def score_lodo(ev, label):
    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, LOOKAHEAD, emis=(mu, sd * SCALE), p_stay=0.994)
        per[ds] = {k: float(r[k]) for k in ("H", "Acc", "L", "SDT")}
    mean = {k: float(np.mean([per[d][k] for d in DS_KEYS])) for k in ("H", "Acc", "L", "SDT")}
    log(f"  {label} LODO MEAN H={mean['H']:.4f} Acc={mean['Acc']:.2f}")
    return per, mean


def lodo_emis(ev):
    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[ds].values()
        ]
    )
    return float(A.mean()), float(A.std())


def load_linear_hp30():
    _mean_ev, hp_ev, la = V4._mean_and_hp_from_folds()
    log(f"linear_hp30 folds loaded la={la}")
    return hp_ev


def load_ext_linear_hp30():
    train_logits, train_att = 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")
    ext = {}
    for ds in TEST_NAMES:
        EV = {}
        for k, d in streams[ds].items():
            meta = test_meta[ds][k]
            EV[k] = dict(
                r0=np.asarray(d, np.float64),
                r1=np.zeros_like(d, np.float64),
                att=np.asarray(meta["att"]),
                t_end=np.asarray(meta["t_end"], np.float64),
                att128=meta["att128"],
                n128=meta["n128"],
                subject=meta["subject"],
            )
        ext[ds] = EV
    return ext


def priority_b_ok(mean, ext):
    return (
        mean["H"] > 0.80
        and mean["Acc"] > 70.0
        and ext["Carta2026"]["H"] > 0.60
        and ext["Carta2026"]["Acc"] > 60.0
        and ext["AASD"]["H"] > 0.60
    )


def scrub(o):
    if isinstance(o, dict):
        return {k: scrub(v) for k, v in o.items()}
    if isinstance(o, (list, tuple)):
        return [scrub(v) for v in o]
    if isinstance(o, (np.floating, np.integer)):
        return float(o)
    return o


def main():
    t0 = time.time()
    os.makedirs(RUN_DIR, exist_ok=True)
    open(LOG, "w").close()
    log("H1 hier_dwell_hp30 start")

    hp_ev = load_linear_hp30()
    rows = []

    # Baseline: pure geo 0.994 (published linear_hp30 integrator)
    install(make_geo_integ(0.994))
    per, mean = score_lodo(hp_ev, "baseline_geo_p0.994")
    rows.append(
        dict(
            tag="baseline_geo_p0.994",
            kind="geo",
            cfg=dict(p_stay=0.994),
            mean=mean,
            per=per,
        )
    )

    v0_cache = {tau: train_median_vol(hp_ev, tau) for tau in TAU_VOL_S}
    log(f"label-free median_train v0 by tau: { {k: round(v, 6) for k, v in v0_cache.items()} }")

    for p_l in P_LONG:
        for p_s in P_SHORT:
            for tau in TAU_VOL_S:
                for beta in BETA:
                    for v0_mode in V0_MODES:
                        v0_fixed = v0_cache[tau]
                        tag = f"L{p_l:g}_S{p_s:g}_t{tau:g}_b{beta:g}_{v0_mode}"
                        install(
                            make_hier_integ(p_l, p_s, tau, beta, v0_mode, v0_fixed)
                        )
                        per, mean = score_lodo(hp_ev, tag)
                        rows.append(
                            dict(
                                tag=tag,
                                kind="hier",
                                cfg=dict(
                                    p_long=p_l,
                                    p_short=p_s,
                                    tau_vol=tau,
                                    beta=beta,
                                    v0_mode=v0_mode,
                                    v0_fixed=v0_fixed,
                                ),
                                mean=mean,
                                per=per,
                            )
                        )
    restore()

    rows.sort(key=lambda r: (r["mean"]["Acc"], r["mean"]["H"]), reverse=True)
    best = rows[0]
    log(
        f"SELECTED → {best['tag']} LODO H={best['mean']['H']:.4f} Acc={best['mean']['Acc']:.2f}"
    )

    # Install selected integrator for external
    if best["kind"] == "geo":
        install(make_geo_integ(best["cfg"]["p_stay"]))
    else:
        c = best["cfg"]
        install(
            make_hier_integ(
                c["p_long"],
                c["p_short"],
                c["tau_vol"],
                c["beta"],
                c["v0_mode"],
                c["v0_fixed"],
            )
        )

    ext_ev = load_ext_linear_hp30()
    mu_l, sd_l = lodo_emis(hp_ev)
    ext_scores = {}
    for ds in TEST_NAMES:
        # p_stay arg unused by hier integ; keep 0.994 for geo baseline path
        r = E.score(ext_ev[ds], mu_l, sd_l * SCALE, 0.994, LOOKAHEAD)
        ext_scores[ds] = {k: float(r[k]) for k in ("H", "Acc", "L", "SDT")}
        log(
            f"  EXT {best['tag']} {ds} H={ext_scores[ds]['H']:.4f} Acc={ext_scores[ds]['Acc']:.2f}"
        )
    restore()

    ok = priority_b_ok(best["mean"], ext_scores)
    payload = dict(
        method="hier_dwell_hp30",
        run_id=RUN_ID,
        selected=best["tag"],
        cfg=best["cfg"],
        lodo={"mean": best["mean"], "per": best["per"]},
        grid_top8=[
            dict(tag=r["tag"], H=r["mean"]["H"], Acc=r["mean"]["Acc"]) for r in rows[:8]
        ],
        ext=ext_scores,
        priority_b=dict(
            lodo_H_gt_0p80=best["mean"]["H"] > 0.80,
            lodo_Acc_gt_70=best["mean"]["Acc"] > 70.0,
            carta_H_gt_0p60=ext_scores["Carta2026"]["H"] > 0.60,
            carta_Acc_gt_60=ext_scores["Carta2026"]["Acc"] > 60.0,
            aasd_H_gt_0p60=ext_scores["AASD"]["H"] > 0.60,
            aasd_Acc_soft=True,
        ),
        verdict="PASS" if ok else "FAIL",
        elapsed_s=time.time() - t0,
        inherited="linear_hp30 τ=30 evidence; dual geo dwell + causal volatility gate",
        baseline_ref="linear_hp30 LODO 0.7899/69.21; AASD 0.6422/53.12; Carta 0.6520/60.54",
    )
    with open(OUT_JSON, "w") as fh:
        json.dump(scrub(payload), fh, indent=2)

    lines = [
        "# results_hier_dwell_hp30",
        "",
        f"Selected: **{best['tag']}**",
        "",
        f"| Stream | LODO H | LODO Acc | AASD H/Acc | Carta H/Acc |",
        f"|---|---:|---:|---|---|",
        (
            f"| hier_dwell_hp30 | {best['mean']['H']:.4f} | {best['mean']['Acc']:.2f} | "
            f"{ext_scores['AASD']['H']:.4f}/{ext_scores['AASD']['Acc']:.2f} | "
            f"{ext_scores['Carta2026']['H']:.4f}/{ext_scores['Carta2026']['Acc']:.2f} |"
        ),
        "",
        "Priority B: LODO H>0.80 Acc>70; Carta H>0.60 Acc>60; AASD H>0.60 (Acc soft).",
        f"Verdict: **{payload['verdict']}**.",
        f"Artifacts: `{OUT_JSON}` (CPU-only; no bulky ckpts).",
    ]
    with open(OUT_MD, "w") as fh:
        fh.write("\n".join(lines) + "\n")
    log(f"VERDICT {payload['verdict']} elapsed={payload['elapsed_s']:.0f}s")
    return 0 if ok else 1


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