from __future__ import annotations

import argparse
import ast
import hashlib
import json
import random
import subprocess
import sys
import tempfile
from collections import Counter
from pathlib import Path

import pyarrow.parquet as pq

from .families import FAMILIES
from .generate import GENERATOR_VERSION, VERIFIER_VERSION, _typed


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


def execute_reference(code: str, cases: list[dict], timeout: int = 3) -> None:
    with tempfile.TemporaryDirectory(prefix="oellm-code-qa-") as directory:
        solution = Path(directory) / "solution.py"
        solution.write_text(code)
        for case in cases:
            result = subprocess.run(
                [sys.executable, "-I", str(solution)],
                input=case["input"],
                text=True,
                capture_output=True,
                timeout=timeout,
                check=False,
            )
            if result.returncode != 0 or result.stdout.strip() != case["output"].strip():
                raise ValueError(f"reference execution failed: rc={result.returncode} stdout={result.stdout!r} stderr={result.stderr!r}")


def validate(root: Path, full: bool = False, execute_modulus: int = 0) -> dict:
    manifest = json.loads((root / "manifest.json").read_text())
    errors: list[str] = []
    counts, families, difficulties = Counter(), Counter(), Counter()
    seen_ids, seen_prompts = set(), set()
    regenerated = executed = 0
    sample_modulus = 1 if full else 97

    for split, info in manifest["files"].items():
        path = root / info["path"]
        if not path.exists():
            errors.append(f"missing file {path}")
            continue
        if sha256_file(path) != info["sha256"]:
            errors.append(f"checksum mismatch {path}")
        parquet = pq.ParquetFile(path)
        counts[split] = parquet.metadata.num_rows
        for batch in parquet.iter_batches(batch_size=2_000):
            for row in batch.to_pylist():
                row_id = row["id"]
                if row_id in seen_ids:
                    errors.append(f"duplicate id {row_id}")
                seen_ids.add(row_id)
                if row["prompt_sha256"] in seen_prompts:
                    errors.append(f"duplicate prompt {row_id}")
                seen_prompts.add(row["prompt_sha256"])
                if row["split"] != split:
                    errors.append(f"split mismatch {row_id}")
                if row["generator_family"] not in FAMILIES:
                    errors.append(f"unknown family {row_id}")
                    continue
                if row["generator_version"] != GENERATOR_VERSION or row["verifier_version"] != VERIFIER_VERSION:
                    errors.append(f"version mismatch {row_id}")
                if row["verifier_kind"] != "code_stdio" or row["programming_language"] != "python":
                    errors.append(f"verifier contract mismatch {row_id}")
                prompt = row["messages"][0]["content"]
                if prompt != row["problem"] or hashlib.sha256(prompt.encode()).hexdigest() != row["prompt_sha256"]:
                    errors.append(f"prompt mismatch {row_id}")
                if hashlib.sha256(row["reference_solution"].encode()).hexdigest() != row["reference_sha256"]:
                    errors.append(f"reference hash mismatch {row_id}")
                try:
                    ast.parse(row["reference_solution"])
                except SyntaxError:
                    errors.append(f"invalid reference syntax {row_id}")
                hidden = row["verification_info"]["test_cases"]
                if row["verification_info"]["language"] != "python" or len(hidden) != row["hidden_test_count"]:
                    errors.append(f"test metadata mismatch {row_id}")
                if any(t["type"] != "stdin_stdout" or not t["input"].endswith("\n") or not t["output"].endswith("\n") for t in hidden):
                    errors.append(f"invalid test case {row_id}")
                if json.loads(row["ground_truth"]) != hidden:
                    errors.append(f"ground truth mismatch {row_id}")
                if row["mutation_score"] + 1e-6 < 2 / 3:
                    errors.append(f"weak mutation score {row_id}")
                families[row["generator_family"]] += 1
                difficulties[str(row["difficulty"])] += 1

                numeric_id = int(row_id[:12], 16)
                if numeric_id % sample_modulus == 0:
                    material = FAMILIES[row["generator_family"]](random.Random(row["generation_seed"]), row["difficulty"])
                    if (
                        material.statement != prompt
                        or material.reference_solution != row["reference_solution"]
                        or json.dumps(material.parameters, sort_keys=True, separators=(",", ":")) != row["parameters_json"]
                        or _typed(material.hidden_tests) != hidden
                        or _typed(material.public_tests) != row["public_tests"]
                    ):
                        errors.append(f"regeneration mismatch {row_id}")
                    regenerated += 1
                if execute_modulus and numeric_id % execute_modulus == 0:
                    try:
                        execute_reference(row["reference_solution"], row["public_tests"] + hidden)
                        executed += 1
                    except (ValueError, subprocess.TimeoutExpired) as error:
                        errors.append(f"{row_id}: {error}")
                if len(errors) >= 100:
                    raise ValueError("validation failed with at least 100 errors:\n" + "\n".join(errors))

    if sum(counts.values()) != manifest["rows"]:
        errors.append("row total mismatch")
    if dict(sorted(families.items())) != manifest["generator_families"]:
        errors.append("family counts mismatch")
    if dict(sorted(difficulties.items())) != manifest["difficulty"]:
        errors.append("difficulty counts mismatch")
    if errors:
        raise ValueError("validation failed:\n" + "\n".join(errors))
    return {
        "rows": sum(counts.values()),
        "splits": dict(counts),
        "unique_ids": len(seen_ids),
        "unique_prompts": len(seen_prompts),
        "regenerated_rows_checked": regenerated,
        "reference_programs_executed": executed,
    }


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("root", type=Path)
    parser.add_argument("--full", action="store_true")
    parser.add_argument("--execute-modulus", type=int, default=0)
    args = parser.parse_args()
    print(json.dumps(validate(args.root, args.full, args.execute_modulus), indent=2, sort_keys=True))


if __name__ == "__main__":
    main()