"""Offline release integrity, provenance and schema checks (standard library)."""
from pathlib import Path
import hashlib
import importlib.util
import json
import math
import re
import shutil
import sys
import tempfile

REPO = Path(__file__).resolve().parents[1]
# Keep verification from adding bytecode files to the exact upload inventory.
sys.dont_write_bytecode = True


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


def validate(repo=REPO):
    repo = Path(repo).resolve()
    manifest = json.loads((repo / "MANIFEST.json").read_text(encoding="utf-8"))
    assert manifest["project_id"] == "orielith9"
    entries = manifest["files"]
    expected_paths = {entry["path"] for entry in entries}
    assert len(expected_paths) == len(entries), "Duplicate manifest paths"
    actual_paths = {p.relative_to(repo).as_posix() for p in repo.rglob("*")
                    if p.is_file() and p.name != "MANIFEST.json" and "__pycache__" not in p.parts}
    assert actual_paths == expected_paths, "Repository inventory differs from manifest"
    for entry in entries:
        path = repo / entry["path"]
        assert not path.is_symlink() and repo in path.resolve().parents
        assert path.stat().st_size == entry["bytes"], f"Size mismatch: {entry['path']}"
        assert sha256(path) == entry["sha256"], f"Checksum mismatch: {entry['path']}"
    research = repo / "research"
    for line in (research / "SHA256SUMS.txt").read_text(encoding="utf-8").splitlines():
        digest, name = line.split("  ", 1)
        assert sha256(research / name) == digest, f"Source release checksum mismatch: {name}"

    schema = json.loads((repo / "dataset_schema.json").read_text(encoding="utf-8"))
    assert schema["experimental_records"] == 0
    card = (repo / "README.md").read_text(encoding="utf-8")
    assert card.startswith("---\n") and "\n---\n" in card
    metadata = card.split("\n---\n", 1)[0]
    names = re.findall(r"^  - config_name: ([a-z_]+)$", metadata, re.M)
    paths = re.findall(r"^        path: (data/[^\s]+)$", metadata, re.M)
    assert set(names) == set(schema["configs"]) and len(names) == len(schema["configs"])
    assert paths == [schema["configs"][name]["path"] for name in names]
    assert metadata.count("default: true") == 1
    ids = set()
    total = 0
    for name, config in schema["configs"].items():
        rows = [json.loads(line) for line in (repo / config["path"]).read_text(encoding="utf-8").splitlines()]
        assert len(rows) == config["rows"]
        total += len(rows)
        for row in rows:
            assert {key: type(value).__name__ for key, value in row.items()} == config["fields"], name
            assert row["id"] not in ids
            ids.add(row["id"])
            assert (repo / row["source_path"]).is_file()
            assert row["evidence_status"]
            assert all(math.isfinite(value) for value in row.values() if isinstance(value, float))
            if name == "design_parameters":
                json.loads(row["value_json"])
            if name == "reference_model":
                assert abs(row["true_tether_extension"] - row["reconstructed_tether_extension"]) < 1e-12
        if name == "layers":
            assert sum(row["thickness_um"] for row in rows) == 1600
    assert total == 297

    # Rebuild all transforms in a disposable directory, keeping original bytes intact.
    spec = importlib.util.spec_from_file_location("orielith_build", repo / "tools/build_dataset.py")
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)
    with tempfile.TemporaryDirectory(prefix="orielith-data-check-") as tmp:
        target = Path(tmp)
        shutil.copytree(research, target / "research")
        module.build_data(target)
        for rel in ["dataset_schema.json"] + [cfg["path"] for cfg in schema["configs"].values()]:
            assert (target / rel).read_bytes() == (repo / rel).read_bytes(), f"Nonreproducible transform: {rel}"

    for filename in ("README.md", "DATA_DICTIONARY.md", "RIGHTS.md"):
        text = (repo / filename).read_text(encoding="utf-8")
        for destination in re.findall(r"\]\(([^)]+)\)", text):
            if "://" in destination or destination.startswith("#"):
                continue
            assert (repo / destination.split("#")[0]).exists(), f"Broken link in {filename}: {destination}"
    return {"status": "passed", "project_id": manifest["project_id"],
            "repository_files": len(entries) + 1, "configurations": len(schema["configs"]),
            "records": total, "experimental_measurement_records": 0,
            "checks": ["repository inventory and SHA256", "original release SHA256",
                       "dataset metadata and primitive schemas", "provenance and deterministic IDs",
                       "finite model values and reconstruction residual", "nominal layer sum",
                       "byte-reproducible source transformations", "relative documentation links"]}


if __name__ == "__main__":
    print(json.dumps(validate(), indent=2))