"""Do the M1-M7 variants (MULTITASK_EXPERIMENTS.md) help as ensemble members ("views")? Same method as ens_feat_views.py.

Ensemble = mean of the members' 121-class distributions, then the interpolated median. All draws are random subsets of a pool, D draws per
cell; per-recording scores are averaged over the draws and compared per recording (paired).
  Table 1  each view alone: n members of the view against n random `base` members (n = 3 CV, 5 public)
  Table 2  n members of the view + n random `base` members against 2n random `base` members
  Table 3  pool of all M views (those finished) against `base` at the same size k, and pool "mix8" + M views against mix8
`base` = 20 seeds (probs_e12 + probs_base_more); the `base` re-run in probs_mt is left out.
usage: python ens_mt_views.py [draws, default 20]
"""
import glob
import os
import re
import sys
import time

import numpy as np

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"))
import run_stft_tree as R  # noqa: E402

DRAWS = int(sys.argv[1]) if len(sys.argv) > 1 else 20
MT = ["m1_awake", "m2_near", "m3_next", "m4_all", "m5_hazard", "m6a_featgru", "m6b_gru2", "m6c_lstm", "m6d_tcn", "m6e_lp30", "m7_adv"]
MIX8 = ["e11", "a9_ngs", "e11_a9", "a9_ngsm", "e9b_nfft128", "e5c_dropout", "a2_swap", "a10_covmix"]
REF = ["a2_swap", "e5c_dropout", "e9b_nfft128", "a10_covmix"]
K = 121
CVK = [(f, g) for f in range(5) for g in ("seen", "unseen")]
PUBK = [(0, "test40")]
_, _, win, rec = R.extract()
y = win.y.to_numpy(); wrec = win.rec.to_numpy(); widx = win.groupby("rec").indices
wmet = R.metric_weights(y, wrec)

files = {}
for d in ("probs_e12", "probs_base_more", "probs_views2", "probs_mt"):
    for p in glob.glob(os.path.join(HERE, d, "*.npz")):
        m = re.match(r"(.+)_(cv|public)_f(\d+)_s(\d+)_(\w+)\.npz$", os.path.basename(p))
        if d == "probs_mt" and m[1] == "base":
            continue
        files.setdefault((m[1], m[2], int(m[4])), {})[(int(m[3]), m[5])] = p

ROWS, UINV = {}, {}
for tag, keys in (("cv", CVK), ("public", PUBK)):
    for (v, t, s), kp in files.items():
        if t == tag and all(k in kp for k in keys):
            for k in keys:
                recs = list(np.load(kp[k])["recs"])
                ROWS[(tag, k)] = np.concatenate([widx[r] for r in recs])
                UINV[(tag, k)] = np.unique(wrec[ROWS[(tag, k)]], return_inverse=True)
            break


def members(views, tag, keys):
    out = {}
    for (v, t, s), kp in files.items():
        if v in views and t == tag and all(k in kp for k in keys):
            out[(v, s)] = {k: np.load(kp[k])["probs"].astype(np.float16) for k in keys}
    return out


t0 = time.time()
POOL = {}
for tag, keys in (("cv", CVK), ("public", PUBK)):
    POOL[tag] = {"base": members(["base"], tag, keys), "mt": members(MT, tag, keys), "mix8": members(MIX8, tag, keys)}
    POOL[tag]["mix8m"] = {**POOL[tag]["mix8"], **POOL[tag]["mt"]}
print(f"members CV: " + ", ".join(f"{k} {len(v)}" for k, v in POOL["cv"].items()) + " | public: " +
      ", ".join(f"{k} {len(v)}" for k, v in POOL["public"].items()) + f"   (loaded in {time.time() - t0:.0f} s)")


def decode(p):
    p = p / p.sum(1, keepdims=True)
    cdf = p.cumsum(1)
    idx = np.minimum((cdf < 0.5).sum(1), K - 1)
    n = np.arange(len(p)); pk = p[n, idx]; prev = cdf[n, idx] - pk
    return np.clip(5.0 * (idx - 0.5 + np.clip((0.5 - prev) / np.maximum(pk, 1e-9), 0, 1)), 0, 600)


def scores(pool, chosen, tag, keys):
    out = {}
    for k in keys:
        p = np.mean([pool[m][k].astype(np.float32) for m in chosen], 0)
        ite = ROWS[(tag, k)]
        out[k] = np.bincount(UINV[(tag, k)][1], wmet[ite] * np.abs(decode(p) - y[ite]))
    return out


def macro(per, tag):
    if tag == "public":
        return float(per[PUBK[0]].mean())
    return float(np.mean([np.mean([per[(f, g)].mean() for g in ("seen", "unseen")]) for f in range(5)]))


def cell(tag, chooser):
    """D draws of `chooser(rng)` -> (pool dict, member list); mean per-recording scores and the macro of each draw."""
    keys = CVK if tag == "cv" else PUBK
    rng = np.random.default_rng(0)
    acc = {k: 0.0 for k in keys}; per_draw = []
    for _ in range(DRAWS):
        pool, chosen = chooser(rng)
        sc = scores(pool, chosen, tag, keys)
        for k in keys:
            acc[k] = acc[k] + sc[k] / DRAWS
        per_draw.append(macro(sc, tag))
    return acc, np.array(per_draw)


def draw(pool, k):
    names = sorted(pool)
    return lambda rng: (pool, [names[i] for i in rng.choice(len(names), k, replace=False)])


def paired(a, b, tag):
    keys = CVK if tag == "cv" else PUBK
    d = np.concatenate([a[k] - b[k] for k in keys])
    return f"{d.mean():+.2f} ± {d.std() / np.sqrt(len(d)):.2f}"


avail = sorted({m[0] for m in POOL["cv"]["mt"]} | {m[0] for m in POOL["public"]["mt"]})
print("\nTable 1/2 (negative = the view helps). n = 3 (CV) / 5 (public) members of the view")
print(f"{'view':>14s} | {'CV own':>7s} {'CV base':>8s} {'own−base':>14s} {'mix−2base':>14s} | {'pub own':>8s} {'pub base':>8s} {'own−base':>14s} {'mix−2base':>14s}")
for v in avail:
    row = []
    for tag, n in (("cv", 3), ("public", 5)):
        bp = POOL[tag]["base"]; vp = {m: a for m, a in POOL[tag]["mt"].items() if m[0] == v}
        if len(vp) < n:
            row.append(None); continue
        pool = {**bp, **vp}; bn, vn = sorted(bp), sorted(vp)
        own = lambda rng, vn=vn, n=n, pool=pool: (pool, [vn[i] for i in rng.choice(len(vn), n, replace=False)])
        mixed = lambda rng, bn=bn, vn=vn, n=n, pool=pool: (pool, [bn[i] for i in rng.choice(len(bn), n, replace=False)] +
                                                         [vn[i] for i in rng.choice(len(vn), n, replace=False)])
        o, od = cell(tag, own); b_, bd = cell(tag, draw(bp, n)); m_, md = cell(tag, mixed); b2, _ = cell(tag, draw(bp, 2 * n))
        row.append((od.mean(), bd.mean(), paired(o, b_, tag), paired(m_, b2, tag)))
    txt = [("%7.2f %8.2f %14s %14s" % r) if r else f"{'n/a':>7s}" + " " * 39 for r in row]
    print(f"{v:>14s} | {txt[0]} | {txt[1]}")
print("\nTable 3: pool of the finished M views against base at the same size k (paired), and mix8 + M views against mix8")
for k in (4, 8, 12):
    out = []
    for tag in ("cv", "public"):
        mt, bp, mx, mxm = POOL[tag]["mt"], POOL[tag]["base"], POOL[tag]["mix8"], POOL[tag]["mix8m"]
        if k > len(mt):
            out.append("n/a"); continue
        a, ad = cell(tag, draw(mt, k)); b_, bd = cell(tag, draw(bp, k))
        c_, cd = cell(tag, draw(mxm, k)); d_, dd = cell(tag, draw(mx, k))
        out.append(f"M {ad.mean():.2f} base {bd.mean():.2f} diff {paired(a, b_, tag)} | mix8+M {cd.mean():.2f} mix8 {dd.mean():.2f} diff {paired(c_, d_, tag)}")
    print(f"k={k:2d}  CV: {out[0]}\n      public: {out[1]}")
print(f"\ndone in {time.time() - t0:.0f} s")
