"""Fractional high-pass and a small causal slope kick on the four classifier logits.

Full 60 s high-pass raised H above 0.8 and dropped Acc below 73. This grid keeps a fraction of
that high-pass, plus a small 1 s slope added to the LDA logit, and plain LDA. Hyperparameters
are chosen per held-out dataset from the other four only.

Selection uses only that fold's four inner datasets (no shared lambda, so a held-out
dataset's labels never enter its own hyperparameter choice):
  joint  primary. Among specs with inner Acc >= 73, maximise inner H. If none qualify,
         take the highest inner Acc, then H.
  maxH   maximise inner H, ignoring Acc.

The held-out dataset is scored once per rule with score.score_dataset.
usage: python ensemble_clf_hpfrac.py
"""
import os

import numpy as np
import pandas as pd
from joblib import Parallel, delayed

import ensemble_clf_nested as N
from common import DS_KEYS

OUT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "results", "research", "ensemble_clf_hpfrac.csv")
INNER = os.path.join(os.path.dirname(os.path.abspath(__file__)), "results", "research", "ensemble_clf_hpfrac_inner.csv")

# (name, tau_s, beta). beta=0 is the identity. tau is unused then.
VARIANTS = (
    ("id", 0.0, 0.0),
    ("hp60b025", 60.0, 0.25),
    ("hp60b050", 60.0, 0.50),
    ("hp120b050", 120.0, 0.50),
    ("hp120b100", 120.0, 1.00),
    ("hp240b050", 240.0, 0.50),
    ("hp240b100", 240.0, 1.00),
)
KICKS = (0.0, 0.05, 0.10, 0.20)   # only applied on top of id; other variants use kick 0
P_STAY = (0.996, 0.998, 0.999)
SCALES = (0.9, 1.0, 1.15)


def add_variant(name, tau, beta):
    src = N.G["base"]["id"]
    N.G["base"][name] = {ds: {} for ds in DS_KEYS}
    if beta == 0.0:
        for ds in DS_KEYS:
            N.G["base"][name][ds] = src[ds]
    else:
        alpha = 1.0 - np.exp(-0.25 / tau)
        for ds in DS_KEYS:
            for key, D in src[ds].items():
                N.G["base"][name][ds][key] = D - beta * N.ema_2d(D, alpha)
    N.G["stats"].setdefault(name, {})
    N.G["stats"][name]["lda4"] = {ds: N.dataset_stats(ds, name, "lda4") for ds in DS_KEYS}
    print(f"variant {name}", flush=True)


def kick_map(dmap, a):
    if a == 0.0:
        return dmap
    out = {}
    for key, s in dmap.items():
        slope = np.zeros_like(s)
        if len(s) > 4:
            slope[4:] = s[4:] - s[:-4]
        out[key] = (1.0 - a) * s + a * slope
    return out


def block(outer, inner, name, kick):
    train = [d for d in DS_KEYS if d not in (outer, inner)]
    w = N.w_from_stats([N.G["stats"][name]["lda4"][d] for d in train], 0.0)
    streams = N.apply_streams(name, "lda4", w, train + [inner])
    streams = {d: kick_map(streams[d], kick) for d in streams}
    mu, sd = N.emis(streams, train)
    rows = []
    for p in P_STAY:
        for scale in SCALES:
            r = N.evaluate(inner, streams[inner], mu, sd * scale, p)
            rows.append(dict(outer=outer, inner=inner, variant=name, kick=kick, p_stay=p, scale=scale, **r))
    print(f"inner {outer}<-{inner} {name} k{kick} H {np.mean([x['H'] for x in rows]):.4f}", flush=True)
    return rows


def _init(base, att, prep, stats, lookahead):
    N.G["base"] = base
    N.G["att"] = att
    N.G["prep"] = prep
    N.G["stats"] = stats
    N.G["lookahead"] = lookahead


def select_joint(m):
    """Per held-out fold, independent of the other folds' inner scores."""
    picks = []
    n_ok = 0
    for _, g in m.groupby("outer"):
        ok = g[g.Acc >= 73.0]
        if len(ok):
            n_ok += 1
            picks.append(ok.sort_values(["H", "Acc", "SDT"], ascending=[False, False, True]).iloc[0])
        else:
            picks.append(g.sort_values(["Acc", "H", "SDT"], ascending=[False, False, True]).iloc[0])
    return pd.DataFrame(picks), n_ok


def select_maxh(m):
    picks = []
    for o, g in m.groupby("outer"):
        picks.append(g.sort_values(["H", "Acc", "SDT"], ascending=[False, False, True]).iloc[0])
    return pd.DataFrame(picks)


def score_picks(picks, role):
    rows = []
    for _, b in picks.iterrows():
        streams_w = N.w_from_stats([N.G["stats"][b.variant]["lda4"][d] for d in DS_KEYS if d != b.outer], 0.0)
        raw = N.apply_streams(b.variant, "lda4", streams_w, DS_KEYS)
        streams = {d: kick_map(raw[d], float(b.kick)) for d in DS_KEYS}
        # official path needs an evidence dict; kick is already in the scalar
        ev = N.to_ev(streams)
        off = N.official(b.outer, ev, float(b.p_stay), float(b.scale))
        rows.append(dict(role=role, ds=b.outer, variant=b.variant, kick=float(b.kick), p_stay=float(b.p_stay),
                         scale=float(b.scale), H=off["H"], Acc=off["Acc"], SDT=off["SDT"], L=off["L"],
                         acc1=off["acc1"], inner_H=float(b.H), inner_Acc=float(b.Acc), scorer="official"))
        print(f"{role} {b.outer} {b.variant} k{b.kick} p {b.p_stay} sc {b.scale}  "
              f"H {off['H']:.4f} Acc {off['Acc']:.2f} SDT {off['SDT']:.2f} L {off['L']:.3f}", flush=True)
    return rows


def main():
    N.load_all()
    for name, tau, beta in VARIANTS:
        if name == "id":
            continue
        add_variant(name, tau, beta)
    # id stats already computed by load_all
    tasks = []
    for outer in DS_KEYS:
        for inner in DS_KEYS:
            if inner == outer:
                continue
            for name, tau, beta in VARIANTS:
                kicks = KICKS if name == "id" else (0.0,)
                for k in kicks:
                    tasks.append((outer, inner, name, k))
    n_jobs = int(os.environ.get("SCORE_JOBS", "6"))
    parts = Parallel(n_jobs=n_jobs, initializer=_init,
                     initargs=(N.G["base"], N.G["att"], N.G["prep"], N.G["stats"], N.G["lookahead"]))(
        delayed(block)(*t) for t in tasks)
    inner = pd.DataFrame([r for part in parts for r in part])
    os.makedirs(os.path.dirname(INNER), exist_ok=True)
    inner.to_csv(INNER, index=False)
    m = inner.groupby(["outer", "variant", "kick", "p_stay", "scale"])[["H", "Acc", "SDT", "L", "acc1"]].mean().reset_index()
    joint, n_ok = select_joint(m)
    print(f"joint folds with inner Acc>=73: {n_ok}/5  inner H {joint.H.mean():.4f} Acc {joint.Acc.mean():.2f}", flush=True)
    maxh = select_maxh(m)
    print(f"maxH inner H {maxh.H.mean():.4f} Acc {maxh.Acc.mean():.2f}", flush=True)
    rows = score_picks(joint, "joint") + score_picks(maxh, "maxH")
    df = pd.DataFrame(rows)
    df.to_csv(OUT, index=False)
    for role, sub in df.groupby("role"):
        print(f"{role} TEST H {sub.H.mean():.4f} Acc {sub.Acc.mean():.2f} SDT {sub.SDT.mean():.2f} "
              f"L {sub.L.mean():.3f} acc1 {sub.acc1.mean():.3f}")
    j = df[df.role == "joint"]
    print(f"goal H>0.8 and Acc>73: {bool(j.H.mean() > 0.8 and j.Acc.mean() > 73)}")
    print(f"wrote {OUT}")


if __name__ == "__main__":
    main()
