from __future__ import annotations

import argparse
import json
from pathlib import Path

from eval_answer_utils import answers_match, extract_final_answer, has_final_marker


SOURCE_RESULTS = "runs/20260407T195053Z_aime60_qwen3_reasoning/results.jsonl"
MODES = ("english", "lojban")


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser()
    parser.add_argument("--out-dir", required=True)
    return parser.parse_args()


def load_jsonl(path: Path) -> list[dict[str, object]]:
    return [json.loads(line) for line in path.read_text().splitlines() if line.strip()]


def mode_record(record: dict[str, object]) -> dict[str, object]:
    raw_output = str(record["raw_output"])
    predicted = extract_final_answer(raw_output)
    return {
        "predicted_answer": predicted,
        "correct": answers_match(predicted, str(record["gold_answer"])),
        "has_final_marker": has_final_marker(raw_output),
        "raw_chars": len(raw_output),
        "wait_count": raw_output.lower().count("wait"),
        "stored_predicted_answer": record["predicted_answer"],
        "stored_correct": record["correct"],
        "stored_has_final_marker": record["has_final_marker"],
    }


def load_paired_records() -> dict[str, dict[str, dict[str, object]]]:
    paired: dict[str, dict[str, dict[str, object]]] = {}
    for record in load_jsonl(Path(SOURCE_RESULTS)):
        mode = str(record["mode"])
        if mode in MODES:
            problem_id = str(record["id"])
            paired.setdefault(problem_id, {})[mode] = {**record, **mode_record(record)}
    return {key: value for key, value in paired.items() if all(mode in value for mode in MODES)}


def choose_shorter_final(records: dict[str, dict[str, object]]) -> str:
    english = records["english"]
    lojban = records["lojban"]
    if (
        english["has_final_marker"]
        and (
            not lojban["has_final_marker"]
            or int(english["raw_chars"]) < int(lojban["raw_chars"])
        )
    ):
        return "english"
    return "lojban"


def evaluate(records_by_id: dict[str, dict[str, dict[str, object]]]) -> list[dict[str, object]]:
    rows = []
    for problem_id in sorted(records_by_id):
        records = records_by_id[problem_id]
        selected_mode = choose_shorter_final(records)
        selected = records[selected_mode]
        gold = str(selected["gold_answer"])
        rows.append(
            {
                "id": problem_id,
                "gold_answer": gold,
                "selected_mode": selected_mode,
                "selected_answer": selected["predicted_answer"],
                "correct": selected["correct"],
                "oracle_correct": any(bool(records[mode]["correct"]) for mode in MODES),
                "modes": {
                    mode: {
                        "predicted_answer": records[mode]["predicted_answer"],
                        "correct": records[mode]["correct"],
                        "has_final_marker": records[mode]["has_final_marker"],
                        "raw_chars": records[mode]["raw_chars"],
                        "wait_count": records[mode]["wait_count"],
                    }
                    for mode in MODES
                },
            }
        )
    return rows


def score(rows: list[dict[str, object]]) -> int:
    return sum(bool(row["correct"]) for row in rows)


def mode_scores(rows: list[dict[str, object]]) -> dict[str, int]:
    return {mode: sum(bool(row["modes"][mode]["correct"]) for row in rows) for mode in MODES}


def summarize(rows: list[dict[str, object]]) -> dict[str, object]:
    first30 = rows[:30]
    last30 = rows[30:]
    selected_counts = {
        mode: sum(row["selected_mode"] == mode for row in rows) for mode in MODES
    }
    return {
        "policy": "prefer_lojban_unless_english_has_final_marker_and_shorter_output",
        "correct": score(rows),
        "total": len(rows),
        "accuracy": score(rows) / len(rows),
        "first30_correct": score(first30),
        "last30_correct": score(last30),
        "oracle_correct": sum(bool(row["oracle_correct"]) for row in rows),
        "first30_oracle_correct": sum(bool(row["oracle_correct"]) for row in first30),
        "last30_oracle_correct": sum(bool(row["oracle_correct"]) for row in last30),
        "mode_scores": mode_scores(rows),
        "first30_mode_scores": mode_scores(first30),
        "last30_mode_scores": mode_scores(last30),
        "selected_counts": selected_counts,
        "source_results": SOURCE_RESULTS,
    }


def main() -> None:
    args = parse_args()
    rows = evaluate(load_paired_records())
    summary = summarize(rows)

    out_dir = Path(args.out_dir)
    out_dir.mkdir(parents=True, exist_ok=True)
    with (out_dir / "results.jsonl").open("w") as handle:
        for row in rows:
            handle.write(json.dumps(row, ensure_ascii=False) + "\n")
    (out_dir / "summary.json").write_text(
        json.dumps(summary, indent=2, ensure_ascii=False) + "\n"
    )
    print(json.dumps(summary, indent=2, ensure_ascii=False))


if __name__ == "__main__":
    main()