"""Filters v1 (TZ 2.4.4). Shared spec with the frontend: ``spec/fixtures/filters.fixtures.json``."""

from __future__ import annotations

import re
from collections.abc import Callable, Mapping
from decimal import Decimal
from typing import Any

from ..fmt import (
    apply_phone_mask,
    format_date,
    format_money,
    format_number,
    format_percent,
    locale_table,
    parse_date,
    plural_index,
    roman,
    title_case,
    to_decimal,
)
from .evaluator import MISSING, EvalEnv, to_text

FilterFn = Callable[[Any, list[Any], EvalEnv], Any]
_FILTERS: dict[str, FilterFn] = {}


def _register(*names: str) -> Callable[[FilterFn], FilterFn]:
    def deco(fn: FilterFn) -> FilterFn:
        for n in names:
            _FILTERS[n] = fn
        return fn

    return deco


def available_filters() -> list[str]:
    return sorted(_FILTERS)


def apply_filter(name: str, value: Any, args: list[Any], env: EvalEnv) -> Any:
    fn = _FILTERS.get(name)
    if fn is None:
        env.warnings.add("FILTER_UNKNOWN", filter=name, node=env.node_id)
        return value
    return fn(value, args, env)


def _int_arg(args: list[Any], i: int, default: int | None) -> int | None:
    if len(args) <= i or args[i] is None or args[i] is MISSING:
        return default
    d = to_decimal(args[i])
    return int(d) if d is not None else default


def _str_arg(args: list[Any], i: int, default: str) -> str:
    if len(args) <= i or args[i] is None or args[i] is MISSING:
        return default
    return str(args[i])


def _empty(value: Any) -> bool:
    return value is MISSING or value is None or value == "" or value == []


@_register("default")
def _default(value: Any, args: list[Any], env: EvalEnv) -> Any:
    return (args[0] if args else "") if _empty(value) else value


@_register("upper")
def _upper(value: Any, args: list[Any], env: EvalEnv) -> Any:
    return to_text(value, env.locale).upper()


@_register("lower")
def _lower(value: Any, args: list[Any], env: EvalEnv) -> Any:
    return to_text(value, env.locale).lower()


@_register("title")
def _title(value: Any, args: list[Any], env: EvalEnv) -> Any:
    return title_case(to_text(value, env.locale))


@_register("capitalize")
def _capitalize(value: Any, args: list[Any], env: EvalEnv) -> Any:
    text = to_text(value, env.locale)
    return text[:1].upper() + text[1:] if text else text


@_register("trim")
def _trim(value: Any, args: list[Any], env: EvalEnv) -> Any:
    return to_text(value, env.locale).strip()


@_register("truncate")
def _truncate(value: Any, args: list[Any], env: EvalEnv) -> Any:
    text = to_text(value, env.locale)
    length = _int_arg(args, 0, 80) or 0
    suffix = _str_arg(args, 1, "…")
    if len(text) <= length:
        return text
    return text[: max(0, length - len(suffix))].rstrip() + suffix


@_register("number")
def _number(value: Any, args: list[Any], env: EvalEnv) -> Any:
    d = to_decimal(value)
    if d is None:
        return value
    locale = _str_arg(args, 1, env.locale)
    return format_number(d, locale, _int_arg(args, 0, None))


@_register("percent")
def _percent(value: Any, args: list[Any], env: EvalEnv) -> Any:
    d = to_decimal(value)
    if d is None:
        return value
    return format_percent(d, env.locale, _int_arg(args, 0, 0))


@_register("money")
def _money(value: Any, args: list[Any], env: EvalEnv) -> Any:
    if _empty(value):
        return value
    out = format_money(value, env.locale, _str_arg(args, 0, "") or None, _int_arg(args, 1, 2))
    return value if out is None else out


@_register("date")
def _date(value: Any, args: list[Any], env: EvalEnv) -> Any:
    dt = parse_date(value)
    if dt is None:
        if not _empty(value):
            env.warnings.add("DATE_INVALID", value=str(value)[:40], node=env.node_id)
        return value
    pattern = _str_arg(args, 0, "") or None
    return format_date(dt, env.locale, pattern, env.tz_offset_minutes)


@_register("plural")
def _plural(value: Any, args: list[Any], env: EvalEnv) -> Any:
    d = to_decimal(value)
    if d is None or not args:
        return ""
    forms = [to_text(a, env.locale) for a in args]
    idx = plural_index(d, env.locale if len(forms) >= 3 else "en")
    return forms[min(idx, len(forms) - 1)]


@_register("join")
def _join(value: Any, args: list[Any], env: EvalEnv) -> Any:
    if not isinstance(value, list):
        return value
    sep = _str_arg(args, 0, ", ")
    return sep.join(to_text(v, env.locale) for v in value)


@_register("length", "count")
def _length(value: Any, args: list[Any], env: EvalEnv) -> Any:
    if isinstance(value, (list, str, Mapping)):
        return Decimal(len(value))
    return Decimal(0)


def _field_values(value: Any, args: list[Any]) -> list[Decimal]:
    if not isinstance(value, list):
        return []
    field = _str_arg(args, 0, "")
    out: list[Decimal] = []
    for item in value:
        raw = item.get(field) if field and isinstance(item, Mapping) else item
        d = to_decimal(raw)
        if d is not None:
            out.append(d)
    return out


@_register("sum")
def _sum(value: Any, args: list[Any], env: EvalEnv) -> Any:
    return sum(_field_values(value, args), Decimal(0))


@_register("avg")
def _avg(value: Any, args: list[Any], env: EvalEnv) -> Any:
    vals = _field_values(value, args)
    return sum(vals, Decimal(0)) / len(vals) if vals else MISSING


@_register("min")
def _min(value: Any, args: list[Any], env: EvalEnv) -> Any:
    vals = _field_values(value, args)
    return min(vals) if vals else MISSING


@_register("max")
def _max(value: Any, args: list[Any], env: EvalEnv) -> Any:
    vals = _field_values(value, args)
    return max(vals) if vals else MISSING


@_register("first")
def _first(value: Any, args: list[Any], env: EvalEnv) -> Any:
    if isinstance(value, (list, str)) and value:
        return value[0]
    return MISSING


@_register("last")
def _last(value: Any, args: list[Any], env: EvalEnv) -> Any:
    if isinstance(value, (list, str)) and value:
        return value[-1]
    return MISSING


@_register("replace")
def _replace(value: Any, args: list[Any], env: EvalEnv) -> Any:
    return to_text(value, env.locale).replace(_str_arg(args, 0, ""), _str_arg(args, 1, ""))


@_register("nl2br")
def _nl2br(value: Any, args: list[Any], env: EvalEnv) -> Any:
    # Newlines are already hard breaks for the text layout; normalise CRLF.
    return to_text(value, env.locale).replace("\r\n", "\n")


@_register("yesno")
def _yesno(value: Any, args: list[Any], env: EvalEnv) -> Any:
    table = locale_table(env.locale)["bool"]
    from .evaluator import truthy

    if truthy(value):
        return _str_arg(args, 0, table["true"])
    return _str_arg(args, 1, table["false"])


@_register("phone")
def _phone(value: Any, args: list[Any], env: EvalEnv) -> Any:
    if _empty(value):
        return value
    return apply_phone_mask(to_text(value, env.locale), _str_arg(args, 0, "+7 (###) ###-##-##"))


@_register("roman")
def _roman(value: Any, args: list[Any], env: EvalEnv) -> Any:
    d = to_decimal(value)
    return roman(int(d)) if d is not None else value


@_register("filter")
def _filter(value: Any, args: list[Any], env: EvalEnv) -> Any:
    """``items|filter:"visible"`` keeps elements whose field is truthy."""
    from .evaluator import truthy

    if not isinstance(value, list):
        return value
    field = _str_arg(args, 0, "")
    return [v for v in value if isinstance(v, Mapping) and truthy(v.get(field))]


# ---------------------------------------------------------------------- collections (spec/scene-additions.md)
_NUM_IN_TEXT = re.compile(r"-?\d+(?:\.\d+)?")


def _field(item: Any, path: str) -> Any:
    """``a.b`` lookup in nested objects; missing parts give ``None``."""
    cur = item
    for part in path.split(".") if path else []:
        if isinstance(cur, Mapping):
            cur = cur.get(part)
        elif isinstance(cur, list) and part.isdigit() and int(part) < len(cur):
            cur = cur[int(part)]
        else:
            return None
    return cur


def _matches(actual: Any, op: str, expected: Any) -> bool:
    from .evaluator import _compare

    if op in ("==", "!=") and isinstance(expected, list):
        hit = _compare("in", actual, expected)
        return hit if op == "==" else not hit
    return _compare(op, actual, expected)


_OPS = ("==", "!=", ">", ">=", "<", "<=")


def _predicate(args: list[Any]) -> Callable[[Any], bool]:
    from .evaluator import truthy

    field = _str_arg(args, 0, "")
    if len(args) >= 3 and args[1] in _OPS:
        op, expected = str(args[1]), args[2]
        return lambda item: _matches(_field(item, field), op, expected)
    if len(args) >= 2:
        expected = args[1]
        return lambda item: _matches(_field(item, field), "==", expected)
    return lambda item: truthy(_field(item, field))


@_register("where")
def _where(value: Any, args: list[Any], env: EvalEnv) -> Any:
    if not isinstance(value, list):
        return []
    pred = _predicate(args)
    return [v for v in value if pred(v)]


@_register("reject")
def _reject(value: Any, args: list[Any], env: EvalEnv) -> Any:
    if not isinstance(value, list):
        return []
    pred = _predicate(args)
    return [v for v in value if not pred(v)]


@_register("find")
def _find(value: Any, args: list[Any], env: EvalEnv) -> Any:
    if not isinstance(value, list):
        return MISSING
    pred = _predicate(args)
    for v in value:
        if pred(v):
            return v
    return MISSING


def _sort_number(raw: Any) -> Decimal | None:
    d = to_decimal(raw)
    if d is not None:
        return d
    if isinstance(raw, str):
        m = _NUM_IN_TEXT.search(raw.replace(",", ""))
        if m:
            return Decimal(m.group())
    return None


def _sorted(value: Any, field: str, descending: bool) -> list[Any]:
    """Stable sort; numeric when all present values look numeric, empty values always last."""
    if not isinstance(value, list):
        return []
    present: list[tuple[Any, Any]] = []
    empty: list[Any] = []
    for item in value:
        raw = _field(item, field) if field else item
        if raw is None or raw is MISSING or raw == "":
            empty.append(item)
        else:
            present.append((raw, item))
    numbers = [_sort_number(raw) for raw, _ in present]
    if all(n is not None for n in numbers):
        keyed = list(zip(numbers, (item for _, item in present), strict=True))
    else:
        keyed = [(to_text(raw, "en").casefold(), item) for raw, item in present]
    keyed.sort(key=lambda pair: pair[0], reverse=descending)
    return [item for _, item in keyed] + empty


@_register("sort")
def _sort(value: Any, args: list[Any], env: EvalEnv) -> Any:
    order = _str_arg(args, 1, "asc").lower()
    return _sorted(value, _str_arg(args, 0, ""), order == "desc")


@_register("sort_desc")
def _sort_desc(value: Any, args: list[Any], env: EvalEnv) -> Any:
    return _sorted(value, _str_arg(args, 0, ""), True)


@_register("limit")
def _limit(value: Any, args: list[Any], env: EvalEnv) -> Any:
    if not isinstance(value, list):
        return []
    n = _int_arg(args, 0, None)
    return value if n is None else value[: max(0, n)]


@_register("get")
def _get(value: Any, args: list[Any], env: EvalEnv) -> Any:
    if value is MISSING or value is None:
        return MISSING
    found = _field(value, _str_arg(args, 0, ""))
    return MISSING if found is None else found


@_register("map")
def _map(value: Any, args: list[Any], env: EvalEnv) -> Any:
    if not isinstance(value, list):
        return []
    field = _str_arg(args, 0, "")
    return [_field(v, field) for v in value]


@_register("in")
def _in(value: Any, args: list[Any], env: EvalEnv) -> Any:
    from .evaluator import _compare

    return _compare("in", value, args[0]) if args else False
