"""Pooled out-of-fold (OOF) evaluation.

Each of the 33 samples is a test sample in exactly one of the 5 folds, so the
fold predictions can be concatenated into a single OOF set of 33 trajectories.
Per-target R2 computed on that pooled set is far more stable than averaging five
per-fold R2 values, several of which are computed on 1-3 labelled samples.
"""
from __future__ import annotations

import json
import os
from pathlib import Path
from typing import Dict, List, Tuple

import numpy as np
import pandas as pd

from .data import TARGETS, TARGET_KEYS
from .metrics import PRIMARY, _r2, regression_metrics

ROOT = Path(os.environ.get("PIMAMBA_ROOT")
            or Path(__file__).resolve().parents[2])
RUNS = ROOT / "results" / "runs"
TABLES = ROOT / "results" / "tables"


def gather(model: str, seed: int = 0, n_folds: int = 5, prefix: str = "main"):
    P, Y, M, S = [], [], [], []
    for f in range(n_folds):
        d = RUNS / f"{prefix}_{model}_f{f}_s{seed}" / "predictions.npz"
        if not d.exists():
            continue
        z = np.load(d, allow_pickle=True)
        P.append(z["pred"]); Y.append(z["true"]); M.append(z["mask"])
        S.append(np.asarray(z["sids"]))
    if not P:
        return None
    return (np.concatenate(P, 0), np.concatenate(Y, 0),
            np.concatenate(M, 0), np.concatenate(S, 0))


def pooled_table(models: List[str], seed: int = 0,
                 prefix: str = "main") -> Tuple[pd.DataFrame, pd.DataFrame]:
    rows, dec_rows = [], []
    for m in models:
        g = gather(m, seed, prefix=prefix)
        if g is None:
            continue
        P, Y, M, S = g
        pt = regression_metrics(Y.reshape(-1, len(TARGETS)),
                                P.reshape(-1, len(TARGETS)),
                                M.reshape(-1, len(TARGETS)))
        r = {"model": m, "n_samples": len(S)}
        for k in TARGET_KEYS:
            v = pt[k]
            r[k] = round(v["r2"], 3) if np.isfinite(v["r2"]) else np.nan
        prim = [pt[k]["r2"] for k in PRIMARY if np.isfinite(pt[k]["r2"])]
        r["primary_mean"] = round(float(np.mean(prim)), 3) if prim else np.nan
        r["primary_median"] = round(float(np.median(prim)), 3) if prim else np.nan
        rows.append(r)

        j = TARGET_KEYS.index("sigma")
        mm = M[:, :, j] > 0
        yv, pv = Y[:, :, j][mm], P[:, :, j][mm]
        ys, ps, lv = [], [], []
        for i in range(len(S)):
            s = M[i, :, j] > 0
            if s.sum() < 4:
                continue
            ys.append(Y[i, s, j] - Y[i, s, j].mean())
            ps.append(P[i, s, j] - P[i, s, j].mean())
            lv.append((Y[i, s, j].mean(), P[i, s, j].mean()))
        ys, ps = np.concatenate(ys), np.concatenate(ps)
        lv = np.array(lv)
        dec_rows.append({
            "model": m,
            "sigma_r2": round(_r2(yv, pv), 3),
            "shape_r2": round(_r2(ys, ps), 3),
            "level_corr": round(float(np.corrcoef(lv[:, 0], lv[:, 1])[0, 1]), 3),
            "level_mae_GPa": round(float(np.mean(np.abs(lv[:, 0] - lv[:, 1]))), 3),
            "level_bias_GPa": round(float(np.mean(lv[:, 1] - lv[:, 0])), 3),
            "peak_rel_err": round(float(np.mean([
                abs(max(P[i, M[i, :, j] > 0, j]) - max(Y[i, M[i, :, j] > 0, j]))
                / max(abs(max(Y[i, M[i, :, j] > 0, j])), 1e-6)
                for i in range(len(S)) if (M[i, :, j] > 0).sum() > 4])), 3),
        })
    return pd.DataFrame(rows), pd.DataFrame(dec_rows)


def ensemble(models: List[str], seed: int = 0, prefix: str = "main",
             prefixes: Dict[str, str] | None = None):
    """Average the normalised predictions of several runs (same fold split).

    All models see the identical test ids in the identical order, so the fold
    predictions are directly averageable; the result is inverse-transformed and
    scored exactly like a single model.
    """
    from .metrics import regression_metrics
    Ps, Ys, Ms, Ss = [], None, None, None
    for m in models:
        pref = (prefixes or {}).get(m, prefix)
        g = gather(m, seed, prefix=pref)
        if g is None:
            continue
        P, Y, M, S = g
        Ps.append(P)
        Ys, Ms, Ss = Y, M, S
    if not Ps:
        return None
    P = np.mean(Ps, 0)
    pt = regression_metrics(Ys.reshape(-1, len(TARGETS)),
                            P.reshape(-1, len(TARGETS)),
                            Ms.reshape(-1, len(TARGETS)))
    prim = [pt[k]["r2"] for k in PRIMARY if np.isfinite(pt[k]["r2"])]
    return {"model": "+".join(models), "sigma_r2": round(pt["sigma"]["r2"], 3),
            "primary_mean": round(float(np.mean(prim)), 3)}


NEXT = ["llama", "xlstm", "gdn", "hymba", "koopman", "node", "rssm", "flow",
        "pimamba2"]


def main():
    models = ["mlp", "gru", "lstm", "transformer", "mamba", "mamba2", "pimamba"]
    t, d = pooled_table(models)
    TABLES.mkdir(parents=True, exist_ok=True)
    t.to_csv(TABLES / "tab_pooled_per_target.csv", index=False)
    d.to_csv(TABLES / "tab_pooled_sigma.csv", index=False)
    ens = []
    combos = [(["pimamba", "mamba"], None),
              (["pimamba", "llama"], {"llama": "next"}),
              (["pimamba", "xlstm"], {"xlstm": "next"}),
              (["pimamba", "gdn"], {"gdn": "next"}),
              (["pimamba", "koopman"], {"koopman": "next"}),
              (["pimamba", "node"], {"node": "next"}),
              (["hymba", "mamba"], {"hymba": "next"}),
              (["hymba", "mamba", "pimamba"], {"hymba": "next"}),
              (["hymba", "llama"], {"hymba": "next", "llama": "next"})]
    for combo, pref in combos:
        r = ensemble(combo, prefixes=pref)
        if r:
            ens.append(r)
            print("ensemble", r)
    if ens:
        pd.DataFrame(ens).to_csv(TABLES / "tab_ensemble.csv", index=False)
    t2, d2 = pooled_table(NEXT, prefix="next")
    if len(t2):
        t2.to_csv(TABLES / "tab_pooled_next_per_target.csv", index=False)
        d2.to_csv(TABLES / "tab_pooled_next_sigma.csv", index=False)
        print("\n## pooled OOF (next-gen)")
        print(t2.to_string(index=False))

    V2 = ["pimamba2", "pimamba2_peak", "pimamba_peak", "pimamba2_nocouple"]
    t3, d3 = pooled_table(V2, prefix="v2")
    if len(t3):
        t3.to_csv(TABLES / "tab_pooled_v2_per_target.csv", index=False)
        d3.to_csv(TABLES / "tab_pooled_v2_sigma.csv", index=False)
        print("\n## pooled OOF (v2)")
        print(t3.to_string(index=False))
    print("## pooled OOF per-target R2")
    print(t.to_string(index=False))
    print("\n## pooled OOF stress decomposition")
    print(d.to_string(index=False))


if __name__ == "__main__":
    main()