"""Analysis of the ensemble experiment: seed ensembles, full-data training, and the blend with the tree committee.

Everything is computed offline from the saved class probabilities (preds/) and the saved committee_stack predictions.
CV = 5 participant-grouped folds, macro = mean(seen, unseen). Public = 500 train -> 40 test, members seeded 42, 43, ... (42 is
the organizers' seed). The ensemble of N members averages their predicted distributions and decodes the median.
"""
import os
import sys
import time

import numpy as np
import pandas as pd

HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(os.path.dirname(HERE))
sys.path.insert(0, os.path.join(ROOT, "experiments/stft_tree"))
sys.path.insert(0, HERE)
import run_stft_tree as R  # noqa: E402
from ens_utils import median_decode  # noqa: E402

PRED = os.path.join(HERE, "preds")
X0, names, win, rec = R.extract()
y = win.y.to_numpy(); wrec = win.rec.to_numpy()
win_idx = win.groupby("rec").indices
rows = lambda rs: np.concatenate([win_idx[r] for r in rs])
folds = R.make_folds(rec, 5, seed=0)
groups_cv = [{"seen": fd["seen"], "unseen": fd["unseen"]} for fd in folds]
pub_recs = list(rec.index[rec.split == "test"])
cache = {}


def probs(variant, tag, fold, seed, g):
    key = (variant, tag, fold, seed, g)
    if key not in cache:
        cache[key] = np.load(os.path.join(PRED, f"{variant}_{tag}_f{fold}_s{seed}_{g}.npy")).astype(np.float32)
    return cache[key]


def have(variant, tag, seeds):
    for s in seeds:
        for k, gs in enumerate(groups_cv if tag == "cv" else [{"test40": 0}]):
            for g in gs:
                if not os.path.exists(os.path.join(PRED, f"{variant}_{tag}_f{k if tag == 'cv' else 0}_s{s}_{g}.npy")):
                    return False
    return True


def cv_seeds(variant):
    s = 0
    while have(variant, "cv", [s]):
        s += 1
    return list(range(s))


def pub_seeds(variant):
    s = 42
    while have(variant, "public", [s]):
        s += 1
    return list(range(42, s))


def evaluate_cv(pred_fn):
    per, fm, seen, unseen, ys, ps = {}, [], [], [], [], []
    for k, gs in enumerate(groups_cv):
        m = {}
        for g, grecs in gs.items():
            ite = rows(grecs)
            p = np.clip(pred_fn(k, g), 0, 600)
            pr, _ = R.score(y[ite], p, wrec[ite])
            for r, v in pr.items():
                per[(k, g, r)] = v
            m[g] = float(np.mean(list(pr.values()))); ys.append(y[ite]); ps.append(p)
        fm.append(np.mean(list(m.values()))); seen.append(m["seen"]); unseen.append(m["unseen"])
    return dict(macro=np.array(fm), seen=float(np.mean(seen)), unseen=float(np.mean(unseen)), per=per,
                y=np.concatenate(ys), p=np.concatenate(ps))


def evaluate_pub(pred):
    ite = rows(pub_recs)
    p = np.clip(pred, 0, 600)
    pr, _ = R.score(y[ite], p, wrec[ite])
    return dict(score=float(np.mean(list(pr.values()))), per=pr, y=y[ite], p=p)


def bins_mae(yv, p):
    b = np.digitize(yv, [40, 90, 300])
    return [float(np.abs(p - yv)[b == k].mean()) for k in range(4)]


def single_pred(variant, seed, tag="cv"):
    return lambda k, g: median_decode(probs(variant, tag, k, seed, g))


def ens_pred(variant, seeds, mode="prob", tag="cv"):
    def f(k, g):
        arrs = [probs(variant, tag, k, s, g) for s in seeds]
        return median_decode(np.mean(arrs, 0)) if mode == "prob" else np.mean([median_decode(a) for a in arrs], 0)
    return f


def paired(a, b):
    d = np.array([a["per"][k] - b["per"][k] for k in a["per"]])
    return d.mean(), d.std() / np.sqrt(len(d)), 100 * (d < 0).mean(), len(d)


L = ["# Ensemble nhiều seed, train toàn bộ dữ liệu, ghép với committee cây: kết quả", "",
     f"Tạo lúc {time.strftime('%Y-%m-%d %H:%M')}. W-bMAE bằng giây, thấp hơn là tốt hơn. Model: `cnn_feat_gru` với đầu vào low-pass 45 Hz và "
     "head phân phối `dist_w` (121 lớp, loss có trọng số metric, giải mã trung vị). Ensemble N model = trung bình các phân phối dự đoán rồi "
     "lấy trung vị. CV = 5 fold theo người (macro = trung bình seen và unseen). Test công khai = train 500 bản ghi, chấm 40 bản ghi; "
     "các thành viên dùng seed 42, 43, ... (42 là seed của ban tổ chức, là gốc của ensemble công khai). Sai số chuẩn của một con số test "
     "công khai khoảng 4 s.", "",
     "Ba công thức huấn luyện: **val25** = 85% số người, lịch 25 epoch, giữ epoch tốt nhất trên 15% người còn lại (cách của các lần chạy trước); "
     "**tr85_ep12** = cùng 85% người, lịch 12 epoch, lấy epoch cuối; **full_ep12 / full_ep18** = toàn bộ bản ghi train của lần chia, "
     "lịch 12 hoặc 18 epoch, lấy epoch cuối, không có tập kiểm tra.", ""]
variants = [v for v in ("val25", "tr85_ep12", "full_ep12", "full_ep18") if cv_seeds(v)]
res = {}
for v in variants:
    cs, ps_ = cv_seeds(v), pub_seeds(v)
    res[v] = dict(cs=cs, ps=ps_, single=[evaluate_cv(single_pred(v, s)) for s in cs],
                  psingle=[evaluate_pub(median_decode(probs(v, "public", 0, s, "test40"))) for s in ps_])

# ---------------------------------------------------------------- T1 singles
L += ["## 1. Một model đơn (trung bình qua các seed)", "",
      "| Công thức | Số seed (CV / test) | Seen | Unseen | **CV macro** | SD giữa seed | Test công khai: từng seed | **Seed 42** |", "|---|---|---|---|---|---|---|---|"]
for v in variants:
    r = res[v]; sm = np.array([s["macro"].mean() for s in r["single"]])
    pub = [p["score"] for p in r["psingle"]]
    L.append(f"| {v} | {len(r['cs'])} / {len(r['ps'])} | {np.mean([s['seen'] for s in r['single']]):.1f} | "
             f"{np.mean([s['unseen'] for s in r['single']]):.1f} | **{sm.mean():.2f}** | {sm.std():.2f} | "
             f"{' / '.join(f'{x:.1f}' for x in pub)} | **{pub[0]:.1f}** |" if pub else f"| {v} | | | | | | | |")

# ---------------------------------------------------------------- T2 ensemble curve (val25) and T3 recipes
def ens_row(v, n, mode="prob"):
    r = res[v]
    if len(r["cs"]) < n or len(r["ps"]) < n:
        return None
    cv = evaluate_cv(ens_pred(v, r["cs"][:n], mode))
    pb = evaluate_pub(ens_pred(v, r["ps"][:n], mode, "public")(0, "test40"))
    return cv, pb


L += ["", "## 2. Ensemble nhiều seed: đường cong theo số model N", "",
      "| Công thức | N | **CV macro** | Seen | Unseen | Test công khai (seed 42 + các seed kế tiếp) |", "|---|---|---|---|---|---|"]
curves = {}
for v in variants:
    base = np.mean([s["macro"].mean() for s in res[v]["single"]])
    L.append(f"| {v} | 1 (trung bình các model đơn) | {base:.2f} | {np.mean([s['seen'] for s in res[v]['single']]):.1f} | "
             f"{np.mean([s['unseen'] for s in res[v]['single']]):.1f} | {np.mean([p['score'] for p in res[v]['psingle']]):.1f} (seed 42: {res[v]['psingle'][0]['score']:.1f}) |")
    for n in (2, 3, 5, 8):
        out = ens_row(v, n)
        if out is None:
            continue
        cv, pb = out; curves[(v, n)] = (cv, pb)
        L.append(f"| {v} | {n} | **{cv['macro'].mean():.2f}** | {cv['seen']:.1f} | {cv['unseen']:.1f} | **{pb['score']:.1f}** |")

# ---------------------------------------------------------------- T3 paired statistics
L += ["", "## 3. So cặp trên từng bản ghi (CV; âm = vế đầu tốt hơn), ± SE", ""]
for v in variants:
    n = min(5, len(res[v]["cs"]))
    if (v, n) in curves:
        ens = curves[(v, n)][0]
        # per-recording mean of the single models, same seeds
        keys = ens["per"].keys()
        mean_single = {k: np.mean([s["per"][k] for s in res[v]["single"][:n]]) for k in keys}
        d = np.array([ens["per"][k] - mean_single[k] for k in keys])
        L.append(f"- ensemble {n} model {v} − trung bình {n} model đơn cùng công thức: {d.mean():+.2f} ± {d.std() / np.sqrt(len(d)):.2f} s "
                 f"(tốt hơn ở {100 * (d < 0).mean():.0f}% bản ghi-nhóm, n = {len(d)})")
ref_v = "val25" if (("val25", 5) in curves) else None
for v in variants:
    if v != ref_v and ref_v and (v, 5) in curves:
        m, se, pct, n = paired(curves[(v, 5)][0], curves[(ref_v, 5)][0])
        L.append(f"- ensemble 5 model {v} − ensemble 5 model {ref_v}: {m:+.2f} ± {se:.2f} s (tốt hơn ở {pct:.0f}% , n = {n})")

# ---------------------------------------------------------------- T4 prob-mean vs median-mean
if ("val25", 5) in curves:
    cv_m = evaluate_cv(ens_pred("val25", res["val25"]["cs"][:5], "median"))
    L += ["", "## 4. Cách lấy trung bình: trung bình phân phối hay trung bình các con số?", "",
          f"Ensemble 5 model `val25`, CV macro: trung bình phân phối rồi lấy trung vị **{curves[('val25', 5)][0]['macro'].mean():.2f}**; "
          f"trung bình các trung vị của từng model {cv_m['macro'].mean():.2f}."]

# ---------------------------------------------------------------- T5 bins
L += ["", "## 5. MAE theo bin (CV, gộp mọi cửa sổ giữ ngoài)", "", "| Cấu hình | 0-40 s | 40-90 s | 90-300 s | 300-600 s |", "|---|---|---|---|---|"]
for v in variants:
    n = min(5, len(res[v]["cs"]))
    sb = np.mean([bins_mae(s["y"], s["p"]) for s in res[v]["single"]], 0)
    L.append(f"| {v} (model đơn, trung bình) | " + " | ".join(f"{x:.1f}" for x in sb) + " |")
    if (v, n) in curves:
        L.append(f"| {v} (ensemble {n} model) | " + " | ".join(f"{x:.1f}" for x in bins_mae(curves[(v, n)][0]["y"], curves[(v, n)][0]["p"])) + " |")

# ---------------------------------------------------------------- T6 blend with the tree committee
tp = lambda tag, k, g: np.load(os.path.join(PRED, f"trees_{tag}_f{k}_s{0 if tag == 'cv' else 42}_{g}.npy"))
tree_ok = all(os.path.exists(os.path.join(PRED, f"trees_cv_f{k}_s0_{g}.npy")) for k, gs in enumerate(groups_cv) for g in gs) and \
    os.path.exists(os.path.join(PRED, "trees_public_f0_s42_test40.npy"))
best = None
if tree_ok:
    cand = [(curves[(v, 5)][0]["macro"].mean(), v) for v in variants if (v, 5) in curves]
    best = min(cand)[1] if cand else None
if tree_ok and best:
    gru = ens_pred(best, res[best]["cs"][:5])
    trees = evaluate_cv(lambda k, g: tp("cv", k, g))
    alphas = np.round(np.linspace(0, 1, 11), 1)
    grid = {a: evaluate_cv(lambda k, g, a=a: a * gru(k, g) + (1 - a) * tp("cv", k, g)) for a in alphas}
    macro_by = np.array([grid[a]["macro"] for a in alphas])                 # (alphas, folds)
    nested = []
    for k in range(5):
        other = [i for i in range(5) if i != k]
        a_k = alphas[np.argmin(macro_by[:, other].mean(1))]
        nested.append((a_k, macro_by[list(alphas).index(a_k), k]))
    a_star = alphas[np.argmin(macro_by.mean(1))]
    L += ["", f"## 6. Ghép GRU ({best}, ensemble 5 model) với committee cây (`committee_stack`)", "",
          "Dự đoán ghép = α × GRU + (1 − α) × cây. Cây chỉ có 1 seed (CV seed 0, test công khai seed 42). α được chọn bằng CV lồng nhau: "
          "với mỗi fold giữ ngoài, α là giá trị tốt nhất trên 4 fold còn lại.", "",
          "| α (trọng số GRU) | " + " | ".join(f"{a:.1f}" for a in alphas) + " |", "|---|" + "---|" * len(alphas),
          "| CV macro | " + " | ".join(f"{macro_by[i].mean():.2f}" for i in range(len(alphas))) + " |", "",
          f"- Cây một mình (α = 0): CV macro {trees['macro'].mean():.2f}; GRU ensemble một mình (α = 1): {grid[1.0]['macro'].mean():.2f}.",
          f"- α chọn lồng nhau theo từng fold: {', '.join(f'{a:.1f}' for a, _ in nested)}; CV macro của cách chọn lồng nhau: **{np.mean([m for _, m in nested]):.2f}**.",
          f"- α tốt nhất trên toàn bộ CV: {a_star:.1f} (CV macro {macro_by.mean(1).min():.2f}).",
          f"- Tương quan sai số có dấu (dự đoán − nhãn) giữa GRU ensemble và cây trên mọi cửa sổ giữ ngoài: "
          f"{np.corrcoef(grid[1.0]['p'] - grid[1.0]['y'], trees['p'] - trees['y'])[0, 1]:.2f}."]
    m, se, pct, n = paired(grid[a_star], grid[1.0])
    L.append(f"- Ghép với α = {a_star:.1f} − GRU ensemble một mình: {m:+.2f} ± {se:.2f} s (tốt hơn ở {pct:.0f}% bản ghi-nhóm, n = {n}).")
    bl = lambda k, g: a_star * gru(k, g) + (1 - a_star) * tp("cv", k, g)
    L += ["", "MAE theo bin (CV): cây: " + " / ".join(f"{x:.1f}" for x in bins_mae(trees["y"], trees["p"])) +
          f"; GRU ensemble: " + " / ".join(f"{x:.1f}" for x in bins_mae(grid[1.0]["y"], grid[1.0]["p"])) +
          f"; ghép α = {a_star:.1f}: " + " / ".join(f"{x:.1f}" for x in bins_mae(grid[a_star]["y"], grid[a_star]["p"]))]
else:
    L += ["", "## 6. Ghép với committee cây", "", "Chưa có dự đoán của committee cây (hoặc chưa đủ seed GRU) nên chưa tính."]

# ---------------------------------------------------------------- T7 public seed-42 summary
L += ["", "## 7. Điểm test công khai seed 42, theo từng công thức", "",
      "| Công thức | Model đơn seed 42 | Ensemble 5 model (seed 42-46) | Ensemble 8 model (seed 42-49) |", "|---|---|---|---|"]
for v in variants:
    c5 = f"{curves[(v, 5)][1]['score']:.1f}" if (v, 5) in curves else "-"
    c8 = f"{curves[(v, 8)][1]['score']:.1f}" if (v, 8) in curves else "-"
    L.append(f"| {v} | {res[v]['psingle'][0]['score']:.1f} | {c5} | {c8} |")
if tree_ok:
    trp = evaluate_pub(tp("public", 0, "test40"))
    L.append(f"| `committee_stack` cây (seed 42) | {trp['score']:.1f} | | |")
    if best:
        gp = evaluate_pub(ens_pred(best, res[best]["ps"][:5], "prob", "public")(0, "test40"))
        for a in (a_star, 0.5, 0.7):
            bp = evaluate_pub(a * np.clip(ens_pred(best, res[best]["ps"][:5], "prob", "public")(0, "test40"), 0, 600) + (1 - a) * tp("public", 0, "test40"))
            L.append(f"| Ghép {best} ensemble 5 + cây, α = {a:.1f} | | {bp['score']:.1f} | |")
L += ["", "Mốc cùng seed 42 trên 40 bản ghi: GRU `lp45` đơn 48.8, `dist_w` đơn 48.0 (lần chạy trước), `committee_stack` cây 52.0, hằng số 60.7."]
open(os.path.join(HERE, "results", "summary.md"), "w").write("\n".join(L) + "\n")
print("\n".join(L))
