#!/usr/bin/env python3
"""Verify the frozen OLMo iGSM-Easy Arithmetic release artifact."""

from __future__ import annotations

import hashlib
import importlib.util
import json
from collections import Counter, defaultdict
from pathlib import Path


ROOT = Path(__file__).resolve().parent
MANIFEST_PATH = ROOT / "manifest.json"
REQUIRED_FIELDS = {
    "id",
    "mod",
    "ops_mode",
    "question",
    "preamble",
    "equations",
    "query",
    "answer",
    "cot",
    "operator_table",
    "target_depth",
    "achieved_depth",
    "num_vars",
    "num_necessary",
    "num_distractors",
    "var_layer",
}


def sha256(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as stream:
        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
            digest.update(chunk)
    return digest.hexdigest()


def load_generator(path: Path):
    spec = importlib.util.spec_from_file_location("igsm_release_generator", path)
    if spec is None or spec.loader is None:
        raise RuntimeError(f"Could not import generator from {path}")
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)
    return module


def main() -> None:
    manifest = json.loads(MANIFEST_PATH.read_text(encoding="utf-8"))
    for relative_path, expected_digest in manifest["sha256"].items():
        path = ROOT / relative_path
        actual_digest = sha256(path)
        if actual_digest != expected_digest:
            raise ValueError(
                f"Checksum mismatch for {relative_path}: expected "
                f"{expected_digest}, got {actual_digest}"
            )

    data_path = ROOT / manifest["data_file"]
    generator = load_generator(ROOT / manifest["generator_file"])
    counts = Counter()
    histograms: dict[int, Counter[int]] = defaultdict(Counter)
    seen_ids = set()

    with data_path.open(encoding="utf-8") as stream:
        for line_number, line in enumerate(stream, start=1):
            if not line.strip():
                continue
            record = json.loads(line)
            missing = REQUIRED_FIELDS - record.keys()
            if missing:
                raise ValueError(f"Line {line_number} is missing fields: {sorted(missing)}")

            example_id = record["id"]
            if example_id in seen_ids:
                raise ValueError(f"Duplicate example id: {example_id}")
            seen_ids.add(example_id)

            depth = int(record["target_depth"])
            answer = int(record["answer"])
            if depth not in manifest["generation"]["depths"]:
                raise ValueError(f"Unexpected target depth {depth} in {example_id}")
            if int(record["achieved_depth"]) != depth:
                raise ValueError(f"Depth mismatch in {example_id}")
            if answer not in range(7):
                raise ValueError(f"Answer outside [0, 6] in {example_id}: {answer}")
            if record["mod"] != 7 or record["ops_mode"] != "arith":
                raise ValueError(f"Unexpected arithmetic mode in {example_id}")
            if int(record["num_distractors"]) != 0:
                raise ValueError(f"Unexpected distractors in {example_id}")

            generator.verify_record(record)
            counts[depth] += 1
            histograms[depth][answer] += 1

    if len(seen_ids) != manifest["total_examples"]:
        raise ValueError(
            f"Expected {manifest['total_examples']} examples, found {len(seen_ids)}"
        )

    for depth_text, expected in manifest["depths"].items():
        depth = int(depth_text)
        if counts[depth] != expected["count"]:
            raise ValueError(
                f"Depth {depth}: expected {expected['count']} examples, "
                f"found {counts[depth]}"
            )
        expected_histogram = {
            int(answer): count
            for answer, count in expected["answer_histogram"].items()
        }
        if dict(histograms[depth]) != expected_histogram:
            raise ValueError(
                f"Depth {depth}: expected histogram {expected_histogram}, "
                f"found {dict(histograms[depth])}"
            )

    print(
        f"Verified {len(seen_ids)} examples across depths "
        f"{sorted(counts)}; all checks passed."
    )


if __name__ == "__main__":
    main()