"""B1 Weibull semi-Markov decision layer on linear_hp30 (and BMMS-hp30) evidence.

NEW vs ALREADY_TRIED:
  - B1 was run on SW2 4dec+4clf fuse (semimarkov.csv); NOT on causal τ=30 HP
    of the 4-seed classifier mean (linear_hp30) or BMMS3 mean4+hp30.
  - msm.py mode-switching Markov is a different family (closed).
  - Selection: mean LODO Acc then H @ emission scale 0.8 — never AASD/Carta labels.
  - Inherits linear_hp30 shift-robust evidence; only the dwell prior changes.

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

import json
import os
import pickle
import time

import numpy as np

import ensemble_clf as EC
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 DATA_EXP, EXP

# Import B1 primitives from the decoder_lodo tree (authoritative).
import sys
sys.path.insert(0, os.path.join(DATA_EXP))
from hmm_semimarkov import MEANS, SHAPES, dwell_prior, sm_filter  # noqa: E402

RUN_ID = "b1_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", "b1_hp30_semimarkov.json")
OUT_MD = os.path.join(EXP, "multi_agent_opt", "results_b1_hp30_semimarkov.md")

SCALE = 0.8
LOOKAHEAD = 0.75
TEST_NAMES = ("AASD", "Carta2026")
# Compact grid: short-dwell (AASD-like) + geometric refs. Full B1 grid was on SW2 fuse.
GRID = (
    [("geo", p) for p in (0.994, 0.99, 0.95)]
    + [("sm", (m, k)) for m in (5.0, 10.0, 20.0, 40.0) for k in (0.6, 1.0, 1.5)]
)


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 make_integ(kind, par):
    if kind == "geo":
        p_stay = float(par)

        def integ(d, p):
            from e1_switch import integ_hmm as geo
            return geo(d, dict(p_stay=p_stay, mu=p["mu"], sd=p["sd"]))

        return integ
    h, pi = dwell_prior(float(par[0]), float(par[1]))

    def integ(d, p):
        mu, sd = p["mu"], p["sd"]
        ll0 = -0.5 * ((d - mu) / sd) ** 2
        ll1 = -0.5 * ((d + mu) / sd) ** 2
        return (sm_filter(ll0.astype(np.float64), ll1.astype(np.float64), h, pi) > 0.5).astype(int)

    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_bmms_hp30():
    exps = [f"direct_clf__eaP_n5_t60_w10_bmms3enh_ptSPK_s{s}" for s in range(4)]

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

    raw = {}
    for ds in DS_KEYS:
        evs = []
        for exp in exps:
            with open(fold_path(exp, ds), "rb") as fh:
                evs.append(pickle.load(fh)["evidence"]["causal"])
        out = {}
        for k in evs[0]:
            r0 = np.mean([e[k]["r0"] for e in evs], 0)
            r1 = np.mean([e[k]["r1"] for e in evs], 0)
            d = dict(evs[0][k])
            d["r0"], d["r1"] = r0.astype(np.float32), r1.astype(np.float32)
            d["pre_switched"] = True
            out[k] = d
        raw[ds] = out
    # apply hp30
    hp = {}
    for ds, table in raw.items():
        hp[ds] = {}
        for k, e in table.items():
            s = (e["r0"] - e["r1"]).astype(np.float64)
            h = V4.highpass(s[:, None], tau=30.0, hop=0.25)[:, 0]
            ne = dict(e)
            ne["r0"] = (h / 2).astype(np.float32)
            ne["r1"] = (-h / 2).astype(np.float32)
            hp[ds][k] = ne
    log("BMMS3 mean4 + hp30 LODO built")
    return hp


def load_ext_linear_hp30():
    """Rebuild external linear_hp30 streams via V4 (same as published)."""
    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")
    # Convert to evidence dicts for E.score
    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
    # emissions from train corpus hp30
    parts = []
    for ds in V4.CORPUS:
        for k, d in streams[ds].items():
            att = train_att[ds][k]
            n = min(len(d), len(att))
            parts.append(np.asarray(d)[:n] * np.where(np.asarray(att)[:n] == 0, 1.0, -1.0))
    A = np.concatenate(parts)
    return ext, float(A.mean()), float(A.std())


def load_ext_bmms_hp30(mu_lodo, sd_lodo):
    """Mean4 BMMS external evidence + hp30."""
    ext = {}
    for ds in TEST_NAMES:
        evs = []
        for s in range(4):
            name = f"ext_clf_{ds}_w10bmms3enhP_evidence_s{s}.pkl"
            for root in (os.path.join(EXP, "results", "research"),
                         os.path.join(DATA_EXP, "results", "research")):
                p = os.path.join(root, name)
                if os.path.exists(p):
                    with open(p, "rb") as fh:
                        evs.append(pickle.load(fh))
                    break
            else:
                raise FileNotFoundError(name)
        out = {}
        for k in evs[0]:
            r0 = np.mean([e[k]["r0"] for e in evs], 0)
            r1 = np.mean([e[k]["r1"] for e in evs], 0)
            s = (r0 - r1).astype(np.float64)
            h = V4.highpass(s[:, None], tau=30.0, hop=0.25)[:, 0]
            d = dict(evs[0][k])
            d["r0"] = (h / 2).astype(np.float32)
            d["r1"] = (-h / 2).astype(np.float32)
            out[k] = d
        ext[ds] = out
    return ext, mu_lodo, sd_lodo


def select_and_score(name, lodo_ev, ext_loader):
    log(f"=== stream {name}: LODO grid ===")
    rows = []
    for kind, par in GRID:
        install(make_integ(kind, par))
        tag = f"geo p{par}" if kind == "geo" else f"m{par[0]:g} k{par[1]:g}"
        per, mean = score_lodo(lodo_ev, tag)
        rows.append(dict(tag=tag, kind=kind, par=par, mean=mean, per=per))
    restore()
    # select Acc then H
    rows.sort(key=lambda r: (r["mean"]["Acc"], r["mean"]["H"]), reverse=True)
    best = rows[0]
    log(f"SELECTED {name} → {best['tag']} LODO H={best['mean']['H']:.4f} Acc={best['mean']['Acc']:.2f}")

    install(make_integ(best["kind"], best["par"]))
    ext_ev, mu, sd = ext_loader()
    # Prefer LODO emissions from the selected stream
    mu_l, sd_l = lodo_emis(lodo_ev)
    ext_scores = {}
    for ds in TEST_NAMES:
        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 {name}/{best['tag']} {ds} H={ext_scores[ds]['H']:.4f} Acc={ext_scores[ds]['Acc']:.2f}")
    restore()
    return dict(selected=best["tag"], lodo=best, grid_top5=[
        dict(tag=r["tag"], H=r["mean"]["H"], Acc=r["mean"]["Acc"]) for r in rows[:5]
    ], ext=ext_scores)


def main():
    t0 = time.time()
    open(LOG, "w").close() if False else os.makedirs(RUN_DIR, exist_ok=True)
    log("B1 semi-Markov on hp30 streams start")

    results = {}
    # Stream 1: linear_hp30
    hp_ev = load_linear_hp30()
    results["linear_hp30"] = select_and_score("linear_hp30", hp_ev, load_ext_linear_hp30)

    # Stream 2: BMMS mean4 hp30
    try:
        bmms = load_bmms_hp30()
        mu_b, sd_b = lodo_emis(bmms)

        def _bmms_ext():
            return load_ext_bmms_hp30(mu_b, sd_b)

        results["bmms_hp30"] = select_and_score("bmms_hp30", bmms, _bmms_ext)
    except FileNotFoundError as e:
        log(f"BMMS skip: {e}")

    # Pick primary: best LODO Acc then H among streams
    primary_name = max(
        results.keys(),
        key=lambda n: (results[n]["lodo"]["mean"]["Acc"], results[n]["lodo"]["mean"]["H"]),
    )
    primary = results[primary_name]
    mean = primary["lodo"]["mean"]
    ext = primary["ext"]
    ok = (
        mean["H"] > 0.80 and mean["Acc"] > 70.0
        and all(ext[ds]["H"] > 0.60 and ext[ds]["Acc"] > 60.0 for ds in TEST_NAMES)
    )
    payload = dict(
        method="b1_hp30_semimarkov",
        run_id=RUN_ID,
        primary=primary_name,
        results=results,
        verdict="PASS" if ok else "FAIL",
        elapsed_s=time.time() - t0,
        inherited="linear_hp30 / BMMS+hp30 evidence; B1 Weibull dwell replaces geometric p_stay",
    )
    # JSON-safe: strip non-serializable par tuples inside nested
    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

    with open(OUT_JSON, "w") as fh:
        json.dump(scrub(payload), fh, indent=2)

    lines = [
        "# results_b1_hp30_semimarkov",
        "",
        f"Primary: **{primary_name}** / {primary['selected']}",
        "",
        "| Stream | Sel | LODO H | LODO Acc | AASD H/Acc | Carta H/Acc |",
        "|---|---|---:|---:|---|---|",
    ]
    for n, r in results.items():
        lines.append(
            f"| {n} | {r['selected']} | {r['lodo']['mean']['H']:.4f} | {r['lodo']['mean']['Acc']:.2f} | "
            f"{r['ext']['AASD']['H']:.4f}/{r['ext']['AASD']['Acc']:.2f} | "
            f"{r['ext']['Carta2026']['H']:.4f}/{r['ext']['Carta2026']['Acc']:.2f} |"
        )
    lines += [
        "",
        f"Verdict: **{payload['verdict']}** (targets LODO H>0.80 Acc>70; both tests H>0.60 Acc>60).",
        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())
