"""Aggregate run JSONs into paper-comparable tables with CIs and paired tests."""
from __future__ import annotations

import argparse
import glob
import json
import os
from collections import defaultdict

import numpy as np

METHOD_LABEL = {
    "stgfn": "ST-GFN (Ours)", "tb": "TB", "fm": "FM", "subtb": "SubTB", "db": "DB",
    "eflownet": "EFlowNet", "stochastic_gfn": "Stochastic-GFN",
    "tb_rnd": "TB+RND", "tb_novelty": "TB+Novelty", "tb_icm": "TB+ICM",
    "tb_cv": "TB+ControlVariates",
    "stgfn_no_spectral": "ST-GFN w/o spectral", "stgfn_no_intrinsic": "ST-GFN w/o intrinsic",
}
ORDER = ["stgfn", "tb", "fm", "subtb", "db", "eflownet", "stochastic_gfn",
         "tb_rnd", "tb_novelty", "tb_icm", "tb_cv",
         "stgfn_no_spectral", "stgfn_no_intrinsic"]

# metrics reported per environment (key, pretty name, higher_is_better)
ENV_METRICS = {
    "bitsequence": [("top100_reward", "Top-100", True), ("diversity", "Div.", True),
                    ("l1_to_target", "L1 to P*", False), ("mean_reward", "Mean R", True)],
    "hypergrid": [("modes_found", "Modes", True), ("coverage_pct", "Cov.%", True),
                  ("l1_to_target", "L1 to P*", False), ("mean_reward", "Mean R", True)],
    "tictactoe": [("win_pct", "Win%", True), ("optimal_pct", "Opt.%", True),
                  ("blunder_pct", "Blunder%", False), ("top100_reward", "Top-100", True)],
    "singlecell_proxy": [("target_corr", "Corr.", True), ("l1_error", "L1", False),
                         ("top100_reward", "Top-100", True)],
}


def ci95(vals):
    v = np.array([x for x in vals if x is not None], dtype=float)
    if len(v) == 0:
        return None, None
    if len(v) == 1:
        return float(v[0]), 0.0
    return float(v.mean()), float(1.96 * v.std(ddof=1) / np.sqrt(len(v)))


def welch_t(a, b):
    """Welch's t-test; returns (t, approx two-sided p) without scipy."""
    a = np.array(a, float); b = np.array(b, float)
    if len(a) < 2 or len(b) < 2:
        return None, None
    va, vb = a.var(ddof=1), b.var(ddof=1)
    se = np.sqrt(va / len(a) + vb / len(b))
    if se == 0:
        return None, None
    t = (a.mean() - b.mean()) / se
    df = (va / len(a) + vb / len(b)) ** 2 / (
        (va / len(a)) ** 2 / (len(a) - 1) + (vb / len(b)) ** 2 / (len(b) - 1)
    )
    # normal approximation to the two-sided p-value
    from math import erfc, sqrt
    p = erfc(abs(t) / sqrt(2))
    return float(t), float(p)


def cohens_d(a, b):
    a = np.array(a, float); b = np.array(b, float)
    if len(a) < 2 or len(b) < 2:
        return None
    s = np.sqrt(((len(a) - 1) * a.var(ddof=1) + (len(b) - 1) * b.var(ddof=1)) /
                (len(a) + len(b) - 2))
    return float((a.mean() - b.mean()) / s) if s > 0 else None


def load(out_dir):
    data = defaultdict(lambda: defaultdict(list))
    for path in glob.glob(os.path.join(out_dir, "*.json")):
        with open(path) as f:
            r = json.load(f)
        data[r["env"]][r["method"]].append(r)
    return data


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--out", default="../outputs/main")
    ap.add_argument("--save", default="../outputs/summary.json")
    args = ap.parse_args()

    data = load(args.out)
    summary = {}
    for env in ["bitsequence", "hypergrid", "tictactoe", "singlecell_proxy"]:
        if env not in data:
            continue
        metrics = ENV_METRICS[env]
        print(f"\n{'='*100}\n{env.upper()}   (mean +- 95% CI over seeds)\n{'='*100}")
        header = f"{'Method':22s} {'n':>2s} " + " ".join(f"{name:>16s}" for _, name, _ in metrics)
        print(header)
        summary[env] = {}
        # gather ST-GFN values for significance tests
        base_vals = {k: [r["final"].get(k) for r in data[env].get("stgfn", [])] for k, _, _ in metrics}
        for m in ORDER:
            if m not in data[env]:
                continue
            runs = data[env][m]
            cells, entry = [], {"n_seeds": len(runs)}
            for key, _, hib in metrics:
                vals = [r["final"].get(key) for r in runs]
                mu, ci = ci95(vals)
                entry[key] = {"mean": mu, "ci95": ci, "values": vals}
                if mu is None:
                    cells.append(f"{'-':>16s}")
                    continue
                star = ""
                if m != "stgfn" and base_vals.get(key):
                    bv = [x for x in base_vals[key] if x is not None]
                    ov = [x for x in vals if x is not None]
                    if len(bv) > 1 and len(ov) > 1:
                        _, p = welch_t(bv, ov)
                        entry[key]["p_vs_stgfn"] = p
                        entry[key]["cohens_d_stgfn_minus_this"] = cohens_d(bv, ov)
                        if p is not None and p < 0.05:
                            star = "*"
                cells.append(f"{mu:11.3f}±{ci:4.3f}{star:>1s}"[:16].rjust(16))
            # efficiency
            wt, _ = ci95([r["final"].get("wall_time_s") for r in runs])
            st, _ = ci95([r["final"].get("stability_cv") for r in runs])
            entry["wall_time_s"] = wt
            entry["stability_cv"] = st
            summary[env][m] = entry
            print(f"{METHOD_LABEL.get(m,m):22s} {len(runs):2d} " + " ".join(cells)
                  + f"   [t={wt:.0f}s cv={st if st is not None else float('nan'):.3f}]")
        print("  * = p<0.05 (Welch) vs ST-GFN on that metric")

    with open(args.save, "w") as f:
        json.dump(summary, f, indent=2)
    print(f"\nwrote {args.save}")


if __name__ == "__main__":
    main()