"""Emit paper/tables/numbers.tex: every number quoted in the prose comes from this file (registry, configs, state store)."""
import os, sys, csv, json, yaml
sys.path.insert(0, os.path.dirname(__file__)); from common import *
def m(name, val): return f"\\newcommand{{\\{name}}}{{{val}}}"
def _n_infra_errors(split):
    import sqlite3
    c = sqlite3.connect(os.path.join(REPO, "runs", "state.sqlite"))
    return c.execute("SELECT COUNT(DISTINCT t.run_id) FROM run_transitions t JOIN runs r ON r.run_id=t.run_id WHERE r.split=? AND t.to_status='error'", (split,)).fetchone()[0]
def main():
    reg = list(csv.DictReader(open(os.path.join(REPO, "tasks", "registry.csv"))))
    conf = [r for r in reg if r["split"] == "conf"]; dev = [r for r in reg if r["split"] == "dev"]; tr = [r for r in reg if r["split"] == "transfer"]
    b = yaml.safe_load(open(os.path.join(REPO, "configs", "budgets.yaml")))["budget"]
    out = [m("nConfTasks", len(conf)), m("nDevTasks", len(dev)), m("nTransferTasks", len(tr)), m("nConfRealData", sum(r["real_data"] == "yes" for r in conf)),
           m("nConfSourceDocs", sum(r["source_documents"] == "yes" for r in conf)), m("nConfNullTruth", sum(r["infeasible_or_null_truth"] == "yes" for r in conf)),
           m("nOracles", len([r for r in reg if r["split"] in ("conf", "dev")])), m("envUSD", f"{b['max_budget_usd']:.2f}"), m("envWall", f"{b['wall_seconds']:,}"), m("envTurns", b["max_turns_per_session"])]
    try:
        s = pd.read_csv(os.path.join(DATA, "sessions.csv")); r = pd.read_csv(os.path.join(DATA, "runs.csv"))
        sm = s[s.run_id.str.startswith("RD") & (s.kind == "initial")].merge(r[["run_id", "treatment"]], on="run_id")
        for a in ARMS:
            v = sm[sm.treatment == a].first_turn_input_tokens
            out.append(m(f"ctx{a}", f"{int(v.iloc[0]):,}" if len(v) else "--"))
        rnp = r[~r.notes.fillna("").str.contains("seed 102|seed 402|seed 403|seed 802")]
        for split, tag in [("confirmatory", "Main"), ("pilot", "Pilot"), ("transfer", "Transfer"), ("recovery", "Recovery"), ("ablation", "Ablation")]:
            d = rnp[rnp.split == split]
            out += [m(f"n{tag}Runs", len(d)), m(f"n{tag}Evaluated", int((d.status == "evaluated").sum())), m(f"cost{tag}Total", f"{d.spent_usd.sum():.2f}")]
        rep = r[r.split == "confirmatory"].groupby(["task_id", "treatment"]).size()
        out.append(m("nRepeats", int(rep.max()) if len(rep) else 3))
        rf = r[~r.notes.fillna("").str.contains("seed 102|seed 402|seed 403|seed 802")]
        out.append(m("costAllTotal", f"{rf.spent_usd.sum():.2f}")); out.append(m("nAllRuns", len(rf))); out.append(m("nPostfixRuns", int(len(r) - len(rf))))
    except Exception as e:
        out.append(f"% sessions/runs not available: {e}")
    # headline results (confirmatory) + sensitivity + accounting
    try:
        at = pd.read_csv(os.path.join(EST, "confirmatory_arm_table.csv")).set_index("arm"); ct = pd.read_csv(os.path.join(EST, "confirmatory_contrasts.csv"))
        for a in ARMS:
            out += [m(f"p{a}", f"{at.loc[a, 'Y_task_weighted']:.3f}"), m(f"viol{a}", f"{at.loc[a, 'violation_rate']:.3f}"), m(f"nviol{a}", int(at.loc[a, 'n_runs_with_violation'])), m(f"cost{a}", f"{at.loc[a, 'cost_mean_usd']:.2f}"),
                    m(f"costMed{a}", f"{at.loc[a, 'cost_median_usd']:.2f}"), m(f"wall{a}", f"{at.loc[a, 'wall_median_s']:.0f}"), m(f"qual{a}", f"{at.loc[a, 'quality_mean']:.3f}"), m(f"nRuns{a}", int(at.loc[a, 'n_runs'])), m(f"costPerSuccess{a}", f"{at.loc[a, 'cost_per_success_usd']:.2f}" if pd.notna(at.loc[a, 'cost_per_success_usd']) else "undefined")]
        for _, r in ct[ct.endpoint == "Y"].iterrows():
            k = r["contrast"].replace("-", "")
            out += [m(f"d{k}", f"{r['estimate']:+.3f}"), m(f"d{k}lo", f"{r['ci_low']:+.3f}"), m(f"d{k}hi", f"{r['ci_high']:+.3f}"), m(f"d{k}p", f"{r['perm_p']:.2f}"), m(f"d{k}fav", f"{int(r['n_tasks_favoring_first'])}/{int(r['n_tasks_tied'])}/{int(r['n_tasks_favoring_second'])}")]
        rv = pd.read_csv(os.path.join(EST, "confirmatory_contrasts.csv")); q = rv[(rv.endpoint == "quality_score") & (rv.contrast == "D-A")].iloc[0]
        out += [m("dDAqual", f"{q['estimate']:+.4f}"), m("dDAquallo", f"{q['ci_low']:+.4f}"), m("dDAqualhi", f"{q['ci_high']:+.4f}")]
        sa = pd.read_csv(os.path.join(EST, "sensitivity_rubric_arm_table.csv")).set_index("arm"); sc = pd.read_csv(os.path.join(EST, "sensitivity_rubric_contrasts.csv")); sd = sc[sc.contrast == "D-A"].iloc[0]
        for a in ARMS: out.append(m(f"sens{a}", f"{sa.loc[a, 'Y_task_weighted']:.3f}"))
        sr = pd.read_csv(os.path.join(EST, "sensitivity_rubric_runs.csv")); out.append(m("nSensChanged", int((sr.success_frozen != sr.success_corrected).sum())))
        out += [m("sensDA", f"{sd['estimate']:+.3f}"), m("sensDAlo", f"{sd['ci_low']:+.3f}"), m("sensDAhi", f"{sd['ci_high']:+.3f}")]
        r = pd.read_csv(os.path.join(DATA, "runs.csv")); c = r[r.split == "confirmatory"]
        out += [m("nMainTimeouts", int((c.terminal_reason == "wall_clock_limit").sum())), m("nMainBudget", int(c.terminal_reason.fillna("").str.contains("budget").sum())), m("nMainInfraErrors", _n_infra_errors("confirmatory")),
                m("costMainMean", f"{c.spent_usd.mean():.2f}"), m("nMainViolRuns", int((c.n_violations > 0).sum())), m("nMainSuccess", int((c.scientific_success == 1).sum())), m("nMainNonSuccess", int((c.scientific_success == 0).sum()))]
        ses = pd.read_csv(os.path.join(DATA, "sessions.csv")); pfids = set(r[r.notes.fillna("").str.contains("seed 102|seed 402|seed 403|seed 802")].run_id)
        out.append(m("costAllSessions", f"{ses[~ses.run_id.isin(pfids)].session_cost_usd.sum():.2f}")); out.append(m("nMainSessions", int(ses.run_id.isin(c.run_id).sum())))
        dD = at.loc["D"]; out.append(m("reviewerShareD", f"{100 * dD['reviewer_usd_total'] / dD['cost_total_usd']:.0f}"))
        import subprocess as _sp
        out.append(m("nHarnessLines", f"{sum(int(l.split()[0]) for l in _sp.run(['wc', '-l'] + sorted(__import__('glob').glob(os.path.join(REPO, 'src', 'pgar', '*.py'))), capture_output=True, text=True).stdout.splitlines() if l.strip().endswith('.py')):,}"))
        for a in ("B", "C", "D"): out.append(m(f"costRatio{a}", f"{at.loc[a, 'cost_mean_usd'] / at.loc['A', 'cost_mean_usd']:.1f}"))
        gr = pd.read_csv(os.path.join(DATA, "gate_receipts.csv")); g = gr[gr.run_id.str.startswith("RC")]
        out += [m("nGateControllerFail", int(((g.origin == "controller") & (g.passed == 0)).sum())), m("nContractFailA", int((g[(g.origin == "final_common_contract_check") & (g.passed == 0)].merge(c[["run_id", "treatment"]], on="run_id").treatment == "A").sum())), m("nContractFailB", int((g[(g.origin == "final_common_contract_check") & (g.passed == 0)].merge(c[["run_id", "treatment"]], on="run_id").treatment == "B").sum()))]
        rvw = pd.read_csv(os.path.join(DATA, "reviews.csv")); rvw = rvw[rvw.run_id.str.startswith("RC")]
        out += [m("nReviews", len(rvw)), m("nReviewsRevise", int((rvw.verdict == "revise").sum())), m("nReviewsNoVerdict", int(rvw.verdict.isna().sum())), m("reviewIssuesMean", f"{rvw.n_issues.mean():.1f}")]
        ses2 = pd.read_csv(os.path.join(DATA, "sessions.csv")); sc = ses2[ses2.run_id.str.startswith("RC")]
        out += [m("nRepairSessions", int(sc.kind.isin(["review_repair"]).sum())), m("nGateCycleSessions", int(sc.kind.str.startswith("gate_cycle").sum())), m("costDallAttempts", f"{sc[sc.run_id.isin(c[c.treatment == 'D'].run_id)].session_cost_usd.sum() / 72:.3f}"), m("costAbortedAttempt", f"{sc[(sc.run_id == 'RC0094')].session_cost_usd.sum() - c[c.run_id == 'RC0094'].spent_usd.iloc[0]:.2f}")]
        gfail = g[(g.origin == "final_common_contract_check") & (g.passed == 0)]
        kinds = {}
        for _, row in gfail.iterrows():
            for ch in json.loads(open(os.path.join(REPO, "runs", "confirmatory", row.run_id, "contract_receipt.json")).read()).get("checks", []):
                if not ch["passed"]: kinds[ch["id"].split(":")[0]] = kinds.get(ch["id"].split(":")[0], 0) + 1
        out.append(m("contractFailKinds", "; ".join(f"{k.replace('_', ' ')} {v}" for k, v in sorted(kinds.items(), key=lambda kv: -kv[1]))))
        out.append(m("nReproFailAB", int(kinds.get("reproducibility", 0))))
    except Exception as e:
        out.append(f"% results macros not available: {e}")
    # recovery and ablation macros
    try:
        r1 = pd.read_csv(os.path.join(EST, "recovery_r1_summary.csv")).set_index("treatment")
        for a in ("A", "D"):
            out += [m(f"rOneN{a}", int(r1.loc[a, "n"])), m(f"rOneSucc{a}", f"{r1.loc[a, 'success']:.2f}"), m(f"rOneDup{a}", f"{r1.loc[a, 'dup_runs']:.1f}"), m(f"rOneLost{a}", int(r1.loc[a, "lost"])), m(f"rOneAck{a}", f"{r1.loc[a, 'ack']:.2f}"), m(f"rOneCost{a}", f"{r1.loc[a, 'cost']:.2f}")]
        r3 = json.load(open(os.path.join(EST, "recovery_r3_duplicate.json"))); out += [m("rThreeSubmissions", r3["submissions"]), m("rThreeSessions", r3["n_sessions_launched"])]
        rr = pd.read_csv(os.path.join(EST, "recovery_r1_r4.csv")); r4 = rr[rr.fault_type == "missing_fixture"]
        out += [m("rFourN", len(r4)), m("rFourInfeasible", int((r4.feasibility_reported == "infeasible").sum()))]
        r2 = json.load(open(os.path.join(EST, "recovery_r2_stale_input.json"))); out += [m("rTwoN", len(r2)), m("rTwoInvalidated", sum(1 for x in r2 if x.get("reproducibility_check_after_mutation") is False)), m("rTwoUnaffected", sum(1 for x in r2 if x.get("reproducibility_check_after_mutation") is True))]
        ab = pd.read_csv(os.path.join(EST, "ablation_length_control.csv")).set_index("contrast")
        out += [m("pL", f"{ab.loc['L rate', 'estimate']:.3f}"), m("dLA", f"{ab.loc['L-A', 'estimate']:+.3f}"), m("dLAlo", f"{ab.loc['L-A', 'ci_low']:+.3f}"), m("dLAhi", f"{ab.loc['L-A', 'ci_high']:+.3f}"), m("dLAp", f"{ab.loc['L-A', 'perm_p']:.2f}"), m("dBL", f"{ab.loc['B-L', 'estimate']:+.3f}"), m("dBLlo", f"{ab.loc['B-L', 'ci_low']:+.3f}"), m("dBLhi", f"{ab.loc['B-L', 'ci_high']:+.3f}"), m("nAblTasks", int(ab.loc['L rate', 'n_tasks']))]
        rl = pd.read_csv(os.path.join(DATA, "runs.csv")); abl = rl[(rl.split == "ablation") & (rl.status == "evaluated")]; out += [m("costL", f"{abl.spent_usd.mean():.2f}"), m("nRunsL", len(abl)), m("nViolL", int((abl.n_violations > 0).sum()))]
    except Exception as e:
        out.append(f"% recovery/ablation macros not available: {e}")
    # audit / session / post-fix macros
    try:
        import glob as _g
        ses_all = pd.read_csv(os.path.join(DATA, "sessions.csv")); out.append(m("nAllSessions", len(ses_all)))
        n_out = 0
        for f in _g.glob(os.path.join(REPO, "runs", "*", "R*", "behaviour_audit.json")):
            if (json.load(open(f)).get("n_outside_workspace_refs") or 0) > 0: n_out += 1
        out.append(m("nAuditOutside", n_out))
        rl2 = pd.read_csv(os.path.join(DATA, "runs.csv")); pf = rl2[rl2.notes.fillna("").str.contains("seed 802")]
        if len(pf) and (pf.status == "evaluated").all():
            txt = "both ended in scientific success" if (pf.scientific_success == 1).all() else f"ended in success in {int((pf.scientific_success == 1).sum())} of {len(pf)} cases"
            out.append(m("postfixROneOutcome", txt + f" (costs {', '.join(f'{x:.2f}' for x in pf.spent_usd)} USD)"))
        else:
            out.append(m("postfixROneOutcome", "were still running when this build was made"))
    except Exception as e:
        out.append(f"% audit macros not available: {e}")
    # transfer macros
    try:
        t = load_runs("transfer"); t = t[t.status == "evaluated"]
        out += [m("nTransferEval", len(t)), m("nTransferSuccess", int((t.scientific_success == 1).sum())), m("costTransferMean", f"{t.spent_usd.mean():.2f}"), m("wallTransferMed", f"{t.spent_wall_s.median()/60:.0f}")]
        for a in ARMS:
            d = t[t.treatment == a]; out += [m(f"transCost{a}", f"{d.spent_usd.mean():.2f}"), m(f"transSucc{a}", f"{int((d.scientific_success == 1).sum())}/{len(d)}")]
        g = pd.read_csv(os.path.join(DATA, "gate_receipts.csv")); gt = g[g.run_id.isin(t.run_id)]
        out += [m("nTransGateCtrlFail", int(((gt.origin == "controller") & (gt.passed == 0)).sum())), m("nTransGateCtrlPass", int(((gt.origin == "controller") & (gt.passed == 1)).sum())), m("nTransRunsGateFail", int(gt[(gt.origin.str.startswith("controller")) & (gt.passed == 0)].run_id.nunique()))]
        t1cd = t[(t.task_id == "T1-forecast") & (t.treatment.isin(["C", "D"]))]; t1ab = t[(t.task_id == "T1-forecast") & (t.treatment.isin(["A", "B"]))]
        out += [m("transTOneCostCD", f"{t1cd.spent_usd.mean():.2f}"), m("transTOneCostAB", f"{t1ab.spent_usd.mean():.2f}"), m("transTOneSessCD", f"{t1cd.n_sessions.mean():.0f}")]
    except Exception as e:
        out.append(f"% transfer macros not available: {e}")
    os.makedirs(os.path.join(REPO, "paper", "tables"), exist_ok=True)
    open(os.path.join(REPO, "paper", "tables", "numbers.tex"), "w").write("\n".join(out) + "\n"); print("\n".join(out))
if __name__ == "__main__": main()