#!/usr/bin/env python3
"""Recompute the manuscript's argument counts from archived per-item records.

This checks response scoring and archived finite-study outcomes. It does not
rerun inference, construct witnesses, or repeat the finite solvers.
"""
import argparse
from collections import Counter
import gzip
import json
from pathlib import Path

from analyze_visual_judges import number, valid_parsed


def records(path):
    opener = gzip.open if path.suffix == ".gz" else open
    with opener(path, "rt") as handle:
        return [json.loads(line) for line in handle if line.strip()]


def check(inputs, finite_path, solver_path):
    labels = json.loads((inputs / "plotqa/labels.json").read_text())
    by_id = {row["item_id"]: row for row in labels}
    responses = records(inputs / "plotqa/qwen38-flash-next.jsonl.gz")
    assert len(labels) == len(by_id) == len(responses) == 5000
    ids = [row["item_id"] for row in responses]
    assert len(set(ids)) == 5000 and set(ids) == set(by_id)
    counts = dict(correct=0, rejected=0, numeric_mismatch=0, unparsed=0, invalid=0)
    for row in responses:
        label = by_id[row["item_id"]]
        if not label["answerable"]:
            continue
        parsed = valid_parsed(row)
        if parsed is None:
            category = "invalid"
        elif not parsed["answerable"]:
            category = "rejected"
        elif number(parsed["answer"]) is None:
            category = "unparsed"
        elif number(parsed["answer"]) == number(label["target"]):
            category = "correct"
        else:
            category = "numeric_mismatch"
        counts[category] += 1
    assert counts == dict(correct=2473, rejected=49, numeric_mismatch=478,
                          unparsed=0, invalid=0), counts

    finite = records(finite_path)
    assert len({row["id"] for row in finite}) == len(finite) == 1024
    assert all(row["source_checks_passed"] and row["oracle_agreement"] for row in finite)
    finite_counts = dict(
        cases=len(finite),
        ambiguous=sum(row["oracle_ambiguous"] for row in finite),
        constant=sum(not row["oracle_ambiguous"] for row in finite),
        dependency_false_missing=sum(row["dependency_cut_claims_missing"]
                                     and not row["oracle_ambiguous"] for row in finite),
        endpoint_missed_ambiguity=sum(not row["endpoint_separates"]
                                     and row["oracle_ambiguous"] for row in finite),
        archived_proofs_verified=sum(row["proof_verified"] is True for row in finite),
    )
    assert finite_counts == dict(cases=1024, ambiguous=610, constant=414,
                                 dependency_false_missing=132,
                                 endpoint_missed_ambiguity=90,
                                 archived_proofs_verified=610), finite_counts
    solver = records(solver_path)
    assert len({(row["cohort"], row["id"]) for row in solver}) == len(solver) == 1456
    assert all(row["source_checks_passed"] for row in solver)
    assert all(row["truth"] == row["smt_status"] == row["enumeration_status"]
               for row in solver)
    solver_counts = Counter(row["truth"] for row in solver)
    assert dict(solver_counts) == dict(ambiguous=822, constant=634), solver_counts
    finite_truth = {row["id"]: "ambiguous" if row["oracle_ambiguous"] else "constant"
                    for row in finite}
    original_solver = {row["id"]: row["truth"] for row in solver if row["cohort"] == "original"}
    assert original_solver == finite_truth
    assert sum(row["dependency_false_missing"] for row in solver) == 225
    return {
        "status": "passed",
        "source": "archived per-response and per-case records",
        "qwen_positive_chart_views": counts,
        "finite_program_cases": finite_counts,
        "enumeration_smt_record_agreement": {
            "cases": len(solver), **dict(solver_counts), "dependency_false_missing": 225
        },
        "inference_calls": 0,
        "solvers_rerun": False,
        "proof_archive_replayed_by_this_command": False,
        "interpretation": (
            "Numeric mismatches remain task errors; no cause adjudication is inferred. "
            "Finite shortcut counts describe the author-generated distribution, "
            "not external annotation accuracy."
        ),
    }


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--inputs", type=Path, required=True)
    parser.add_argument("--finite-results", type=Path, required=True)
    parser.add_argument("--solver-results", type=Path, required=True)
    parser.add_argument("--output", type=Path, required=True)
    args = parser.parse_args()
    result = check(args.inputs, args.finite_results, args.solver_results)
    args.output.parent.mkdir(parents=True, exist_ok=True)
    args.output.write_text(json.dumps(result, indent=2) + "\n")
    print(json.dumps(result))