"""Fail-closed executable route traces for answer-verified free-form math.

The trace is deliberately separate from the natural-language derivation and
from the boxed answer. It contains only references and operations; it never
contains model-declared intermediate results. Numeric leaves must be grounded
in the problem text, every operation is executed exactly, and every trace node
must contribute to the terminal value.

This validator establishes a checkable computational route, not a proof that
the route's modeling assumptions follow from the prose problem. Ordinary MATH
answer verification remains a separate mandatory admission condition.
"""

from __future__ import annotations

from collections import Counter
from dataclasses import dataclass
from fractions import Fraction
import json
import math
import re
from typing import Any, Mapping

import sympy


MATH_ROUTE_VERSION = "math-route-v1"
MATH_ROUTE_RPN_VERSION = "math-route-rpn-v2"
_MAX_TRACE_CHARS = 4_096
_MAX_STEPS = 20
_MAX_ARGS = 6
_MAX_INTEGER_BITS = 512
_ID_RE = re.compile(r"s[1-9][0-9]?")
_NUMBER_RE = re.compile(
    r"(?<![\w.])-?\d+(?:,\d{3})*(?:\.\d+)?(?!\w)(?!\.\d)"
)
_SLASH_FRACTION_RE = re.compile(
    r"(?<![\w.])(-?\d+(?:,\d{3})*)\s*/\s*(\d+(?:,\d{3})*)"
    r"(?!\w)(?!\.\d)"
)
_LATEX_FRACTION_RE = re.compile(
    r"\\(?:d?frac)\s*\{\s*(-?\d+(?:,\d{3})*)\s*\}"
    r"\s*\{\s*(\d+(?:,\d{3})*)\s*\}"
)
_ROUTE_BLOCK_RE = re.compile(r"<route>(.*?)</route>", re.DOTALL)
_COMMUTATIVE_OPS = frozenset({"add", "mul", "gcd", "lcm", "min", "max"})
_UNARY_OPS = frozenset(
    {"neg", "abs", "square", "cube", "sqrt", "factorial", "percent"}
)
_BINARY_OPS = frozenset(
    {"sub", "div", "pow", "mod", "choose", "permute"}
)
_NARY_OPS = frozenset({"add", "mul", "gcd", "lcm", "min", "max", "average"})
_ALLOWED_TOP_LEVEL = frozenset({"version", "steps", "final"})
_ALLOWED_STEP_KEYS = frozenset({"id", "op", "args", "value"})
_RPN_UNARY_OPS = {
    "neg": "neg",
    "abs": "abs",
    "square": "square",
    "cube": "cube",
    "sqrt": "sqrt",
    "factorial": "factorial",
    "percent": "percent",
}
_RPN_BINARY_OPS = {
    "add": "add",
    "mul": "mul",
    "sub": "sub",
    "div": "div",
    "pow": "pow",
    "mod": "mod",
    "choose": "choose",
    "permute": "permute",
    "gcd": "gcd",
    "lcm": "lcm",
    "min": "min",
    "max": "max",
    "average": "average",
}


@dataclass(frozen=True)
class MathRouteValidation:
    route_signature: str
    terminal_value: sympy.Expr
    operations: tuple[str, ...]
    step_count: int
    source_count: int


class MathRouteError(ValueError):
    """Raised for a malformed, ungrounded, or non-executable trace."""


def _fraction(text: str) -> Fraction:
    compact = str(text).replace(",", "").strip()
    if re.fullmatch(r"-?\d+", compact):
        return Fraction(int(compact), 1)
    if re.fullmatch(r"-?\d+/\d+", compact):
        numerator, denominator = compact.split("/", 1)
        if int(denominator) == 0:
            raise MathRouteError("zero denominator")
        return Fraction(int(numerator), int(denominator))
    if re.fullmatch(r"-?\d+\.\d+", compact):
        return Fraction(compact)
    raise MathRouteError("source values must be exact integers, decimals, or fractions")


def problem_number_inventory(problem: str) -> Counter[Fraction]:
    """Return exact numeric leaves present in problem text, with multiplicity."""

    text = str(problem)
    inventory: Counter[Fraction] = Counter()

    def consume_latex(match: re.Match[str]) -> str:
        numerator, denominator = match.groups()
        inventory[Fraction(int(numerator.replace(",", "")), int(denominator.replace(",", "")))] += 1
        return " "

    def consume_slash(match: re.Match[str]) -> str:
        numerator, denominator = match.groups()
        inventory[Fraction(int(numerator.replace(",", "")), int(denominator.replace(",", "")))] += 1
        return " "

    text = _LATEX_FRACTION_RE.sub(consume_latex, text)
    text = _SLASH_FRACTION_RE.sub(consume_slash, text)
    for match in _NUMBER_RE.finditer(text):
        inventory[_fraction(match.group(0))] += 1
    return inventory


def extract_math_route_block(model_response: str) -> str | None:
    matches = _ROUTE_BLOCK_RE.findall(str(model_response))
    if len(matches) != 1:
        return None
    block = matches[0].strip()
    if not block or len(block) > _MAX_TRACE_CHARS:
        return None
    return block


def _exact_integer(value: sympy.Expr, *, name: str) -> int:
    simplified = sympy.simplify(value)
    if not simplified.is_Integer:
        raise MathRouteError(f"{name} requires an exact integer")
    integer = int(simplified)
    if abs(integer).bit_length() > _MAX_INTEGER_BITS:
        raise MathRouteError(f"{name} integer is too large")
    return integer


def _bounded(value: sympy.Expr) -> sympy.Expr:
    simplified = sympy.simplify(value)
    if simplified.has(
        sympy.nan,
        sympy.zoo,
        sympy.oo,
        -sympy.oo,
        sympy.I,
    ):
        raise MathRouteError("operation produced a non-finite or complex value")
    if len(str(simplified)) > 1_024 or int(sympy.count_ops(simplified)) > 128:
        raise MathRouteError("operation result is too large")
    for atom in simplified.atoms(sympy.Integer):
        if abs(int(atom)).bit_length() > _MAX_INTEGER_BITS:
            raise MathRouteError("operation result integer is too large")
    return simplified


def _execute_operation(op: str, arguments: tuple[sympy.Expr, ...]) -> sympy.Expr:
    if op in _UNARY_OPS and len(arguments) != 1:
        raise MathRouteError(f"{op} requires one argument")
    if op in _BINARY_OPS and len(arguments) != 2:
        raise MathRouteError(f"{op} requires two arguments")
    if op in _NARY_OPS and not 2 <= len(arguments) <= _MAX_ARGS:
        raise MathRouteError(f"{op} requires two to {_MAX_ARGS} arguments")
    if op == "neg":
        result = -arguments[0]
    elif op == "abs":
        result = sympy.Abs(arguments[0])
    elif op == "square":
        result = arguments[0] ** 2
    elif op == "cube":
        result = arguments[0] ** 3
    elif op == "sqrt":
        if arguments[0].is_nonnegative is not True:
            raise MathRouteError("sqrt requires a provably nonnegative argument")
        result = sympy.sqrt(arguments[0])
    elif op == "factorial":
        integer = _exact_integer(arguments[0], name=op)
        if not 0 <= integer <= 100:
            raise MathRouteError("factorial input is outside [0,100]")
        result = sympy.factorial(integer)
    elif op == "percent":
        result = arguments[0] / 100
    elif op == "add":
        result = sum(arguments, sympy.Integer(0))
    elif op == "mul":
        result = math.prod(arguments, start=sympy.Integer(1))
    elif op == "sub":
        result = arguments[0] - arguments[1]
    elif op == "div":
        if sympy.simplify(arguments[1]) == 0:
            raise MathRouteError("division by zero")
        result = arguments[0] / arguments[1]
    elif op == "pow":
        exponent = _exact_integer(arguments[1], name=op)
        if not -12 <= exponent <= 12:
            raise MathRouteError("power exponent is outside [-12,12]")
        if arguments[0] == 0 and exponent < 0:
            raise MathRouteError("zero to a negative power")
        result = arguments[0] ** exponent
    elif op == "mod":
        left = _exact_integer(arguments[0], name=op)
        right = _exact_integer(arguments[1], name=op)
        if right == 0:
            raise MathRouteError("modulo by zero")
        result = sympy.Integer(left % right)
    elif op == "choose":
        n = _exact_integer(arguments[0], name=op)
        k = _exact_integer(arguments[1], name=op)
        if not 0 <= k <= n <= 10_000:
            raise MathRouteError("choose inputs are outside 0 <= k <= n <= 10000")
        result = sympy.binomial(n, k)
    elif op == "permute":
        n = _exact_integer(arguments[0], name=op)
        k = _exact_integer(arguments[1], name=op)
        if not 0 <= k <= n <= 1_000:
            raise MathRouteError("permute inputs are outside 0 <= k <= n <= 1000")
        result = sympy.factorial(n) / sympy.factorial(n - k)
    elif op in {"gcd", "lcm"}:
        integers = [_exact_integer(argument, name=op) for argument in arguments]
        function = math.gcd if op == "gcd" else math.lcm
        result = sympy.Integer(function(*integers))
    elif op == "min":
        if not all(argument.is_real is True for argument in arguments):
            raise MathRouteError("min requires real arguments")
        result = sympy.Min(*arguments)
    elif op == "max":
        if not all(argument.is_real is True for argument in arguments):
            raise MathRouteError("max requires real arguments")
        result = sympy.Max(*arguments)
    elif op == "average":
        result = sum(arguments, sympy.Integer(0)) / len(arguments)
    else:
        raise MathRouteError(f"unsupported route operation {op!r}")
    return _bounded(result)


def _signature(op: str, argument_signatures: tuple[str, ...]) -> str:
    children = (
        tuple(sorted(argument_signatures))
        if op in _COMMUTATIVE_OPS
        else argument_signatures
    )
    return f"{op}({','.join(children)})"


def validate_math_route_trace(
    trace: str | Mapping[str, Any],
    problem: str,
) -> MathRouteValidation | None:
    """Parse and execute a grounded route trace; return ``None`` on any failure."""

    try:
        parsed = json.loads(trace) if isinstance(trace, str) else dict(trace)
        if not isinstance(parsed, dict) or set(parsed) != _ALLOWED_TOP_LEVEL:
            raise MathRouteError("route object has missing or extra fields")
        if parsed["version"] != MATH_ROUTE_VERSION:
            raise MathRouteError("unsupported route version")
        raw_steps = parsed["steps"]
        if not isinstance(raw_steps, list) or not 2 <= len(raw_steps) <= _MAX_STEPS:
            raise MathRouteError("route has an invalid number of steps")
        final_id = str(parsed["final"])
        if _ID_RE.fullmatch(final_id) is None:
            raise MathRouteError("invalid final node ID")

        inventory = problem_number_inventory(problem)
        values: dict[str, sympy.Expr] = {}
        signatures: dict[str, str] = {}
        dependencies: dict[str, tuple[str, ...]] = {}
        operations: list[str] = []
        source_count = 0
        non_source_count = 0
        for expected_index, raw_step in enumerate(raw_steps, start=1):
            if not isinstance(raw_step, dict):
                raise MathRouteError("route step must be an object")
            if not set(raw_step).issubset(_ALLOWED_STEP_KEYS):
                raise MathRouteError("route step has extra fields")
            step_id = str(raw_step.get("id", ""))
            if step_id != f"s{expected_index}" or step_id in values:
                raise MathRouteError("route node IDs must be contiguous and ordered")
            op = str(raw_step.get("op", ""))
            if op == "source":
                if set(raw_step) != {"id", "op", "value"}:
                    raise MathRouteError("source step schema is invalid")
                value = _fraction(str(raw_step["value"]))
                if inventory[value] <= 0:
                    raise MathRouteError("source value is not available in the problem")
                inventory[value] -= 1
                values[step_id] = sympy.Rational(value.numerator, value.denominator)
                signatures[step_id] = "input"
                dependencies[step_id] = ()
                source_count += 1
                operations.append(op)
                continue

            if set(raw_step) != {"id", "op", "args"}:
                raise MathRouteError("operation step schema is invalid")
            raw_args = raw_step["args"]
            if not isinstance(raw_args, list):
                raise MathRouteError("operation args must be a list")
            argument_ids = tuple(str(argument) for argument in raw_args)
            if (
                not argument_ids
                or len(argument_ids) > _MAX_ARGS
                or len(set(argument_ids)) != len(argument_ids)
                or any(argument_id not in values for argument_id in argument_ids)
            ):
                raise MathRouteError("operation dependencies are invalid")
            arguments = tuple(values[argument_id] for argument_id in argument_ids)
            values[step_id] = _execute_operation(op, arguments)
            signatures[step_id] = _signature(
                op,
                tuple(signatures[argument_id] for argument_id in argument_ids),
            )
            dependencies[step_id] = argument_ids
            operations.append(op)
            non_source_count += 1

        if final_id not in values or non_source_count < 1 or source_count < 1:
            raise MathRouteError("route lacks a computed terminal value")
        reachable = {final_id}
        frontier = [final_id]
        while frontier:
            node = frontier.pop()
            for dependency in dependencies[node]:
                if dependency not in reachable:
                    reachable.add(dependency)
                    frontier.append(dependency)
        if reachable != set(values):
            raise MathRouteError("every route node must contribute to the final value")
        return MathRouteValidation(
            route_signature=(
                f"math-route:{MATH_ROUTE_VERSION}:{signatures[final_id]}"
            ),
            terminal_value=values[final_id],
            operations=tuple(operations),
            step_count=len(values),
            source_count=source_count,
        )
    except Exception:
        return None


def validate_math_route_rpn(
    trace: str,
    problem: str,
) -> MathRouteValidation | None:
    """Execute the compact v2 reverse-Polish route language.

    Numeric tokens are grounded problem leaves. Unary and binary operator
    tokens consume the stack, so a successful one-item terminal stack also
    proves that every emitted token contributes to the final value. The
    language has no result literals, variable names, prose, or code execution.
    """

    try:
        compact = str(trace).strip()
        if not compact or len(compact) > 1_024:
            raise MathRouteError("RPN route is empty or too long")
        tokens = compact.split()
        if not tokens or tokens[0] not in {
            "v2",
            MATH_ROUTE_RPN_VERSION,
        }:
            raise MathRouteError("unsupported RPN route version")
        tokens = tokens[1:]
        if not 2 <= len(tokens) <= 40:
            raise MathRouteError("RPN route has an invalid token count")

        inventory = problem_number_inventory(problem)
        stack: list[tuple[sympy.Expr, str]] = []
        operations: list[str] = []
        source_count = 0
        operation_count = 0
        for token in tokens:
            if token in _RPN_UNARY_OPS:
                if len(stack) < 1:
                    raise MathRouteError("RPN unary operation underflow")
                argument_value, argument_signature = stack.pop()
                op = _RPN_UNARY_OPS[token]
                stack.append(
                    (
                        _execute_operation(op, (argument_value,)),
                        _signature(op, (argument_signature,)),
                    )
                )
                operations.append(op)
                operation_count += 1
                continue
            if token in _RPN_BINARY_OPS:
                if len(stack) < 2:
                    raise MathRouteError("RPN binary operation underflow")
                right_value, right_signature = stack.pop()
                left_value, left_signature = stack.pop()
                op = _RPN_BINARY_OPS[token]
                stack.append(
                    (
                        _execute_operation(op, (left_value, right_value)),
                        _signature(op, (left_signature, right_signature)),
                    )
                )
                operations.append(op)
                operation_count += 1
                continue

            value = _fraction(token)
            if inventory[value] <= 0:
                raise MathRouteError("RPN source value is not available in the problem")
            inventory[value] -= 1
            stack.append(
                (
                    sympy.Rational(value.numerator, value.denominator),
                    "input",
                )
            )
            operations.append("source")
            source_count += 1

        if len(stack) != 1 or source_count < 1 or operation_count < 1:
            raise MathRouteError("RPN route lacks one computed terminal value")
        terminal_value, terminal_signature = stack[0]
        return MathRouteValidation(
            route_signature=(
                f"math-route:{MATH_ROUTE_RPN_VERSION}:{terminal_signature}"
            ),
            terminal_value=terminal_value,
            operations=tuple(operations),
            step_count=len(tokens),
            source_count=source_count,
        )
    except Exception:
        return None


def validate_math_route_response(
    model_response: str,
    problem: str,
) -> MathRouteValidation | None:
    """Extract the response's unique route block and execute it."""

    block = extract_math_route_block(model_response)
    if block is None:
        return None
    if block.lstrip().startswith("{"):
        return validate_math_route_trace(block, problem)
    return validate_math_route_rpn(block, problem)