#!/usr/bin/env python3
"""Fail-closed validator for the native released-data DCF package."""

from __future__ import annotations

import hashlib
import json
import math
import os
import subprocess
import sys
import tempfile
from pathlib import Path


ROOT = Path(__file__).resolve().parent
COMMIT = "0b4d5487a9868a18c4f9aa5b3d96cdccc705ca97"
TREE = "74710a65e89875c1aa187420d59a9ab12b00efe4"
OLD_REPORTS = {"convergence.json", "results.json", "scope_audit.json", "summary.txt", "table_audit.json"}
NATIVE_REPORTS = {"native_pipeline.json", "official_release_audit.json"}
CALIBRATION_REPORTS = {"calibration_limit_summary.json", "calibration_limit_path.csv", "calibration_quantiles.csv", "calibration_controls.csv"}


def load(relative: str) -> object:
    return json.loads((ROOT / relative).read_text(encoding="utf-8"))


def sha256(path: Path) -> str:
    return hashlib.sha256(path.read_bytes()).hexdigest()


claims = load("official_claims.json")
matrix = load("EVIDENCE_MATRIX.json")
pins = load("SOURCE_PIN.json")
assessment = load("final_assessment.json")
native = load("outputs/native_pipeline.json")
release = load("outputs/official_release_audit.json")
calibration = load("outputs/calibration_limit_summary.json")

assert isinstance(claims, list) and len(claims) == 6
assert matrix["paper_id"] == "XfndtVLIub"
gate = matrix["release_quality_gate"]
assert gate["semantic_quality_gate_version"] == 4
assert gate["registered_claims"] == gate["supported_by_independent_evidence"] == 6
assert gate["expected_verified_points"] == 12
assert gate["literal_falsifications"] == 1
assert not gate["formula_only_support_counted"]
assert not gate["proxy_support_counted"]
assert not gate["algebraic_bound_substitution_counted"]
assert [row["literal_claim"] for row in matrix["claims"]] == claims
assert all(row["registered_system_executed"] for row in matrix["claims"])
assert all(row["paper_or_released_scale"] for row in matrix["claims"])
assert all(row["actual_model_or_dataset_used"] for row in matrix["claims"])
assert all(row["destructive_control_executed"] for row in matrix["claims"])

assert pins["repository"] == "https://github.com/NathanHitt/Differentiable_Coherent_Factuality"
assert pins["commit"] == COMMIT and pins["git_tree"] == TREE
assert len(pins["files"]) == 19
for record in pins["files"]:
    path = ROOT / "source_current" / record["path"]
    assert path.is_file(), record["path"]
    assert path.stat().st_size == record["bytes"], record["path"]
    assert sha256(path) == record["sha256"], record["path"]

assert native["paper_id"] == release["paper_id"] == "XfndtVLIub"
assert native["official_commit"] == release["official_commit"] == COMMIT
assert native["examples"] == 50 and native["claims"] == 503
assert native["nonconformity"]["evaluations"] == 50 and native["nonconformity"]["finite"]
assert native["prediction"]["node_probabilities"] == 503 and native["prediction"]["finite"]
assert native["joint_graph_destructive_control"]["ancestor_removal_l1_difference"] > 26.0
assert native["joint_graph_destructive_control"]["changed"]
assert native["gradient_witness"]["finite"]
assert native["gradient_witness"]["nonzero_norm"] > 5.0
assert not native["soft_sort_shim_used_in_reported_path"]
assert release["all_passed"]
assert release["claim1_math"]["relative_improvement_percent"] >= 141.0
assert 0 < release["claim1_math"]["coverage_shortfall_percentage_points"] < 0.5
assert release["claim1_math"]["literal_verdict"] == "falsified_as_composite_reliability_claim"
assert release["claim2_felm"]["relative_improvement_percent"] >= 60.0
assert release["claim2_felm"]["target_met"]
assert release["claim3_calibration"]["native_actual_graph_nonconformity_evaluations"] == 50
assert release["claim4_prediction"]["native_actual_graph_prediction_nodes"] == 503
assert release["claim5_agreement"]["rows"] == 10
assert release["claim5_agreement"]["cv_folds"] == 20
assert release["claim5_agreement"]["predictions_per_row"] == 14600
assert release["claim5_agreement"]["minimum_agreement"] >= 0.90
assert release["claim5_agreement"]["maximum_agreement"] == 1.0
assert release["claim6_joint_pipeline"]["end_to_end_gradient_finite_and_nonzero"]
assert calibration["status"] == "pass" and calibration["paper_id"] == "XfndtVLIub"
assert calibration["official_commit"] == COMMIT
assert calibration["execution_scope"]["graphs"] == 50
assert calibration["execution_scope"]["claim_nodes"] == 503
assert calibration["execution_scope"]["graph_temperature_evaluations"] == 450
assert calibration["execution_scope"]["quantile_evaluations"] == 135
assert calibration["theorem_contract"]["lambda_grid_span"] == 0.5
assert not calibration["theorem_contract"]["soft_sort_shim_used_in_reported_path"]
assert calibration["final_temperature_result"]["graphs_within_1e-10"] == 50
assert calibration["final_temperature_result"]["maximum_absolute_error"] < 1e-10
assert calibration["quantile_recovery"]["alphas"] == 15
assert calibration["quantile_recovery"]["final_maximum_absolute_error"] < 1e-10
assert calibration["quantile_recovery"]["order_statistic_stability_bound_holds_all_cells"]
assert calibration["destructive_controls"]["fixed_beta_8"]["graphs_changed_beyond_1e-6"] == 50
assert calibration["destructive_controls"]["fixed_beta_8"]["mean_absolute_error"] > 0.1
assert calibration["destructive_controls"]["removed_violation_penalty"]["mean_absolute_error"] > 0.1
assert all(calibration["gates"].values())
assert calibration["no_paper_scale_rerun_invented"]

assert assessment["semantic_quality_gate_version"] == 4
assert assessment["all_six_claims_supported"]
assert assessment["local_expected_verified_points"] == 12
assert assessment["native_release_execution_complete"]
assert assessment["paired_replay_byte_identical"]

expected = OLD_REPORTS | NATIVE_REPORTS | CALIBRATION_REPORTS
assert {path.name for path in (ROOT / "outputs").iterdir() if path.is_file()} == expected
assert {path.name for path in (ROOT / "packaged_replay").iterdir() if path.is_file()} == expected
for name in expected:
    assert (ROOT / "outputs" / name).read_bytes() == (ROOT / "packaged_replay" / name).read_bytes(), name

text = "\n".join(
    path.read_text(encoding="utf-8", errors="ignore")
    for path in ROOT.rglob("*")
    if path.is_file() and path.suffix in {".md", ".json", ".html", ".txt"}
)
assert all(claim in text for claim in claims)
assert "paper-XfndtVLIub" in text
assert "falsified_as_literally_registered" in text
assert "No paper-scale result was invented" in text
assert "450 graph-temperature evaluations" in text
assert "fixed beta=8" in text.lower()

env = {
    **os.environ,
    "PYTHONDONTWRITEBYTECODE": "1",
    "PYTHONHASHSEED": "0",
    "PYTHONWARNINGS": "error",
}
with tempfile.TemporaryDirectory() as tmp:
    tmp = Path(tmp)
    old = tmp / "old"
    native_first = tmp / "native_first"
    native_second = tmp / "native_second"
    subprocess.run(
        [sys.executable, str(ROOT / "reproduce.py"), "--out", str(old)],
        check=True, env=env, stdout=subprocess.DEVNULL,
    )
    assert {path.name for path in old.iterdir()} == OLD_REPORTS
    for name in OLD_REPORTS:
        assert (old / name).read_bytes() == (ROOT / "outputs" / name).read_bytes(), name
    for destination in (native_first, native_second):
        subprocess.run(
            [sys.executable, str(ROOT / "native_release_audit.py"), "--output-dir", str(destination)],
            check=True, env=env, stdout=subprocess.DEVNULL,
        )
    assert {path.name for path in native_first.iterdir()} == NATIVE_REPORTS
    assert {path.name for path in native_second.iterdir()} == NATIVE_REPORTS
    for name in NATIVE_REPORTS:
        assert (native_first / name).read_bytes() == (native_second / name).read_bytes(), name
        assert (native_first / name).read_bytes() == (ROOT / "outputs" / name).read_bytes(), name
    calibration_first = tmp / "calibration_first"
    calibration_second = tmp / "calibration_second"
    for destination in (calibration_first, calibration_second):
        subprocess.run(
            [sys.executable, str(ROOT / "calibration_limit_audit.py"), "--source-root", str(ROOT), "--output-dir", str(destination)],
            check=True, env=env, stdout=subprocess.DEVNULL,
        )
    assert {path.name for path in calibration_first.iterdir()} == CALIBRATION_REPORTS
    assert {path.name for path in calibration_second.iterdir()} == CALIBRATION_REPORTS
    for name in CALIBRATION_REPORTS:
        assert (calibration_first / name).read_bytes() == (calibration_second / name).read_bytes(), name
        assert (calibration_first / name).read_bytes() == (ROOT / "outputs" / name).read_bytes(), name

print(json.dumps({
    "status": "pass",
    "paper_id": "XfndtVLIub",
    "claims_supported": 6,
    "literal_falsifications": [1],
    "local_expected_verified_points": 12,
    "official_commit": COMMIT,
    "actual_math_graphs": 50,
    "actual_claim_nodes": 503,
    "released_prediction_comparisons": 146000,
    "ancestor_control_l1": native["joint_graph_destructive_control"]["ancestor_removal_l1_difference"],
    "gradient_norm": native["gradient_witness"]["nonzero_norm"],
    "calibration_graph_temperature_evaluations": 450,
    "calibration_final_max_error": calibration["final_temperature_result"]["maximum_absolute_error"],
    "calibration_quantiles_recovered": 15,
    "paired_warning_strict_replay": "byte_identical",
}, sort_keys=True))