"""Safe expression language (TZ 2.3.7, 2.4.3): lexer + Pratt parser producing tuple AST.

The AST is made only of builtin types (tuples/str/bool/None) so it can be stored in a marshal render plan.
No Python evaluation primitives (eval/exec/compile) are used anywhere.

AST node forms::

    ("num", "1.5")                 number literal (kept as text, evaluated as Decimal)
    ("str", "text")                string literal
    ("const", True|False|None)     true / false / null
    ("path", ("client", "items", 0, "title"))
    ("list", (expr, ...))          array literal
    ("index", base, expr)          computed index or key: palette[loop.index0 % 4]
    ("un", "!"|"-", expr)
    ("bin", op, left, right)       op in == != < <= > >= in + - * / %
    ("and", left, right) / ("or", left, right)
    ("cond", test, then, else)
    ("filter", name, expr, (arg, ...))
"""

from __future__ import annotations

import re
from typing import Any

Ast = tuple[Any, ...]


class ExprSyntaxError(ValueError):
    def __init__(self, message: str, source: str, pos: int) -> None:
        super().__init__(f"{message} at {pos} in {source!r}")
        self.source = source
        self.pos = pos


_TOKEN_RE = re.compile(
    r"""
    (?P<ws>\s+)
  | (?P<num>\d+(?:\.\d+)?)
  | (?P<str>"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')
  | (?P<ident>[A-Za-z_À-￿][A-Za-z0-9_À-￿]*)
  | (?P<op>==|!=|>=|<=|&&|\|\||[-+*/%<>!?:()\[\].|,])
    """,
    re.VERBOSE,
)

_KEYWORDS = {"true": ("const", True), "false": ("const", False), "null": ("const", None)}
_WORD_OPS = {"and": "&&", "or": "||", "not": "!", "in": "in"}

# Binding powers for infix operators.
_INFIX_BP = {
    "?": 1,
    "||": 2,
    "&&": 3,
    "==": 4,
    "!=": 4,
    "<": 5,
    "<=": 5,
    ">": 5,
    ">=": 5,
    "in": 5,
    "+": 6,
    "-": 6,
    "*": 7,
    "/": 7,
    "%": 7,
    "|": 9,
}
_UNARY_BP = 8
_FILTER_ARG_BP = 9


def _unescape(raw: str) -> str:
    body = raw[1:-1]
    out: list[str] = []
    i = 0
    while i < len(body):
        ch = body[i]
        if ch == "\\" and i + 1 < len(body):
            nxt = body[i + 1]
            out.append({"n": "\n", "t": "\t"}.get(nxt, nxt))
            i += 2
            continue
        out.append(ch)
        i += 1
    return "".join(out)


def tokenize(source: str) -> list[tuple[str, Any, int]]:
    tokens: list[tuple[str, Any, int]] = []
    pos = 0
    while pos < len(source):
        m = _TOKEN_RE.match(source, pos)
        if not m:
            raise ExprSyntaxError("Unexpected character", source, pos)
        kind = m.lastgroup or ""
        text = m.group()
        if kind == "num":
            tokens.append(("num", text, pos))
        elif kind == "str":
            tokens.append(("str", _unescape(text), pos))
        elif kind == "ident":
            if text in _KEYWORDS:
                tokens.append(("kw", text, pos))
            elif text in _WORD_OPS:
                tokens.append(("op", _WORD_OPS[text], pos))
            else:
                tokens.append(("ident", text, pos))
        elif kind == "op":
            tokens.append(("op", text, pos))
        pos = m.end()
    tokens.append(("eof", None, len(source)))
    return tokens


class _Parser:
    def __init__(self, source: str) -> None:
        self.source = source
        self.tokens = tokenize(source)
        self.i = 0

    def peek(self) -> tuple[str, Any, int]:
        return self.tokens[self.i]

    def next(self) -> tuple[str, Any, int]:
        tok = self.tokens[self.i]
        self.i += 1
        return tok

    def expect_op(self, op: str) -> None:
        kind, val, pos = self.next()
        if kind != "op" or val != op:
            raise ExprSyntaxError(f"Expected {op!r}", self.source, pos)

    def parse(self, rbp: int = 0) -> Ast:
        left = self.nud(self.next())
        while True:
            kind, val, _ = self.peek()
            if kind != "op" or val not in _INFIX_BP or _INFIX_BP[val] <= rbp:
                break
            self.next()
            left = self.led(val, left)
        return left

    def nud(self, tok: tuple[str, Any, int]) -> Ast:
        kind, val, pos = tok
        if kind == "num":
            return ("num", val)
        if kind == "str":
            return ("str", val)
        if kind == "kw":
            return _KEYWORDS[val]
        if kind == "ident":
            return self.path(val)
        if kind == "op":
            if val == "(":
                inner = self.parse(0)
                self.expect_op(")")
                return inner
            if val == "[":
                return self.array()
            if val in ("!", "-", "+"):
                operand = self.parse(_UNARY_BP)
                if val == "+":
                    return operand
                return ("un", val, operand)
        raise ExprSyntaxError("Unexpected token", self.source, pos)

    def array(self) -> Ast:
        items: list[Ast] = []
        kind, val, _ = self.peek()
        if kind == "op" and val == "]":
            self.next()
            return ("list", ())
        while True:
            items.append(self.parse(0))
            kind, val, pos = self.next()
            if kind == "op" and val == "]":
                return ("list", tuple(items))
            if not (kind == "op" and val == ","):
                raise ExprSyntaxError("Expected ',' or ']'", self.source, pos)

    def path(self, first: str) -> Ast:
        segments: list[str | int] = [first]
        computed: Ast | None = None

        def push(seg: str | int) -> None:
            nonlocal computed
            if computed is None:
                segments.append(seg)
            else:
                computed = ("index", computed, ("str", seg) if isinstance(seg, str) else ("num", str(seg)))

        while True:
            kind, val, _ = self.peek()
            if kind == "op" and val == ".":
                self.next()
                k2, v2, p2 = self.next()
                if k2 not in ("ident", "kw") and not (k2 == "op" and v2 == "in"):
                    raise ExprSyntaxError("Expected property name", self.source, p2)
                push(str(v2))
            elif kind == "op" and val == "[":
                self.next()
                k2, v2, _ = self.peek()
                k3, v3, _ = self.tokens[self.i + 1] if self.i + 1 < len(self.tokens) else ("eof", None, 0)
                if k3 == "op" and v3 == "]" and ((k2 == "num" and "." not in v2) or k2 == "str"):
                    self.next()
                    self.next()
                    push(int(v2) if k2 == "num" else v2)
                else:
                    inner = self.parse(0)
                    self.expect_op("]")
                    base = computed if computed is not None else ("path", tuple(segments))
                    computed = ("index", base, inner)
            else:
                break
        return computed if computed is not None else ("path", tuple(segments))

    def led(self, op: str, left: Ast) -> Ast:
        if op == "?":
            then = self.parse(0)
            self.expect_op(":")
            other = self.parse(_INFIX_BP["?"] - 1)
            return ("cond", left, then, other)
        if op == "|":
            kind, name, pos = self.next()
            # ``in`` is a word operator in infix position but also a valid filter name.
            if kind != "ident" and not (kind == "op" and name == "in"):
                raise ExprSyntaxError("Expected filter name", self.source, pos)
            args: list[Ast] = []
            k2, v2, _ = self.peek()
            if k2 == "op" and v2 == ":":
                self.next()
                args.append(self.parse(_FILTER_ARG_BP))
                while True:
                    k3, v3, _ = self.peek()
                    if k3 == "op" and v3 == ",":
                        self.next()
                        args.append(self.parse(_FILTER_ARG_BP))
                    else:
                        break
            return ("filter", name, left, tuple(args))
        right = self.parse(_INFIX_BP[op])
        if op == "&&":
            return ("and", left, right)
        if op == "||":
            return ("or", left, right)
        return ("bin", op, left, right)


def parse_expression(source: str) -> Ast:
    """Parse a bare expression (``visibleIf``, ``bind``, ``repeater.source``)."""
    text = source.strip()
    if text.startswith("{{") and text.endswith("}}") and text.count("{{") == 1:
        text = text[2:-2].strip()
    if not text:
        raise ExprSyntaxError("Empty expression", source, 0)
    parser = _Parser(text)
    ast = parser.parse(0)
    kind, _, pos = parser.peek()
    if kind != "eof":
        raise ExprSyntaxError("Unexpected trailing input", text, pos)
    return ast


TemplatePart = str | tuple[str, Ast, str]


def parse_template(text: str) -> tuple[TemplatePart, ...]:
    """Split ``"Dear {{client.name|upper}}"`` into literal strings and ("e", ast, source) parts.

    ``\\{{`` yields literal ``{{``. Unterminated ``{{`` is kept literally.
    """
    parts: list[TemplatePart] = []
    buf: list[str] = []
    i = 0
    n = len(text)
    while i < n:
        if text.startswith("\\{{", i):
            buf.append("{{")
            i += 3
            continue
        if text.startswith("{{", i):
            end = text.find("}}", i + 2)
            if end < 0:
                buf.append(text[i:])
                break
            src = text[i + 2 : end].strip()
            if buf:
                parts.append("".join(buf))
                buf = []
            parts.append(("e", parse_expression(src), src))
            i = end + 2
            continue
        buf.append(text[i])
        i += 1
    if buf:
        parts.append("".join(buf))
    return tuple(parts)


def collect_paths(ast: Ast, out: set[str] | None = None) -> set[str]:
    """Collect dotted data paths referenced by an AST (for schema checks and page.* detection)."""
    if out is None:
        out = set()
    kind = ast[0]
    if kind == "path":
        out.add(".".join(str(s) if isinstance(s, str) else "[]" for s in ast[1]).replace(".[]", "[]"))
    elif kind == "un":
        collect_paths(ast[2], out)
    elif kind == "bin":
        collect_paths(ast[2], out)
        collect_paths(ast[3], out)
    elif kind in ("and", "or"):
        collect_paths(ast[1], out)
        collect_paths(ast[2], out)
    elif kind == "cond":
        for sub in ast[1:]:
            collect_paths(sub, out)
    elif kind == "filter":
        collect_paths(ast[2], out)
        for arg in ast[3]:
            collect_paths(arg, out)
    elif kind == "list":
        for item in ast[1]:
            collect_paths(item, out)
    elif kind == "index":
        collect_paths(ast[1], out)
        collect_paths(ast[2], out)
    return out
