from __future__ import annotations

import hashlib
import json
from pathlib import Path
from typing import Any

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


def read_json(path: Path) -> dict[str, Any]:
    return json.loads(path.read_text(encoding="utf-8"))


def validate_formal_run(
    root: Path,
    *,
    formal_config_path: Path,
    tasks_path: Path,
    split_path: Path,
    prompt_protocol: str,
    metric_feedback_mode: str,
    hide_iou_feedback: bool,
    stagnation_patience: int,
    max_tokens: int,
    timeout_seconds: int,
    history_window: int,
    include_history_cot: bool,
    legacy_stop_as_success: bool,
    api_temperature: float,
    api_seed: int,
    display_size: tuple[int, int],
) -> dict[str, Any]:
    config = read_json(formal_config_path)
    protocol = config["protocol"]
    run = config["run"]
    expected = {
        "prompt_protocol": protocol["prompt_protocol"],
        "metric_feedback_mode": protocol["metric_feedback_mode"],
        "hide_iou_feedback": bool(protocol["hide_iou_feedback"]),
        "stagnation_patience": int(run["stagnation_patience"]),
        "max_tokens": int(run["max_tokens"]),
        "timeout_seconds": int(run["timeout_seconds"]),
        "history_window": int(protocol["history_window"]),
        "include_history_cot": bool(protocol["include_history_cot"]),
        "api_temperature": float(run["temperature"]),
        "api_seed": int(run["api_seed"]),
        "display_size": (
            int(config["renderer"]["api_display_width"]),
            int(config["renderer"]["api_display_height"]),
        ),
    }
    actual = {
        "prompt_protocol": prompt_protocol,
        "metric_feedback_mode": metric_feedback_mode,
        "hide_iou_feedback": hide_iou_feedback,
        "stagnation_patience": stagnation_patience,
        "max_tokens": max_tokens,
        "timeout_seconds": timeout_seconds,
        "history_window": history_window,
        "include_history_cot": include_history_cot,
        "api_temperature": float(api_temperature),
        "api_seed": int(api_seed),
        "display_size": tuple(int(value) for value in display_size),
    }
    mismatches = {key: {"expected": expected[key], "actual": actual[key]} for key in expected if expected[key] != actual[key]}
    if mismatches or legacy_stop_as_success:
        raise RuntimeError(f"Formal protocol mismatch: {mismatches or {'legacy_stop_as_success': True}}")

    canonical_expected = str(config["dataset"]["canonical_tasks_sha256"])
    if sha256_file(tasks_path) != canonical_expected:
        raise RuntimeError("Canonical tasks SHA-256 mismatch")
    split = read_json(split_path)
    split_ids = [str(value) for value in split.get("sample_ids", [])]
    if len(split_ids) != len(set(split_ids)) or not split_ids:
        raise RuntimeError("Split must contain unique task IDs")
    canonical_ids = {
        str(json.loads(line)["sample_id"])
        for line in tasks_path.read_text(encoding="utf-8").splitlines()
        if line.strip()
    }
    if not set(split_ids).issubset(canonical_ids):
        raise RuntimeError("Split contains IDs outside the canonical tasks file")
    expected_split_hash = str(config["dataset"]["test_ids_sha256"])
    if sha256_file(split_path) != expected_split_hash:
        raise RuntimeError("Formal test split SHA-256 mismatch")
    if str(split.get("split_name", "")) != "test" or len(split_ids) != int(config["dataset"]["test_task_count"]):
        raise RuntimeError("Formal run must use the frozen 100-task test split")

    return {
        "status": "passed",
        "formal_config": str(formal_config_path.relative_to(root)).replace("\\", "/"),
        "split_file": str(split_path.relative_to(root)).replace("\\", "/"),
        "split_name": str(split.get("split_name", "")),
        "task_count": len(split_ids),
        "canonical_tasks_sha256": canonical_expected,
        "split_sha256": sha256_file(split_path),
        "protocol": actual,
    }