#!/usr/bin/env python3
"""Generate a deterministic ABI contract from sim_kinematics.h and CMake exports."""

from __future__ import annotations

import argparse
import hashlib
import json
import re
from pathlib import Path


HEADER = Path("wasm-core/include/sim_kinematics.h")
CMAKE = Path("wasm-core/CMakeLists.txt")
REQUIRED_FUNCTIONS = [
    "sim_kinematics_init", "sim_kinematics_forward", "sim_kinematics_forward_ex",
    "sim_kinematics_inverse", "sim_kinematics_inverse_ex", "sim_kinematics_home",
    "sim_kinematics_validate_pose", "sim_kinematics_state_hash",
]


def sha256(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as handle:
        for block in iter(lambda: handle.read(1024 * 1024), b""):
            digest.update(block)
    return digest.hexdigest()


def generate(root: Path, output: Path) -> dict[str, object]:
    root = root.resolve()
    header_path, cmake_path = root / HEADER, root / CMAKE
    header = header_path.read_text(encoding="utf-8")
    cmake = cmake_path.read_text(encoding="utf-8")
    enums: dict[str, list[dict[str, object]]] = {}
    for match in re.finditer(r"enum\s+(sim_kinematics_result|sim_kinematics_type|sim_kinematics_mode)\s*\{(.*?)\};", header, re.S):
        values: list[dict[str, object]] = []
        for item in match.group(2).split(","):
            item = item.strip()
            if not item:
                continue
            name, _, value = item.partition("=")
            values.append({"name": name.strip(), "value": int(value.strip()) if value.strip().lstrip("-").isdigit() else None})
        enums[match.group(1)] = values
    structs: dict[str, list[str]] = {}
    for match in re.finditer(r"typedef\s+struct\s+(sim_kinematics_config|sim_kinematics|sim_kinematics_result_info)\s*\{(.*?)\}\s*\1\s*;", header, re.S):
        structs[match.group(1)] = [re.sub(r"\s+", " ", line.strip()) for line in match.group(2).splitlines() if line.strip() and not line.strip().startswith("/*")]
    declared_functions = sorted(set(re.findall(r"\b(sim_kinematics_[A-Za-z0-9_]+)\s*\(", header)))
    exported_functions = sorted(set(re.findall(r"'_?(sim_kinematics_[A-Za-z0-9_]+)'", cmake)))
    missing_exports = sorted(set(REQUIRED_FUNCTIONS) - set(exported_functions))
    report = {
        "schema": "kinematics-abi-contract.v1", "abi_version": 1, "context_id": json.loads((root / "context-lock.json").read_text(encoding="utf-8")).get("context_id"),
        "inputs": {"header": HEADER.as_posix(), "header_sha256": sha256(header_path), "cmake": CMAKE.as_posix(), "cmake_sha256": sha256(cmake_path)},
        "enums": enums, "structs": structs, "declared_functions": declared_functions,
        "required_functions": REQUIRED_FUNCTIONS, "exported_functions": exported_functions, "missing_required_exports": missing_exports,
        "numeric_policy": {"fp_contract": "off", "fast_math": False, "nonfinite": "SIM_KIN_ERR_NONFINITE", "state_hash": "FNV-1a-64", "iteration_limit": 100000},
        "errors": {"SIM_KIN_OK": 0, "SIM_KIN_ERR_ARGUMENT": -700, "SIM_KIN_ERR_NONFINITE": -701, "SIM_KIN_ERR_RANGE": -702, "SIM_KIN_ERR_CONFIGURATION": -703, "SIM_KIN_ERR_SINGULAR": -704, "SIM_KIN_ERR_UNKNOWN_TYPE": -705, "SIM_KIN_ERR_UNSUPPORTED": -706},
        "status": "verified" if not missing_exports else "blocked",
    }
    report["contract_sha256"] = hashlib.sha256(json.dumps(report, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")).hexdigest()
    output.parent.mkdir(parents=True, exist_ok=True)
    output.write_text(json.dumps(report, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8")
    return report


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--repo-root", type=Path, default=Path(__file__).resolve().parents[1])
    parser.add_argument("--output", type=Path, default=Path("coverage/kinematics-abi-contract.json"))
    args = parser.parse_args()
    report = generate(args.repo_root, args.repo_root / args.output)
    print(f"kinematics_abi={report['status']} functions={len(report['declared_functions'])} missing_exports={len(report['missing_required_exports'])}")
    return 0 if report["status"] == "verified" else 1


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