#!/usr/bin/env python3
"""Dependency-free static validation for the Urusilla HF dataset pack.

This validator reads local declarative files only. It does not fetch URLs,
contact a model, execute dataset content, or authorize an external effect.
"""

from __future__ import annotations

import argparse
import hashlib
import json
import math
from pathlib import Path
import re
import sys
from typing import Any, Iterable, Mapping, Sequence


PACK_DIR = Path(__file__).resolve().parent
DATA_PATH = PACK_DIR / "data" / "challenge.jsonl"
SCHEMA_PATH = PACK_DIR / "schema.json"
CARD_PATH = PACK_DIR / "README.md"

SCHEMA_VERSION = "urusilla-hf-external-reproduction/1"
RECORD_ID = "urusilla-external-reproduction-001"
PINNED_COMMIT = "1358de54c8a7034ee057a47e252e8947fe042f55"
CAPSULE_DIGEST = (
    "588034f997fb4f3d35dfdbb68afd9232a78192ac1fa497d565f67e0892358a27"
)
CAPSULE_REF = "sha256:" + CAPSULE_DIGEST
CAPSULE_URI = (
    "https://raw.githubusercontent.com/jaden3824/urusilla/"
    f"{PINNED_COMMIT}/urusilla_capsule_v0_1.json"
)
INTEROP_URI = (
    "https://github.com/jaden3824/urusilla/blob/"
    f"{PINNED_COMMIT}/INTEROP_LAB.md"
)
SPEC_URI = (
    "https://github.com/jaden3824/urusilla/blob/"
    f"{PINNED_COMMIT}/urusilla_v0_1_spec.md"
)

TOP_LEVEL_KEYS = {
    "schema_version",
    "record_id",
    "record_type",
    "protocol",
    "known_evidence",
    "challenge",
    "safety_boundary",
    "data_governance",
}

TOKEN_LEDGER_CATEGORIES = [
    "task_input",
    "system_role",
    "agent_input_history",
    "agent_output_visible",
    "final_answer",
    "format_induction",
    "encode_decode_model",
    "negotiation_profile",
    "repair_retry",
    "tool_request",
    "tool_result",
    "safety_filter",
    "hidden_reasoning_billed",
    "unclassified",
    "total_tokens",
]

SHA256_RE = re.compile(r"^sha256:[0-9a-f]{64}$")
MAX_FILE_BYTES = 1_048_576
MAX_DEPTH = 32
MAX_NODES = 50_000
MAX_STRING_CHARS = 65_536


class ValidationError(ValueError):
    """Raised when the static pack violates its frozen contract."""


def _duplicate_rejector(pairs: Sequence[tuple[str, Any]]) -> dict[str, Any]:
    result: dict[str, Any] = {}
    for key, value in pairs:
        if key in result:
            raise ValidationError(f"duplicate JSON member: {key}")
        result[key] = value
    return result


def _resource_check(value: Any) -> None:
    stack: list[tuple[Any, int]] = [(value, 1)]
    nodes = 0
    while stack:
        current, depth = stack.pop()
        nodes += 1
        if nodes > MAX_NODES:
            raise ValidationError(f"JSON exceeds {MAX_NODES} values")
        if depth > MAX_DEPTH:
            raise ValidationError(f"JSON nesting exceeds {MAX_DEPTH}")
        if type(current) is str:
            if len(current) > MAX_STRING_CHARS:
                raise ValidationError(
                    f"JSON string exceeds {MAX_STRING_CHARS} characters"
                )
            current.encode("utf-8")
        elif type(current) is dict:
            stack.extend((key, depth + 1) for key in current)
            stack.extend((item, depth + 1) for item in current.values())
        elif type(current) is list:
            stack.extend((item, depth + 1) for item in current)
        elif type(current) is float and not math.isfinite(current):
            raise ValidationError("non-finite JSON number")


def strict_json_loads(text: str) -> Any:
    if type(text) is not str:
        raise ValidationError("JSON input must be text")
    try:
        encoded = text.encode("utf-8")
    except UnicodeError as exc:
        raise ValidationError("JSON input is not valid UTF-8 text") from exc
    if len(encoded) > MAX_FILE_BYTES:
        raise ValidationError(f"JSON exceeds {MAX_FILE_BYTES} bytes")
    try:
        value = json.loads(
            text,
            object_pairs_hook=_duplicate_rejector,
            parse_constant=lambda constant: (_ for _ in ()).throw(
                ValidationError(f"non-finite JSON number: {constant}")
            ),
        )
    except ValidationError:
        raise
    except (json.JSONDecodeError, UnicodeError, RecursionError, ValueError) as exc:
        raise ValidationError(f"invalid JSON: {exc}") from exc
    _resource_check(value)
    return value


def _read_text(path: Path) -> str:
    try:
        raw = path.read_bytes()
    except OSError as exc:
        raise ValidationError(f"cannot read {path}: {exc}") from exc
    if len(raw) > MAX_FILE_BYTES:
        raise ValidationError(f"{path} exceeds {MAX_FILE_BYTES} bytes")
    if raw.startswith(b"\xef\xbb\xbf"):
        raise ValidationError(f"{path} must not contain a UTF-8 BOM")
    try:
        return raw.decode("utf-8")
    except UnicodeDecodeError as exc:
        raise ValidationError(f"{path} is not valid UTF-8") from exc


def _object(value: Any, path: str) -> dict[str, Any]:
    if type(value) is not dict:
        raise ValidationError(f"{path} must be an object")
    return value


def _array(value: Any, path: str) -> list[Any]:
    if type(value) is not list:
        raise ValidationError(f"{path} must be an array")
    return value


def _exact_keys(value: Mapping[str, Any], expected: Iterable[str], path: str) -> None:
    wanted = set(expected)
    observed = set(value)
    if wanted != observed:
        raise ValidationError(
            f"{path} fields differ; "
            f"missing={sorted(wanted - observed)}, extra={sorted(observed - wanted)}"
        )


def _require(value: bool, message: str) -> None:
    if not value:
        raise ValidationError(message)


def _validate_card() -> None:
    text = _read_text(CARD_PATH)
    _require(text.startswith("---\n"), "README.md must start with YAML metadata")
    try:
        _, metadata, body = text.split("---\n", 2)
    except ValueError as exc:
        raise ValidationError("README.md needs a closed YAML metadata block") from exc
    required_metadata = (
        "license: apache-2.0",
        "language:\n- en",
        "pretty_name: Urusilla External Reproduction Challenge",
        "path: data/challenge.jsonl",
    )
    for item in required_metadata:
        _require(item in metadata, f"README.md metadata is missing {item!r}")
    for item in (
        "Proven general post-decode API-input token saving: **0%**",
        "only **2 of 3** receivers explicitly opted in",
        CAPSULE_URI,
        CAPSULE_DIGEST,
        INTEROP_URI,
        "No package, plugin, model weight, executable grammar, or persistent memory",
        "Private chain-of-thought is neither required nor accepted.",
    ):
        _require(item in body, f"README.md is missing required disclosure: {item!r}")


def _validate_schema() -> None:
    schema = _object(strict_json_loads(_read_text(SCHEMA_PATH)), "schema")
    _require(
        schema.get("$schema") == "https://json-schema.org/draft/2020-12/schema",
        "schema.json must declare JSON Schema draft 2020-12",
    )
    _require(schema.get("type") == "object", "schema root type must be object")
    required = schema.get("required")
    _require(
        type(required) is list and set(required) == TOP_LEVEL_KEYS,
        "schema.json required root keys must match the record contract",
    )
    properties = _object(schema.get("properties"), "schema.properties")
    _require(
        set(properties) == TOP_LEVEL_KEYS,
        "schema.json properties must match the record contract",
    )


def _validate_protocol(value: Any) -> None:
    protocol = _object(value, "protocol")
    _exact_keys(
        protocol,
        (
            "project",
            "release_tag",
            "language_version",
            "capsule_uri",
            "capsule_sha256",
            "capsule_signature_status",
            "interop_protocol_uri",
            "language_spec_uri",
            "evidence_room_uri",
        ),
        "protocol",
    )
    _require(protocol["project"] == "Urusilla", "protocol.project mismatch")
    _require(protocol["release_tag"] == "v0.1.0-experimental", "release tag mismatch")
    _require(protocol["language_version"] == "0.1.0", "language version mismatch")
    _require(protocol["capsule_uri"] == CAPSULE_URI, "Capsule URI is not pinned")
    _require(SHA256_RE.fullmatch(protocol["capsule_sha256"]) is not None, "invalid Capsule digest")
    _require(protocol["capsule_sha256"] == CAPSULE_REF, "Capsule digest mismatch")
    _require(
        protocol["capsule_signature_status"] == "unsigned-experimental",
        "unsigned Capsule must not be presented as verified",
    )
    _require(protocol["interop_protocol_uri"] == INTEROP_URI, "Interop URI mismatch")
    _require(protocol["language_spec_uri"] == SPEC_URI, "specification URI mismatch")
    _require(
        protocol["evidence_room_uri"]
        == "https://github.com/jaden3824/urusilla/discussions/6",
        "evidence room URI mismatch",
    )


def _validate_known_evidence(value: Any) -> None:
    evidence = _object(value, "known_evidence")
    _exact_keys(
        evidence,
        (
            "general_post_decode_api_input_saving_percent",
            "general_result_scope",
            "general_total_task_tokens_status",
            "same_project_pilot",
        ),
        "known_evidence",
    )
    _require(
        type(evidence["general_post_decode_api_input_saving_percent"]) in {int, float}
        and float(evidence["general_post_decode_api_input_saving_percent"]) == 0.0,
        "general post-decode saving must remain 0%",
    )
    _require(
        evidence["general_total_task_tokens_status"] == "unknown",
        "general total-task tokens must remain unknown",
    )
    pilot = _object(evidence["same_project_pilot"], "known_evidence.same_project_pilot")
    _require(
        pilot.get("classification") == "SAME-PROJECT-ORCHESTRATED",
        "pilot must not be relabeled independent",
    )
    _require(pilot.get("receivers_total") == 3, "pilot receiver count mismatch")
    _require(pilot.get("explicit_session_adoptions") == 2, "pilot adoption count mismatch")
    _require(pilot.get("explicit_adoption_failures") == 1, "pilot failure count mismatch")
    _require(
        pilot.get("valid_typed_message_generators") == 3,
        "pilot valid-message count mismatch",
    )
    _require(pilot.get("matched_raw_json_controls") is False, "pilot had no matched controls")
    _require(pilot.get("efficiency_status") == "not-measured", "pilot efficiency was not measured")


def _validate_task(value: Any) -> None:
    task = _object(value, "challenge.task")
    _exact_keys(
        task,
        (
            "task_id",
            "provenance",
            "license",
            "facts",
            "instruction",
            "observable_success_rubric",
        ),
        "challenge.task",
    )
    _require(task["provenance"] == "project-authored-synthetic", "task provenance mismatch")
    _require(task["license"] == "Apache-2.0", "task license mismatch")
    facts = _object(task["facts"], "challenge.task.facts")
    _exact_keys(facts, ("budget_usd", "network_allowed", "tie_break", "plans"), "challenge.task.facts")
    _require(facts["budget_usd"] == 1.0, "task budget mismatch")
    _require(facts["network_allowed"] is False, "network must be forbidden")
    plans = _array(facts["plans"], "challenge.task.facts.plans")
    _require(len(plans) == 2, "task must contain exactly two plans")
    observed = {plan.get("plan_id"): plan for plan in plans if type(plan) is dict}
    _require(set(observed) == {"single-pass", "double-pass"}, "plan IDs mismatch")
    _require(observed["single-pass"].get("cost_usd") == 0.2, "single-pass cost mismatch")
    _require(observed["double-pass"].get("cost_usd") == 0.7, "double-pass cost mismatch")
    for plan in plans:
        _require(plan.get("network_required") is False, "plans must require no network")
    rubric = _array(task["observable_success_rubric"], "challenge.task.observable_success_rubric")
    _require(len(rubric) == 5, "success rubric must retain all five gates")


def _validate_arms(value: Any) -> None:
    arms = _array(value, "challenge.arms")
    _require(len(arms) == 3, "exactly three matched arms are required")
    by_id: dict[str, dict[str, Any]] = {}
    for index, raw in enumerate(arms):
        arm = _object(raw, f"challenge.arms[{index}]")
        _exact_keys(
            arm,
            ("arm_id", "representation", "model_visible_payload", "constraints"),
            f"challenge.arms[{index}]",
        )
        arm_id = arm["arm_id"]
        _require(type(arm_id) is str and arm_id not in by_id, "arm IDs must be unique strings")
        _require(type(arm["model_visible_payload"]) is str and arm["model_visible_payload"], "arm payload must be nonempty")
        _require(type(arm["constraints"]) is list and arm["constraints"], "arm constraints must be nonempty")
        by_id[arm_id] = arm
    _require(set(by_id) == {"raw", "json", "urusilla"}, "required arm set mismatch")
    ordinary_json = _object(
        strict_json_loads(by_id["json"]["model_visible_payload"]),
        "json arm payload",
    )
    _require(ordinary_json.get("budget_usd") == 1.0, "JSON arm budget mismatch")
    _require(ordinary_json.get("network_allowed") is False, "JSON arm network flag mismatch")
    _require(
        {plan.get("plan_id") for plan in ordinary_json.get("plans", [])}
        == {"single-pass", "double-pass"},
        "JSON arm plan set mismatch",
    )
    urusilla_message = _object(
        strict_json_loads(by_id["urusilla"]["model_visible_payload"]),
        "Urusilla arm payload",
    )
    _require(urusilla_message.get("act") == "REQUEST", "Urusilla arm must be a REQUEST")
    _require(
        urusilla_message.get("schema")
        == "urn:urusilla:hf-challenge:budgeted-plan-selection:1",
        "Urusilla arm schema mismatch",
    )
    body = _object(urusilla_message.get("body"), "Urusilla arm body")
    _require(body.get("kind") == "goal", "Urusilla REQUEST body must be a goal")
    condition = _object(body.get("condition"), "Urusilla arm goal condition")
    _require(condition.get("kind") == "claim", "Urusilla goal condition must be a claim")
    arguments = _array(condition.get("arguments"), "Urusilla arm claim arguments")
    _require(
        {item.get("plan_id") for item in arguments if type(item) is dict and "plan_id" in item}
        == {"single-pass", "double-pass"},
        "Urusilla arm plan set mismatch",
    )
    _require(
        any(
            type(item) is dict
            and item.get("budget_usd") == 1.0
            and item.get("network_allowed") is False
            for item in arguments
        ),
        "Urusilla arm budget/network facts mismatch",
    )
    _require(
        hashlib.sha256(by_id["urusilla"]["model_visible_payload"].encode("utf-8")).hexdigest()
        == "69e7a7c75743dae42a932a89c036b76c1704b61c7e757c14829a7cf48087a6f4",
        "Urusilla arm exact payload digest mismatch",
    )
    _require("Urusilla" not in by_id["raw"]["model_visible_payload"], "raw arm leaked Urusilla induction")
    _require("Urusilla" not in by_id["json"]["model_visible_payload"], "JSON arm leaked Urusilla induction")


def _validate_design(value: Any) -> None:
    design = _object(value, "challenge.study_design")
    _require(design.get("required_arms") == ["raw", "json", "urusilla"], "study arm order contract mismatch")
    _require(design.get("same_receiver_configuration_required") is True, "receiver matching must be required")
    _require(design.get("same_task_facts_required") is True, "task matching must be required")
    _require(design.get("same_success_rubric_required") is True, "rubric matching must be required")
    _require(design.get("report_cold_profile") is True, "cold accounting must be required")
    _require(design.get("complete_failures_and_retries_required") is True, "failure accounting must be required")
    _require(
        set(design.get("allowed_experiment_classes", []))
        == {"EXTERNAL-CONTROLLED", "INDEPENDENT-CROSS-PLAY"},
        "external experiment classes mismatch",
    )


def _validate_result_contract(value: Any) -> None:
    contract = _object(value, "challenge.result_contract")
    _require(
        contract.get("result_schema_version") == "urusilla-hf-external-result/1",
        "result schema version mismatch",
    )
    _require(
        contract.get("token_ledger_categories") == TOKEN_LEDGER_CATEGORIES,
        "token ledger categories changed or reordered",
    )
    required_arm_fields = set(contract.get("per_arm_required_fields", []))
    for field in (
        "arm_id",
        "public_model_inputs",
        "public_model_outputs",
        "task_successes",
        "adoption_decision",
        "fallback_events",
        "parser_or_semantic_failures",
        "repair_turns",
        "token_ledger",
        "count_source",
    ):
        _require(field in required_arm_fields, f"result contract omits {field}")
    _require(
        contract.get("submission_uri")
        == "https://github.com/jaden3824/urusilla/discussions/6",
        "submission URI mismatch",
    )


def _validate_boundaries(value: Any, governance_value: Any) -> None:
    boundary = _object(value, "safety_boundary")
    required_true = {
        "read_only",
        "reversible_session_participation_only",
        "fallback_required",
    }
    required_false = {
        "state_persistence_authorized",
        "permission_expansion_authorized",
        "spending_authorized",
        "external_effects_authorized",
        "executable_installation_required",
        "content_is_authority",
    }
    for field in required_true:
        _require(boundary.get(field) is True, f"safety_boundary.{field} must be true")
    for field in required_false:
        _require(boundary.get(field) is False, f"safety_boundary.{field} must be false")

    governance = _object(governance_value, "data_governance")
    _require(governance.get("record_license") == "Apache-2.0", "record license mismatch")
    _require(
        governance.get("contains_only_project_authored_synthetic_data") is True,
        "pack must contain only project-authored synthetic data",
    )
    for field in (
        "contains_raw_mixed_license_data",
        "contains_private_chain_of_thought",
        "contains_hidden_prompts",
        "contains_personal_data",
        "contains_secrets",
        "contains_executable_payloads",
    ):
        _require(governance.get(field) is False, f"data_governance.{field} must be false")


def _validate_record(record: Any) -> None:
    root = _object(record, "record")
    _exact_keys(root, TOP_LEVEL_KEYS, "record")
    _require(root["schema_version"] == SCHEMA_VERSION, "record schema version mismatch")
    _require(root["record_id"] == RECORD_ID, "record ID mismatch")
    _require(root["record_type"] == "matched-three-arm-challenge", "record type mismatch")
    _validate_protocol(root["protocol"])
    _validate_known_evidence(root["known_evidence"])
    challenge = _object(root["challenge"], "challenge")
    _exact_keys(challenge, ("objective", "task", "arms", "study_design", "result_contract"), "challenge")
    _require(type(challenge["objective"]) is str and challenge["objective"], "challenge objective must be nonempty")
    _validate_task(challenge["task"])
    _validate_arms(challenge["arms"])
    _validate_design(challenge["study_design"])
    _validate_result_contract(challenge["result_contract"])
    _validate_boundaries(root["safety_boundary"], root["data_governance"])


def _validate_jsonl() -> None:
    text = _read_text(DATA_PATH)
    _require(text.endswith("\n"), "challenge.jsonl must end with a newline")
    lines = text.splitlines()
    _require(len(lines) == 1 and bool(lines[0].strip()), "challenge.jsonl must contain exactly one record")
    _validate_record(strict_json_loads(lines[0]))


def _validate_capsule(path: Path) -> None:
    try:
        raw = path.read_bytes()
    except OSError as exc:
        raise ValidationError(f"cannot read Capsule {path}: {exc}") from exc
    observed = hashlib.sha256(raw).hexdigest()
    _require(observed == CAPSULE_DIGEST, f"Capsule digest mismatch: observed {observed}")
    try:
        text = raw.decode("utf-8")
    except UnicodeDecodeError as exc:
        raise ValidationError("Capsule is not UTF-8 JSON") from exc
    capsule = _object(strict_json_loads(text), "capsule")
    _require(capsule.get("capsule_type") == "urusilla-grammar-capsule", "Capsule type mismatch")
    _require(capsule.get("capsule_version") == "0.1.0", "Capsule version mismatch")
    _require(capsule.get("release_status") == "experimental-unsigned", "Capsule status mismatch")


def validate(capsule_path: Path | None = None) -> None:
    _validate_card()
    _validate_schema()
    _validate_jsonl()
    if capsule_path is not None:
        _validate_capsule(capsule_path)


def main(argv: Sequence[str] | None = None) -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        "--capsule",
        type=Path,
        help="optional local Capsule path whose exact bytes should be hashed",
    )
    args = parser.parse_args(argv)
    try:
        validate(args.capsule)
    except ValidationError as exc:
        print(f"FAIL: {exc}", file=sys.stderr)
        return 1
    checked = "card + schema + 1 JSONL record"
    if args.capsule is not None:
        checked += " + exact local Capsule bytes"
    print(f"PASS: {checked}")
    return 0


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