#!/usr/bin/env python3
"""Check result parity and record source/dependency evidence in the active environment."""
import hashlib
import importlib
import importlib.metadata as metadata
import json
from pathlib import Path
import platform
import subprocess
import sys

from packaging.requirements import Requirement
from experiment import require

ROOT = Path(__file__).resolve().parent
VERSION = metadata.version("xarray")
SOURCE_HASHES = {
    "xarray.backends.zarr": {
        "2025.10.1": "29d00d38de7123e564aa5d3d3f459d43d8f15828c8c88c0db051fa89842d1478",
        "2026.9.0": "539e25335cece9828beb3dbd6b9f3ee3c06bbd9921da97b44affeb3506615f81",
    },
    "zarr.core.group": "abf7320e0ad38d9a601622c264163cec2f8e39cb1e0cf0c7a093e162f0ca5cc1",
    "zarr.core.array": "a9b09feaea09551a0e481b3103008b16a81654b508d9b7767a2332252d214089",
}


def digest(path):
    return hashlib.sha256(path.read_bytes()).hexdigest()


def dependency_closure():
    todo, packages = ["xarray", "zarr", "crc32c"], {}
    while todo:
        name = todo.pop()
        distribution = metadata.distribution(name)
        canonical = distribution.metadata["Name"]
        if canonical in packages:
            continue
        packages[canonical] = distribution.version
        for text in distribution.requires or []:
            requirement = Requirement(text)
            if requirement.marker and not requirement.marker.evaluate({"extra": ""}):
                continue
            require(metadata.version(requirement.name) in requirement.specifier,
                    f"Dependency mismatch: {text}")
            todo.append(requirement.name)
    return dict(sorted(packages.items(), key=lambda pair: pair[0].lower()))


def main():
    normal_path = ROOT / f"observations-{VERSION}.json"
    optimized_path = ROOT / f"optimized-{VERSION}.json"
    normal = json.loads(normal_path.read_text())
    optimized = json.loads(optimized_path.read_text())
    require(normal == optimized, "Normal and optimized outputs differ")
    rows = normal["observations"]
    require(normal["case_count"] == 84 and len(rows) == 252, "Coverage differs")
    mismatches = sum(not row["matches_documented_policy"] for row in rows)
    require(mismatches == 30, "Expected ten policy mismatches in each repetition")
    source_hashes = {}
    for module_name, reference in SOURCE_HASHES.items():
        module = importlib.import_module(module_name)
        actual = digest(Path(module.__file__))
        expected = reference[VERSION] if isinstance(reference, dict) else reference
        require(actual == expected, f"Upstream source mismatch: {module_name}")
        source_hashes[module_name] = actual
    logs = {}
    for optimized_mode in (False, True):
        command = [sys.executable] + (["-O"] if optimized_mode else []) + ["-m", "unittest", "-v"]
        completed = subprocess.run(command, cwd=ROOT, capture_output=True, text=True)
        require(completed.returncode == 0, completed.stdout + completed.stderr)
        log_name = f"tests-{VERSION}-{'optimized' if optimized_mode else 'normal'}.log"
        (ROOT / log_name).write_text(completed.stdout + completed.stderr)
        logs[log_name] = digest(ROOT / log_name)
    packages = dependency_closure()
    (ROOT / f"requirements-{VERSION}.txt").write_text(
        "".join(f"{name}=={version}\n" for name, version in packages.items())
    )
    result = {
        "python": platform.python_version(), "packages": packages,
        "cases": 84, "repetitions": 3, "observations_per_execution": 252,
        "normal_optimized_identical": True, "documented_policy_mismatches_per_repetition": 10,
        "unit_tests_per_mode": 10, "test_logs_sha256": logs,
        "upstream_source_module_sha256": source_hashes,
        "normal_output_sha256": digest(normal_path),
        "optimized_output_sha256": digest(optimized_path),
        "harness_sha256": digest(ROOT / "experiment.py"),
        "test_source_sha256": digest(ROOT / "test_experiment.py"),
        "qualification": "Reproduced known upstream issue #10269; no novelty or incidence claim.",
    }
    (ROOT / f"validation-{VERSION}.json").write_text(
        json.dumps(result, indent=2, sort_keys=True) + "\n"
    )
    print(json.dumps(result, indent=2, sort_keys=True))


if __name__ == "__main__":
    main()