#!/usr/bin/env python3
"""Validate provenance, lossless normalization and recorded benchmark structure."""
import argparse
import hashlib
import itertools
import json
import math
import statistics
import sys
from collections import Counter
from pathlib import Path

sys.dont_write_bytecode = True
from prepare_dataset import ROOT, TABLES, read_rows


def require(condition, message):
    if not condition:
        raise ValueError(message)


def hashes(root, mapping):
    for name, expected in mapping.items():
        path = root / name
        require(path.is_file(), "Missing file: " + name)
        require(hashlib.sha256(path.read_bytes()).hexdigest() == expected, "Checksum mismatch: " + name)


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--skip-release-manifest", action="store_true", help="For release assembly only")
    args = parser.parse_args()
    original = json.loads((ROOT / "research/MANIFEST_SHA256.json").read_text(encoding="utf-8"))
    hashes(ROOT / "research", original["files"])
    require({p.relative_to(ROOT / "research").as_posix() for p in (ROOT / "research").rglob("*") if p.is_file()} == set(original["files"]) | {"MANIFEST_SHA256.json"}, "Original research file set changed")
    counts = {}
    sentinel = object()
    for name, (_, expected, generator) in TABLES.items():
        count = 0
        keys = None
        for actual, source in itertools.zip_longest(read_rows(ROOT / "data" / (name + ".jsonl")), generator(), fillvalue=sentinel):
            require(actual is not sentinel and source is not sentinel and actual == source, "Lossless source comparison failed: %s row %d" % (name, count + 1))
            require(keys is None or set(actual) == keys, "Nonuniform columns: " + name)
            keys = set(actual)
            for key, value in actual.items():
                if key.endswith("_json"):
                    json.loads(value)
                if isinstance(value, float):
                    require(math.isfinite(value), "Nonfinite number: " + key)
            count += 1
        require(count == expected, "Unexpected row count: " + name)
        counts[name] = count
    measurements = list(read_rows(ROOT / "data/measurements.jsonl"))
    require(len({(r["method"], r["seed"], r["generation"]) for r in measurements}) == 4992, "Duplicate measurements")
    require({r["seed"] for r in measurements} == set(range(100, 132)), "Unexpected confirmation seeds")
    require({r["generation"] for r in measurements} == set(range(1, 13)), "Unexpected generation range")
    require(len({r["method"] for r in measurements}) == 13, "Unexpected method count")
    require(all(r["budget"] == 12000 and r["probe_total"] == 80 for r in measurements), "Probe settings changed")
    expected_final = {"full": 47.25, "full_lambda0": 47.25, "full_fixed": 7.28125, "direct_hensel": 49.0, "learned_digit_policy": 56.53125}
    actual_final = {method: statistics.mean(r["solved"] for r in measurements if r["method"] == method and r["generation"] == 12) for method in expected_final}
    require(actual_final == expected_final, "Headline results differ")
    by_key = {(r["method"], r["seed"], r["generation"]): r for r in measurements}
    for seed in range(100, 132):
        for generation in range(1, 13):
            left = by_key[("full", seed, generation)]
            right = by_key[("full_lambda0", seed, generation)]
            for key in ("solved", "spent", "strategy", "version", "memory_anchors"):
                require(left[key] == right[key], "Weight-ablation null result differs: " + key)
    inventions = list(read_rows(ROOT / "data/invention_events.jsonl"))
    require(all(r["accepted"] for r in inventions), "Recorded update acceptance changed")
    require(Counter(r["cause"] for r in inventions) == {"synthesized_digit_expression": 160, "certified_precision_doubling": 160, "certified_memory_compilation": 96}, "Unexpected update distribution")
    if not args.skip_release_manifest:
        manifest = json.loads((ROOT / "RELEASE_MANIFEST.json").read_text(encoding="utf-8"))
        require(manifest["algorithm"] == "sha256", "Unsupported manifest algorithm")
        hashes(ROOT, manifest["files"])
        actual = {p.relative_to(ROOT).as_posix() for p in ROOT.rglob("*") if p.is_file()}
        require(actual == set(manifest["files"]) | {"RELEASE_MANIFEST.json"}, "Release file set changed")
    print(json.dumps({"status": "passed", "source_checksums": "passed", "lossless_normalization": "passed", "rows": counts, "final_mean_solved": actual_final, "release_manifest": "skipped for assembly" if args.skip_release_manifest else "passed"}, indent=2))


if __name__ == "__main__":
    try:
        main()
    except (ValueError, KeyError, OSError, json.JSONDecodeError) as error:
        print("Validation failed: " + str(error), file=sys.stderr)
        raise SystemExit(1)