"""
Stage 05 (v8b): build the AIME25 4-alpha results table.

Reads the stage-04 summary JSON and emits a CSV + Markdown table with,
per alpha: accuracy, mean thinking tokens (+ reduction vs alpha=1.0),
mean chars (+ reduction), mean reflection markers (+ reduction), and
collapse rate. Reductions are relative to the alpha=1.0 baseline.

Outputs into results/:
  aime25_seed{seed}_4alpha_table.csv
  aime25_seed{seed}_4alpha_table.md
"""
import argparse, csv, math, os, sys
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from configs import get_config
from configs.paths import dim_paths, ensure_dirs
from src.utils import read_json

FIELDS = [
    "alpha", "n", "accuracy_%", "correct", "mean_think_tokens",
    "token_reduction_%", "mean_chars", "char_reduction_%",
    "mean_reflection_markers", "reflection_reduction_%",
    "no_boxed", "collapse_rate_%",
]


def fmt(x, nd=2):
    if x is None:
        return ""
    try:
        if math.isnan(float(x)):
            return ""
    except Exception:
        return str(x)
    return f"{float(x):.{nd}f}"


def rows_from_summary(summary):
    base = summary.get("1.00")
    rows = []
    for a in sorted([float(k) for k in summary.keys()], reverse=True):
        k = f"{a:.2f}"
        s = summary[k]
        def red(field):
            if not base or float(base[field]) == 0:
                return None
            return 1 - float(s[field]) / float(base[field])
        rows.append({
            "alpha": k,
            "n": s.get("n", ""),
            "accuracy_%": fmt(100.0 * float(s.get("accuracy", 0)), 1),
            "correct": s.get("n_correct", ""),
            "mean_think_tokens": fmt(float(s.get("mean_think_tokens", 0)), 1),
            "token_reduction_%": fmt(100.0 * red("mean_think_tokens"), 1)
                                 if red("mean_think_tokens") is not None else "",
            "mean_chars": fmt(float(s.get("mean_chars", 0)), 1),
            "char_reduction_%": fmt(100.0 * red("mean_chars"), 1)
                                if red("mean_chars") is not None else "",
            "mean_reflection_markers": fmt(float(s.get("mean_mon", 0)), 2),
            "reflection_reduction_%": fmt(100.0 * red("mean_mon"), 1)
                                      if red("mean_mon") is not None else "",
            "no_boxed": s.get("n_no_boxed", ""),
            "collapse_rate_%": fmt(100.0 * float(s.get("collapse_rate", 0)), 1),
        })
    return rows


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--dimension", default="monitoring")
    ap.add_argument("--seed", type=int, default=0)
    args = ap.parse_args()

    ensure_dirs(args.dimension)
    cfg = get_config(args.dimension)
    p = dim_paths(args.dimension)

    sum_path = os.path.join(p.RESULTS_DIR, f"aime25_seed{args.seed}_4alpha_summary.json")
    if not os.path.exists(sum_path):
        print(f"[05] missing {sum_path} — run stage 04 first."); sys.exit(1)
    data = read_json(sum_path)
    rows = rows_from_summary(data["summary"])

    csv_path = os.path.join(p.RESULTS_DIR, f"aime25_seed{args.seed}_4alpha_table.csv")
    md_path = os.path.join(p.RESULTS_DIR, f"aime25_seed{args.seed}_4alpha_table.md")

    with open(csv_path, "w", newline="", encoding="utf-8") as f:
        w = csv.DictWriter(f, fieldnames=FIELDS)
        w.writeheader()
        for r in rows:
            w.writerow({k: r.get(k, "") for k in FIELDS})

    with open(md_path, "w", encoding="utf-8") as f:
        f.write("| " + " | ".join(FIELDS) + " |\n")
        f.write("| " + " | ".join(["---"] * len(FIELDS)) + " |\n")
        for r in rows:
            f.write("| " + " | ".join(str(r.get(k, "")) for k in FIELDS) + " |\n")

    print(f"[05] selected_layers: {data.get('selected_layers')}")
    print(f"[05] wrote:\n  {csv_path}\n  {md_path}\n")
    print("| " + " | ".join(FIELDS) + " |")
    print("| " + " | ".join(["---"] * len(FIELDS)) + " |")
    for r in rows:
        print("| " + " | ".join(str(r.get(k, "")) for k in FIELDS) + " |")


if __name__ == "__main__":
    main()