"""Project variable schema: tree <-> rows, JSON Schema builder, example data (TZ 2.4.1, 2.4.5)."""

from __future__ import annotations

import re
from typing import Any

from django.db import transaction

from snapfile.core import ids
from snapfile.core.errors import ApiError
from snapfile_render.expr.parser import ExprSyntaxError, parse_expression

from .models import Project, VariableNode

KEY_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
SCALARS = ("string", "number", "date", "money", "bool", "image")
TYPES = (*SCALARS, "array", "object")
DERIVED = "derived"
RESERVED_ROOTS = {"page", "sheet", "doc", "loop", "now"}
# Editor-level types (03_frontend 3.13) are not separate engine types: they are stored as the TZ 2.4.1 type
# plus ``format.ui_type`` (decision of iteration 1, see docs/dev/known-issues.md). Accepted on input so
# that clients sending them do not get a 422; the stored/returned ``type`` is always one of TYPES.
TYPE_ALIASES = {"text": "string", "integer": "number", "percent": "number", "color": "string", "enum": "string"}
COLOR_PATTERN = "^#([0-9A-Fa-f]{6}|[0-9A-Fa-f]{8})$"
_CONSTRAINT_KEYS = ("minLength", "maxLength", "pattern", "minimum", "maximum", "enum", "minItems", "maxItems")


def _node_dict(node: VariableNode, children: dict[Any, list[VariableNode]]) -> dict[str, Any]:
    out: dict[str, Any] = {
        "id": ids.encode("var", node.id),
        "key": node.key,
        "path": node.path,
        "type": node.type,
        "label": node.label,
        "description": node.description,
        "required": node.required,
        "nullable": node.nullable,
        "default": node.default_value,
        "format": node.format,
        "constraints": node.constraints,
        "example": node.example,
    }
    if node.type == DERIVED:
        out["expression"] = node.expression
        out["readonly"] = True
    kids = [_node_dict(c, children) for c in children.get(node.id, [])]
    if node.type == "object":
        out["fields"] = kids
    elif node.type == "array":
        item: dict[str, Any] = {"type": node.item_type or "string"}
        if (node.item_type or "") == "object":
            item["fields"] = kids
        out["items"] = item
    return out


def get_tree(project: Project) -> list[dict[str, Any]]:
    rows = list(VariableNode.objects.filter(project=project).order_by("sort", "key"))
    children: dict[Any, list[VariableNode]] = {}
    for r in rows:
        children.setdefault(r.parent_id, []).append(r)
    return [_node_dict(n, children) for n in children.get(None, [])]


def normalize_types(tree: Any) -> Any:
    """Map editor aliases (text, integer, percent, color, enum) to TZ types + ``format.ui_type``."""
    if not isinstance(tree, list):
        return tree
    out = []
    for var in tree:
        if not isinstance(var, dict):
            out.append(var)
            continue
        var = dict(var)
        alias = var.get("type")
        if alias in TYPE_ALIASES:
            fmt = dict(var.get("format") or {})
            cons = dict(var.get("constraints") or {})
            fmt["ui_type"] = alias
            if alias == "integer":
                fmt.setdefault("decimals", 0)
            elif alias == "percent":
                fmt.setdefault("percent", True)
            elif alias == "color":
                cons.setdefault("pattern", COLOR_PATTERN)
            elif alias == "enum" and isinstance(var.get("enum"), list):
                cons.setdefault("enum", var["enum"])
            var["type"] = TYPE_ALIASES[alias]
            var["format"] = fmt
            var["constraints"] = cons or None
        var.pop("enum", None)
        if isinstance(var.get("fields"), list):
            var["fields"] = normalize_types(var["fields"])
        items = var.get("items")
        if isinstance(items, dict):
            items = dict(items)
            if items.get("type") in TYPE_ALIASES:
                items["type"] = TYPE_ALIASES[items["type"]]
            if isinstance(items.get("fields"), list):
                items["fields"] = normalize_types(items["fields"])
            var["items"] = items
        out.append(var)
    return out


def _validate(tree: Any, prefix: str, errors: list[dict[str, Any]], depth: int = 0) -> None:
    if not isinstance(tree, list):
        errors.append({"pointer": prefix or "/", "message": "Expected a list of variables"})
        return
    seen: set[str] = set()
    for i, var in enumerate(tree):
        ptr = f"{prefix}/{i}"
        if not isinstance(var, dict):
            errors.append({"pointer": ptr, "message": "Expected an object"})
            continue
        key = var.get("key")
        if not isinstance(key, str) or not KEY_RE.match(key):
            errors.append({"pointer": f"{ptr}/key", "message": "Key must match [A-Za-z_][A-Za-z0-9_]*"})
        elif key in seen:
            errors.append({"pointer": f"{ptr}/key", "message": f"Duplicate key {key!r}"})
        elif depth == 0 and key in RESERVED_ROOTS:
            errors.append({"pointer": f"{ptr}/key", "message": f"{key!r} is a reserved system variable"})
        seen.add(str(key))
        vtype = var.get("type")
        if vtype == DERIVED:
            if depth != 0:
                errors.append({"pointer": f"{ptr}/type", "message": "Derived variables are top-level only"})
            try:
                parse_expression(str(var.get("expression") or ""))
            except ExprSyntaxError as exc:
                errors.append({"pointer": f"{ptr}/expression", "message": str(exc)})
            continue
        if vtype not in TYPES:
            errors.append({"pointer": f"{ptr}/type", "message": f"Type must be one of {', '.join(TYPES)}"})
        if depth > 8:
            errors.append({"pointer": ptr, "message": "Schema is nested too deeply"})
            continue
        if vtype == "object":
            _validate(var.get("fields") or [], f"{ptr}/fields", errors, depth + 1)
        elif vtype == "array":
            items = var.get("items") or {"type": "string"}
            if items.get("type") not in TYPES or items.get("type") == "array":
                errors.append({"pointer": f"{ptr}/items/type", "message": "Unsupported array item type"})
            if items.get("type") == "object":
                _validate(items.get("fields") or [], f"{ptr}/items/fields", errors, depth + 1)


def _insert(
    project: Project,
    tree: list[dict[str, Any]],
    parent: VariableNode | None,
    base_path: str,
    actor: dict[str, Any] | None,
) -> None:
    for sort, var in enumerate(tree):
        path = f"{base_path}.{var['key']}" if base_path else var["key"]
        vtype = var["type"]
        items = var.get("items") or {}
        constraints = {k: v for k, v in (var.get("constraints") or {}).items() if k in _CONSTRAINT_KEYS} or None
        node = VariableNode.objects.create(
            project=project,
            parent=parent,
            key=var["key"],
            path=path,
            type=vtype,
            item_type=(items.get("type") or "string") if vtype == "array" else None,
            format=var.get("format"),
            expression=var.get("expression") if vtype == DERIVED else None,
            default_value=var.get("default"),
            required=bool(var.get("required")),
            nullable=bool(var.get("nullable")),
            constraints=constraints,
            label=var.get("label"),
            description=var.get("description"),
            example=var.get("example"),
            sort=sort,
            created_by=actor,
            updated_by=actor,
        )
        if vtype == "object":
            _insert(project, var.get("fields") or [], node, path, actor)
        elif vtype == "array" and items.get("type") == "object":
            _insert(project, items.get("fields") or [], node, f"{path}[]", actor)


def replace_tree(
    project: Project, tree: list[dict[str, Any]], base_revision: int | None, actor: dict[str, Any] | None
) -> int:
    errors: list[dict[str, Any]] = []
    tree = normalize_types(tree)
    _validate(tree, "", errors)
    if errors:
        raise ApiError(422, "VALIDATION_FAILED", "Variable schema is invalid", errors[:100])
    with transaction.atomic():
        locked = Project.objects.select_for_update().get(pk=project.pk)
        revision = int(locked.setting("schema_revision") or 0)
        if base_revision is not None and base_revision != revision:
            raise ApiError(
                409, "REVISION_CONFLICT", "Schema was changed by someone else", [{"current_revision": revision}]
            )
        VariableNode.objects.filter(project=locked).delete()
        _insert(locked, tree, None, "", actor)
        locked.settings = {**(locked.settings or {}), "schema_revision": revision + 1}
        locked.save(update_fields=["settings", "updated_at"])
    project.settings = locked.settings
    return revision + 1


# --------------------------------------------------------------------------------------------- JSON Schema

_DATE_PATTERN = r"^\d{4}-\d{2}-\d{2}([T ]\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?)?$"
_IMAGE_PATTERN = r"^(ast_[0-9A-Za-z]{26}|https?://.+|data:image/[a-z+]+;base64,.+)$"


def _scalar_schema(vtype: str, var: dict[str, Any]) -> dict[str, Any]:
    c = var.get("constraints") or {}
    if vtype == "string":
        s: dict[str, Any] = {"type": "string"}
        for k in ("minLength", "maxLength", "pattern", "enum"):
            if k in c:
                s[k] = c[k]
        return s
    if vtype == "number":
        integer = (var.get("format") or {}).get("ui_type") == "integer"
        s = {"type": "integer" if integer else "number"}
        for k in ("minimum", "maximum", "enum"):
            if k in c:
                s[k] = c[k]
        return s
    if vtype == "date":
        return {"type": "string", "pattern": _DATE_PATTERN}
    if vtype == "money":
        return {
            "oneOf": [
                {"type": "number"},
                {"type": "string", "pattern": r"^-?\d+([.,]\d+)?$"},
                {
                    "type": "object",
                    "required": ["amount"],
                    "properties": {
                        "amount": {"type": ["number", "string"]},
                        "currency": {"type": "string", "pattern": "^[A-Z]{3}$"},
                    },
                },
            ]
        }
    if vtype == "bool":
        return {"type": "boolean"}
    if vtype == "image":
        return {"type": "string", "pattern": _IMAGE_PATTERN}
    return {}


def _var_schema(var: dict[str, Any], strict: bool) -> dict[str, Any]:
    vtype = var["type"]
    if vtype == "object":
        schema = _object_schema(var.get("fields") or [], strict)
    elif vtype == "array":
        items = var.get("items") or {"type": "string"}
        if items.get("type") == "object":
            item_schema = _object_schema(items.get("fields") or [], strict)
        else:
            item_schema = _scalar_schema(items.get("type", "string"), {})
        schema = {"type": "array", "items": item_schema, "maxItems": 10000}
        c = var.get("constraints") or {}
        for k in ("minItems", "maxItems"):
            if k in c:
                schema[k] = c[k]
    else:
        schema = _scalar_schema(vtype, var)
    if var.get("description") or var.get("label"):
        schema["description"] = var.get("description") or var.get("label")
    if var.get("example") is not None:
        schema["examples"] = [var["example"]]
    if var.get("nullable"):
        return {"anyOf": [schema, {"type": "null"}]}
    return schema


def _object_schema(fields: list[dict[str, Any]], strict: bool) -> dict[str, Any]:
    fields = [f for f in fields if f["type"] != DERIVED]
    return {
        "type": "object",
        "properties": {f["key"]: _var_schema(f, strict) for f in fields},
        "required": [f["key"] for f in fields if f.get("required") and f.get("default") is None],
        "additionalProperties": not strict,
    }


def build_json_schema(tree: list[dict[str, Any]], *, strict: bool = False, title: str | None = None) -> dict[str, Any]:
    schema = _object_schema(tree, strict)
    schema["$schema"] = "https://json-schema.org/draft/2020-12/schema"
    if title:
        schema["title"] = title
    return schema


def derived_defs(tree: list[dict[str, Any]] | None) -> list[tuple[str, str]]:
    """Top-level derived variables as (key, expression), in schema order."""
    return [(v["key"], v["expression"]) for v in tree or [] if v.get("type") == DERIVED and v.get("expression")]


def merge_override(tree: list[dict[str, Any]], override: list[dict[str, Any]] | None) -> list[dict[str, Any]]:
    """Template-local variables may only add new top-level keys (TZ 2.4.1 p.1)."""
    if not override:
        return tree
    keys = {v["key"] for v in tree}
    return [*tree, *[v for v in override if isinstance(v, dict) and v.get("key") not in keys]]


def example_data(tree: list[dict[str, Any]]) -> dict[str, Any]:
    tree = [v for v in tree if v["type"] != DERIVED]

    def value(var: dict[str, Any]) -> Any:
        if var.get("example") is not None:
            return var["example"]
        if var.get("default") is not None:
            return var["default"]
        t = var["type"]
        if t == "object":
            return {f["key"]: value(f) for f in var.get("fields") or []}
        if t == "array":
            items = var.get("items") or {"type": "string"}
            if items.get("type") == "object":
                return [{f["key"]: value(f) for f in items.get("fields") or []}]
            return [value({"type": items.get("type", "string"), "key": "item"})]
        return {
            "string": var.get("label") or var["key"],
            "number": 0,
            "date": "2026-01-01",
            "money": 0,
            "bool": True,
            "image": None,
        }.get(t)

    return {v["key"]: value(v) for v in tree}


def known_paths(tree: list[dict[str, Any]]) -> dict[str, str]:
    """Map of every schema path (``client.name``, ``items[].title``) to its type."""
    out: dict[str, str] = {}

    def walk(vars_: list[dict[str, Any]], prefix: str) -> None:
        for v in vars_:
            path = f"{prefix}.{v['key']}" if prefix else v["key"]
            out[path] = v["type"]
            if v["type"] == "object":
                walk(v.get("fields") or [], path)
            elif v["type"] == "array" and (v.get("items") or {}).get("type") == "object":
                walk(v["items"].get("fields") or [], f"{path}[]")

    walk(tree, "")
    return out
