"""Canonical string renderer for symbolic expressions."""

from __future__ import annotations

from .expression import (
    Aggregate,
    Binary,
    Expression,
    Function,
    Gather,
    GroupedParameter,
    Indexed,
    Number,
    Parameter,
    Reduction,
    RelationLift,
    Symbol,
    Unary,
)


PRECEDENCE = {"+": 10, "-": 10, "*": 20, "/": 20, "**": 30}


def render(
    expression: Expression,
    parent_precedence: int = 0,
    right: bool = False,
    *,
    latex: bool = False,
    number_format: str = "",
) -> str:
    """Render an expression as canonical text.

    Args:
        expression: Symbolic expression to process.
        parent_precedence: Precedence required by the enclosing expression.
        right: Whether the expression is the right operand of its parent.
        latex: Whether to render LaTeX notation.
        number_format: Format specification for numeric literals.

    Returns:
        The rendered expression.
    """
    if isinstance(expression, Number):
        return format(expression.value, number_format) if number_format else repr(expression.value)
    if isinstance(expression, Symbol):
        return expression.name
    if isinstance(expression, Parameter):
        suffix = "" if expression.value is None else f", value={expression.value!r}"
        return f"param({expression.name!r}{suffix})"
    if isinstance(expression, GroupedParameter):
        arguments = [render(expression.by)]
        if expression.name is not None:
            arguments.append(f"name={expression.name!r}")
        if expression.value is not None:
            arguments.append(f"value={dict(expression.value)!r}")
        if expression.default is not None:
            arguments.append(f"default={expression.default!r}")
        return f"grouped_param({', '.join(arguments)})"
    if isinstance(expression, Indexed):
        indices = ", ".join(str(index) for index in expression.indices)
        base = render(expression.base, 100, latex=latex, number_format=number_format)
        return f"{base}[{indices}]"
    if isinstance(expression, Unary):
        operand = render(expression.operand, 40, latex=latex, number_format=number_format)
        text = f"{expression.operator}{operand}"
        return f"({text})" if parent_precedence > 40 else text
    if isinstance(expression, Binary):
        precedence = PRECEDENCE[expression.operator]
        left = render(expression.left, precedence, latex=latex, number_format=number_format)
        right_precedence = precedence + (0 if expression.operator == "**" else 1)
        right_text = render(
            expression.right,
            right_precedence,
            right=True,
            latex=latex,
            number_format=number_format,
        )
        if latex and expression.operator == "/":
            text = f"\\frac{{{left}}}{{{right_text}}}"
        elif latex and expression.operator == "**":
            text = f"{left}^{{{right_text}}}"
        else:
            operator = (
                r" \times "
                if latex and expression.operator == "*"
                else f" {expression.operator} "
            )
            text = f"{left}{operator}{right_text}"
        return f"({text})" if precedence < parent_precedence else text
    if isinstance(expression, Function):
        arguments = ", ".join(
            render(arg, latex=latex, number_format=number_format)
            for arg in expression.arguments
        )
        if latex and expression.name == "sqrt":
            return f"\\sqrt{{{arguments}}}"
        if latex and expression.name == "abs":
            return f"\\left|{arguments}\\right|"
        if latex:
            function_name = {
                "arccos": r"\arccos",
                "arcsin": r"\arcsin",
                "arctan": r"\arctan",
                "log": r"\ln",
                "log10": r"\log_{10}",
                "log2": r"\log_{2}",
            }.get(expression.name, rf"\operatorname{{{expression.name}}}")
            return f"{function_name}\\left({arguments}\\right)"
        return f"{expression.name}({arguments})"
    if isinstance(expression, Reduction):
        indices = ", ".join(str(index) for index in expression.indices)
        operand = render(expression.operand, latex=latex, number_format=number_format)
        if expression.relation is None:
            return f"\\sum_{{{indices}}} {operand}" if latex else f"sum[{indices}]({operand})"
        relation = render(expression.relation, latex=latex, number_format=number_format)
        if latex:
            return f"\\sum_{{{indices}; {relation}}} {operand}"
        return f"sum[{indices}]({relation}, {operand})"
    if isinstance(expression, Gather):
        relation = render(expression.relation, latex=latex, number_format=number_format)
        operand = render(expression.operand, latex=latex, number_format=number_format)
        if latex:
            return f"\\operatorname{{gather}}\\left({relation}, {operand}\\right)"
        return f"gather({relation}, {operand})"
    if isinstance(expression, Aggregate):
        from .desugar import desugar

        return render(
            desugar(expression),
            parent_precedence,
            right,
            latex=latex,
            number_format=number_format,
        )
    if isinstance(expression, RelationLift):
        name = "targ" if expression.role == "target" else "sour"
        raise ValueError(f"{name}(...) must appear inside aggr(...).")
    raise TypeError(f"Cannot render {type(expression).__name__}.")