"""Offline release-gate verifier for this static source/proof crosswalk."""

from __future__ import annotations

import hashlib
import json
import re
import shutil
import stat
import subprocess
import sys
import tempfile
from pathlib import Path


ALLOWLIST = {
    ".gitignore",
    "LICENSE",
    "README.md",
    "index.html",
    "evidence/claims-active.json",
    "evidence/provenance.json",
    "manifest.json",
    "pages/claims-crosswalk.md",
    "scripts/verify.py",
}
REQUIRED_TAGS = {"icml2026-repro", "paper-u4klflLAX3"}
SOURCE_ONLY_LIMIT = (
    "does not report an empirical reproduction, proof verification, "
    "author-code result, or independent execution"
)
PAPER_ARXIV_ID = "2606.06287v1"
PAPER_SOURCE_URL = "https://arxiv.org/e-print/2606.06287v1"
PAPER_SOURCE_SHA256 = "e9cbf11dfdb3b18c59235dbc1c358f1b796940170b55ff2eeb15cdb17dc97a9c"


class ReleaseGateError(RuntimeError):
    """A package failed a deterministic release-gate condition."""


def fail(message: str) -> None:
    raise ReleaseGateError(message)


def package_files(root: Path) -> list[Path]:
    if (root / ".git").exists():
        result = subprocess.run(
            ["git", "-C", str(root), "ls-files"],
            check=True,
            capture_output=True,
            text=True,
        )
        return [root / line for line in result.stdout.splitlines()]
    return sorted(
        path
        for path in root.rglob("*")
        if path.is_file() and ".git" not in path.relative_to(root).parts
    )


def read_text(path: Path) -> str:
    try:
        return path.read_text(encoding="utf-8")
    except UnicodeDecodeError as error:
        fail(f"non-text public file: {path}")
        raise AssertionError from error


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


def verify(root: Path) -> None:
    root = root.resolve()
    if not root.is_dir():
        fail(f"package root does not exist: {root}")

    relative_files = {path.relative_to(root).as_posix() for path in package_files(root)}
    unknown = sorted(relative_files - ALLOWLIST)
    missing = sorted(ALLOWLIST - relative_files)
    if unknown:
        fail(f"public-safe allowlist violation: {unknown}")
    if missing:
        fail(f"required public file missing: {missing}")

    for relative in relative_files:
        path = root / relative
        if path.stat().st_mode & stat.S_IXUSR:
            fail(f"executable payload is not allowed: {relative}")

    texts = {relative: read_text(root / relative) for relative in relative_files}
    combined = "\n".join(
        text for relative, text in texts.items() if relative != "scripts/verify.py"
    )
    forbidden_content = {
        "private path": r"/(?:Users|home)/[^/]+",
        "credential-like token": r"(?:hf|sk|api)[_-][A-Za-z0-9]{16,}",
        "unsafe HTML": r"<(?:script|iframe|object|embed)\b|\bon[a-z]+\s*=",
        "overclaimed evidence": r"\b(?:we reproduced|reproduction result|proof verified|independently verified)\b",
    }
    for label, pattern in forbidden_content.items():
        if re.search(pattern, combined, flags=re.IGNORECASE):
            fail(f"{label} detected")

    readme = texts["README.md"]
    for required in ("sdk: static", "app_file: index.html", *REQUIRED_TAGS):
        if required not in readme:
            fail(f"missing required Space metadata or tag: {required}")
    if SOURCE_ONLY_LIMIT not in re.sub(r"\s+", " ", readme):
        fail("required bounded source-only wording is absent")

    pages = sorted((root / "pages").glob("**/*.md"))
    if not pages:
        fail("at least one pages/**/*.md file is required")
    stripped_pages = re.sub(r"\s+", "", "".join(read_text(page) for page in pages))
    if len(stripped_pages) < 200:
        fail("combined stripped page content is below 200 characters")

    claims = json.loads(texts["evidence/claims-active.json"])
    if claims.get("openreview_id") != "u4klflLAX3" or len(claims.get("claims", [])) != 5:
        fail("active claim set is incomplete or points to the wrong paper")
    if claims.get("active_resolution") != "{**claims.json, **claims_anchored.json}; anchored entries overwrite legacy entries":
        fail("active claim merge statement is missing or incorrect")

    provenance = json.loads(texts["evidence/provenance.json"])
    paper = provenance.get("paper", {})
    if paper.get("arxiv_id") != PAPER_ARXIV_ID:
        fail("paper source version pin is missing or incorrect")
    if paper.get("source_url") != PAPER_SOURCE_URL:
        fail("paper source URL is not the immutable versioned URL")
    if paper.get("source_sha256") != PAPER_SOURCE_SHA256:
        fail("paper source SHA-256 does not match the versioned source URL")
    feeds = provenance.get("challenge_claim_feeds", {})
    if feeds.get("challenge_revision") != "7b5b56aebf3abe590eab9f2c241a796125cab928":
        fail("challenge revision pin is missing or incorrect")
    for feed in ("claims_json", "claims_anchored_json"):
        pin = feeds.get(feed, {})
        if not re.fullmatch(r"[0-9a-f]{64}", pin.get("sha256", "")):
            fail(f"{feed} SHA-256 pin is invalid")
        if "/resolve/7b5b56aebf3abe590eab9f2c241a796125cab928/" not in pin.get("immutable_url", ""):
            fail(f"{feed} immutable URL does not use the pinned challenge revision")
    if "anchored entries overwrite legacy entries" not in feeds.get("active_merge", ""):
        fail("judge merge rule is absent")

    manifest = json.loads(texts["manifest.json"])
    if manifest.get("allowlist") != sorted(ALLOWLIST):
        fail("manifest allowlist differs from verifier allowlist")
    manifest_hashes = manifest.get("sha256", {})
    expected_hashed = sorted(ALLOWLIST - {"manifest.json"})
    if sorted(manifest_hashes) != expected_hashed:
        fail("manifest hash coverage is incomplete")
    for relative in expected_hashed:
        if manifest_hashes[relative] != sha256(root / relative):
            fail(f"hash integrity failure: {relative}")


def self_test(root: Path) -> None:
    ignored_staging = shutil.ignore_patterns(
        ".git",
        ".source-screen",
        "__pycache__",
        "claims.json",
        "claims_anchored.json",
        "*.headers",
        "arxiv-abstract.html",
        "arxiv-source.tar",
        "judge-app.py",
        "judge-space-api.json",
        "openreview-paper.pdf",
    )
    with tempfile.TemporaryDirectory() as temporary:
        copied = Path(temporary) / "candidate"
        shutil.copytree(root, copied, ignore=ignored_staging)
        readme = copied / "README.md"
        readme.write_text(readme.read_text(encoding="utf-8").replace("paper-u4klflLAX3", "paper-missing"), encoding="utf-8")
        try:
            verify(copied)
        except ReleaseGateError as error:
            if "missing required Space metadata or tag" not in str(error):
                fail(f"tag negative check failed for the wrong reason: {error}")
        else:
            fail("tag negative check was not rejected")

    with tempfile.TemporaryDirectory() as temporary:
        copied = Path(temporary) / "candidate"
        shutil.copytree(root, copied, ignore=ignored_staging)
        manifest_path = copied / "manifest.json"
        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
        manifest["sha256"]["README.md"] = "0" * 64
        manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n", encoding="utf-8")
        try:
            verify(copied)
        except ReleaseGateError as error:
            if "hash integrity failure: README.md" not in str(error):
                fail(f"hash negative check failed for the wrong reason: {error}")
        else:
            fail("hash negative check was not rejected")

    with tempfile.TemporaryDirectory() as temporary:
        copied = Path(temporary) / "candidate"
        shutil.copytree(root, copied, ignore=ignored_staging)
        index = copied / "index.html"
        index.write_text(index.read_text(encoding="utf-8") + "<script>bad()</script>\n", encoding="utf-8")
        try:
            verify(copied)
        except ReleaseGateError as error:
            if "unsafe HTML detected" not in str(error):
                fail(f"unsafe-HTML negative check failed for the wrong reason: {error}")
        else:
            fail("unsafe-HTML negative check was not rejected")

    with tempfile.TemporaryDirectory() as temporary:
        copied = Path(temporary) / "candidate"
        shutil.copytree(root, copied, ignore=ignored_staging)
        provenance_path = copied / "evidence/provenance.json"
        provenance = json.loads(provenance_path.read_text(encoding="utf-8"))
        provenance["paper"]["source_sha256"] = "0" * 64
        provenance_path.write_text(json.dumps(provenance, indent=2) + "\n", encoding="utf-8")
        try:
            verify(copied)
        except ReleaseGateError as error:
            if "paper source SHA-256 does not match the versioned source URL" not in str(error):
                fail(f"source-provenance negative check failed for the wrong reason: {error}")
        else:
            fail("source-provenance negative check was not rejected")


def main() -> int:
    arguments = sys.argv[1:]
    root = Path(arguments[0]) if arguments and not arguments[0].startswith("-") else Path(".")
    self_test_requested = "--self-test" in arguments
    try:
        verify(root)
        if self_test_requested:
            self_test(root)
    except ReleaseGateError as error:
        print(f"FAIL: {error}")
        return 1
    print("PASS: static source/proof crosswalk release gate")
    if self_test_requested:
        print("PASS: negative checks rejected missing tag, bad manifest hash, unsafe HTML, and source-provenance mismatch")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())