"""Check the threshold behavior of a published pion-scattering mesh using Python 3."""
import argparse
import ast
import hashlib
import io
import json
import math
from pathlib import Path
import struct
import zipfile

SOURCE = "arXiv:2608.23750v1"
DOI = "10.5281/zenodo.22016314"
ARCHIVE_SHA = "2ea54c22bc2d293ad1026198898b8e7c73c9b0a7248918606eafa745415c8c21"
REVISION = "91b1ece3543aba0d6d783c6142c388e71437d903"
MASS_MEV = 139.57
ENERGIES = [280.0, 280.5, 281.0]
WAVES = ("S0", "S2")
FILES = {
    "ensemble_median.npz": "7eb40ba8a832d7fb35398f57f7969b220d78743de6e0bef9de335b1d4699f496",
    "ensemble_ci68.npz": "2efba9bd9b052a6e06e4c4959f1faccff3bb219060284c77a39c0256658e5a55",
    "model_seed_1000066975.npz": "79991a3876414e256a698a13e32ffa4266055e01d4a087845fb323b0b13aae12",
    "model_seed_1962540218.npz": "79011242b268a6f6d55f3cb27fbd23184c9309231068d9d677b3bcbc6ef897e9",
    "model_seed_999843098.npz": "b4ee12d0b9aff26075189d302e24ba53a43616fa01bd94d668788cfbde921b55",
}
# Table IV: median and the endpoints of the printed central 68% interval.
TABLE = {"S0": (0.222, [0.208, 0.236]), "S2": (-0.041, [-0.047, -0.036])}


def read_first_three(archive, key):
    item = archive.getinfo(key + ".npy")
    if item.file_size > 21_000:
        raise ValueError("Unexpected NPY size for " + key)
    raw = archive.read(item)
    if raw[:8] != b"\x93NUMPY\x01\x00":
        raise ValueError("Expected NPY v1 numeric vector for " + key)
    start = 10 + int.from_bytes(raw[8:10], "little")
    if start > 512 or len(raw) != start + 2441 * 8:
        raise ValueError("Unexpected vector length for " + key)
    header = ast.literal_eval(raw[10:start].decode("ascii"))
    if header != {"descr": "<f8", "fortran_order": False, "shape": (2441,)}:
        raise ValueError("Unexpected vector format for " + key)
    return list(struct.unpack_from("<3d", raw, start))


def extract(folder):
    """Read only known, hash-pinned float vectors. The other members stay unopened."""
    inputs = {
        "attribution": "Wyatt A. Smith, Production SINN ensemble for pion scattering (2026), CC BY 4.0. Selected and restructured grid values.",
        "license": "https://creativecommons.org/licenses/by/4.0/",
        "doi": DOI, "gitCommit": REVISION, "energyMeV": ENERGIES,
        "summaries": {}, "replicas": {},
    }
    for name, digest in FILES.items():
        path = folder / name
        if path.stat().st_size > 600_000:
            raise ValueError("Unexpected mesh file size for " + name)
        raw = path.read_bytes()
        if hashlib.sha256(raw).hexdigest() != digest:
            raise ValueError("Content digest mismatch for " + name)
        with zipfile.ZipFile(io.BytesIO(raw)) as archive:
            if read_first_three(archive, "energy_mev") != ENERGIES:
                raise ValueError("Unexpected energy grid in " + name)
            if name.startswith("ensemble"):
                columns = ["median"] if "median" in name else ["lower", "upper"]
                for wave in WAVES:
                    summary = inputs["summaries"].setdefault(wave, {})
                    for col in columns:
                        suffix = "" if col == "median" else "_" + col
                        summary[col] = read_first_three(archive, wave + "_partial_wave_re" + suffix)
            else:
                seed = name.removeprefix("model_seed_").removesuffix(".npz")
                inputs["replicas"][seed] = {
                    wave: {key: read_first_three(archive, wave + "_" + key)
                           for key in ("phase_deg", "inelasticity", "partial_wave_re")}
                    for wave in WAVES
                }
    return inputs


def intercept(values, second):
    xs = [energy**2 / 4 - MASS_MEV**2 for energy in ENERGIES]
    return values[0] - xs[0] * (values[second] - values[0]) / (xs[second] - xs[0])


def check(inputs):
    waves = []
    for wave in WAVES:
        series = inputs["summaries"][wave]
        median = intercept(series["median"], 1)
        published, interval = TABLE[wave]
        waves.append({
            "wave": wave, "paperMedian": published, "paper68": interval,
            "meshMedianProxy": round(median, 12),
            "meshMedianWide": round(intercept(series["median"], 2), 12),
            "meshBandEdgeProxies": [round(intercept(series[key], 1), 12) for key in ("lower", "upper")],
            "insidePaper68": interval[0] <= median <= interval[1],
        })

    tolerance = 1e-12
    residuals = []
    degree_failures = 0
    for replica in inputs["replicas"].values():
        for wave in WAVES:
            values = replica[wave]
            for i, energy in enumerate(ENERGIES):
                rho = math.sqrt(1 - (2 * MASS_MEV / energy)**2)
                eta = values["inelasticity"][i]
                degrees = values["phase_deg"][i]
                stored = values["partial_wave_re"][i]
                real_part = eta * math.sin(2 * math.radians(degrees)) / (2 * rho)
                residuals.append(abs(real_part - stored))
                wrong_units = eta * math.sin(2 * degrees) / (2 * rho)
                degree_failures += abs(wrong_units - stored) > tolerance
    passed = (inputs["energyMeV"] == ENERGIES and len(residuals) == 18
              and max(residuals) < tolerance and degree_failures == len(residuals)
              and all(row["insidePaper68"] for row in waves))
    return {
        "status": "passed" if passed else "failed", "source": SOURCE,
        "archiveDoi": DOI, "archiveSha256": ARCHIVE_SHA, "releaseCommit": REVISION,
        "thresholdMeV": 2 * MASS_MEV, "energyMeV": ENERGIES,
        "waves": waves, "normalization": {
            "replicas": len(inputs["replicas"]), "comparisons": len(residuals),
            "tolerance": tolerance, "maxAbsResidual": float(f"{max(residuals):.2g}"),
            "degreeMistakeFailures": degree_failures,
        },
    }


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--from-mesh", type=Path, metavar="DIR",
                        help="re-extract the bundled input values from five original NPZ files in DIR")
    args = parser.parse_args()
    snapshot = Path(__file__).with_name("inputs.json")
    bundled = json.loads(snapshot.read_text(encoding="utf-8"))
    if args.from_mesh:
        derived = extract(args.from_mesh)
        if derived != bundled:
            raise SystemExit("Extracted release values differ from the bundled inputs")
    result = check(bundled)
    print(json.dumps(result, indent=2))
    raise SystemExit(0 if result["status"] == "passed" else 1)
