"""E12: seed ensembles of the saved held-out probabilities (run_augment.py --save-probs), scored per recording.

Ensemble = mean of the members' 121-class distributions, then the median (the rule of the submitted solvers).
CV: members are the CV seeds of each fold; public split: members are the public seeds (42 first).
usage: python ens_e12.py <probs dir> [summary file name]
"""
import collections
import glob
import os
import re
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, os.path.join(ROOT, "experiments/ensemble"))
import run_stft_tree as R  # noqa: E402
from ens_utils import median_decode  # noqa: E402

PD = os.path.join(HERE, sys.argv[1] if len(sys.argv) > 1 else "probs_e12")
OUT = sys.argv[2] if len(sys.argv) > 2 else "summary_e12.md"
ORDER = ["base", "e11", "a9_ngs", "e11_a9", "a9_ngsm"]
_, _, win, rec = R.extract()
y = win.y.to_numpy(); wrec = win.rec.to_numpy(); widx = win.groupby("rec").indices

runs = collections.defaultdict(dict)                       # (variant, tag, fold, group) -> {seed: path}
for p in glob.glob(os.path.join(PD, "*.npz")):
    m = re.match(r"(.+)_(cv|public)_f(\d+)_s(\d+)_(\w+)\.npz$", os.path.basename(p))
    runs[(m[1], m[2], int(m[3]), m[5])][int(m[4])] = p
variants = [v for v in ORDER if any(k[0] == v for k in runs)] + sorted({k[0] for k in runs} - set(ORDER))


def score(paths):
    """Mean of the distributions of the given runs -> per-recording W-bMAE (dict)."""
    d = [np.load(p) for p in paths]
    recs = list(d[0]["recs"])
    assert all(list(x["recs"]) == recs for x in d)
    probs = np.mean([x["probs"].astype(np.float32) for x in d], 0)
    ite = np.concatenate([widx[r] for r in recs])
    return R.score(y[ite], median_decode(probs), wrec[ite])[0]


rows = []
for (v, tag, fold, group), seeds in runs.items():
    ss = sorted(seeds)
    for s in ss:
        rows += [dict(variant=v, tag=tag, fold=fold, group=group, kind="single", seed=s, rec=r, wbmae=x)
                 for r, x in score([seeds[s]]).items()]
    for k in range(2, len(ss) + 1):                       # ensembles of the first k seeds
        rows += [dict(variant=v, tag=tag, fold=fold, group=group, kind=f"ens{k}", seed=-1, rec=r, wbmae=x)
                 for r, x in score([seeds[s] for s in ss[:k]]).items()]
df = pd.DataFrame(rows)
df.to_csv(os.path.join(PD, "scores_per_recording.csv"), index=False)

cv, pub = df[df.tag == "cv"], df[df.tag == "public"]
kmax = int(cv[cv.kind.str.startswith("ens")].kind.str[3:].astype(int).max()) if (cv.kind != "single").any() else 1
ens = f"ens{kmax}" if kmax > 1 else "single"


def macro(g):                                              # mean over folds of mean(seen, unseen) of the per-group means
    t = g.groupby(["fold", "group"]).wbmae.mean().unstack()
    return float(t.mean(1).mean())


def paired(g, v):
    p = g.pivot_table(index=["fold", "group", "rec"], columns="variant", values="wbmae", aggfunc="mean")
    if v == "base" or "base" not in p:
        return ""
    d = (p[v] - p["base"]).dropna()
    return f"{d.mean():+.2f} ± {d.std() / np.sqrt(len(d)):.2f} ({100 * (d < 0).mean():.0f}% tốt hơn)"


L = ["# E11/E12: ensemble theo seed", "", 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. Mọi cấu hình: low-pass 45 Hz + E4 "
     "+ 217 feature + head `dist_w`. `e11` = feature bỏ vạch AF7 (E7a) + cờ kênh hỏng và zero kênh hỏng (E5b); `a9_ngs` = augmentation "
     "nhiễu Gauss cho CNN + gain theo bản ghi và kênh + hoán đổi bán cầu; `e11_a9` = cả hai. Ensemble = trung bình phân phối 121 lớp "
     "của các seed, rồi lấy trung vị. So cặp với `base` trên từng bản ghi.", "",
     f"## CV 5 fold ({kmax} seed mỗi fold)", "",
     "| Cấu hình | Model đơn (TB các seed) | Model đơn: hiệu so với `base` | **Ensemble** | Ensemble: hiệu so với `base` ± SE | Lợi ích của ensemble |",
     "|---|---|---|---|---|---|"]
for v in variants:
    s1, e = cv[(cv.variant == v) & (cv.kind == "single")], cv[(cv.variant == v) & (cv.kind == ens)]
    if len(s1):
        L.append(f"| {v} | {macro(s1):.2f} | {paired(cv[cv.kind == 'single'], v)} | **{macro(e):.2f}** | {paired(cv[cv.kind == ens], v)} | "
                 f"{macro(e) - macro(s1):+.2f} |")
L += ["", "Ensemble CV theo số seed (k seed đầu):", "", "| Cấu hình | " + " | ".join(f"k={k}" for k in range(1, kmax + 1)) + " |",
      "|---|" + "---|" * kmax]
for v in variants:
    vals = [macro(cv[(cv.variant == v) & (cv.kind == "single") & (cv.seed == cv[(cv.variant == v) & (cv.kind == "single")].seed.min())])] + \
           [macro(cv[(cv.variant == v) & (cv.kind == f"ens{k}")]) for k in range(2, kmax + 1)]
    L.append(f"| {v} | " + " | ".join(f"{x:.2f}" for x in vals) + " |")
if len(pub):
    kp = int(pub[pub.kind.str.startswith("ens")].kind.str[3:].astype(int).max()) if (pub.kind != "single").any() else 1
    seeds = sorted(pub[pub.kind == "single"].seed.unique())
    L += ["", f"## Test công khai (train 500, chấm 40 bản ghi; seed {', '.join(map(str, seeds))}; SE khoảng 4 s)", "",
          "| Cấu hình | " + " | ".join(f"seed {s}" for s in seeds) + " | TB model đơn | " + " | ".join(f"ensemble {k}" for k in range(2, kp + 1)) +
          f" | Ensemble {kp}: hiệu so với `base` ± SE |", "|---|" + "---|" * (len(seeds) + kp + 1)]
    for v in variants:
        g = pub[pub.variant == v]
        if not len(g):
            continue
        sing = [g[(g.kind == "single") & (g.seed == s)].wbmae.mean() for s in seeds]
        ensv = [g[g.kind == f"ens{k}"].wbmae.mean() for k in range(2, kp + 1)]
        L.append(f"| {v} | " + " | ".join(f"{x:.2f}" for x in sing) + f" | {np.nanmean(sing):.2f} | " + " | ".join(f"{x:.2f}" for x in ensv) +
                 f" | {paired(pub[pub.kind == f'ens{kp}'], v) if kp > 1 else ''} |")
    L += ["", f"Cột `ensemble {kp}` là cách bản nộp được chấm (mốc: bản nộp `CNN-feat-GRU-Ensemble-E4` 8 model, tự chấm 43.75)."]
os.makedirs(os.path.join(HERE, "results"), exist_ok=True)
open(os.path.join(HERE, "results", OUT), "w").write("\n".join(L) + "\n")
print("\n".join(L))
