import re
from typing import Any, Optional

STANDARD_VARIABLE_DEFAULTS: dict[str, str] = {
    "first_name": "User",
    "last_name": "",
    "username": "user",
    "user_id": "0",
    "balance": "0",
    "plan_name": "Free",
    "bot_name": "Assistant",
    "item_name": "Subscription",
    "amount": "$0.00",
    "order_id": "ORD-0000",
    "payment_status": "Pending",
    "eta_minutes": "10",
    "txn_id": "TXN-000000",
    "validity_days": "30",
    "error_code": "ERR_UNKNOWN",
    "error_message": "An unexpected error occurred.",
}


class VariableResolver:
    """
    Safely resolves `{var_name}` and `{object.field}` placeholders in bot message templates.
    """

    VAR_PATTERN = re.compile(r"\{([a-zA-Z0-9_]+(?:\.[a-zA-Z0-9_]+)*)\}")

    @classmethod
    def extract_variables(cls, text: str) -> list[str]:
        """Returns unique list of variable names extracted from text in order of appearance."""
        seen = set()
        variables: list[str] = []
        for match in cls.VAR_PATTERN.finditer(text):
            var_name = match.group(1)
            if var_name not in seen:
                seen.add(var_name)
                variables.append(var_name)
        return variables

    @classmethod
    def resolve(
        cls,
        text: str,
        variables: Optional[dict[str, Any]] = None,
        custom_defaults: Optional[dict[str, Any]] = None,
        use_standard_defaults: bool = True,
    ) -> str:
        """
        Replaces placeholders with provided variable values.
        Supports dotted paths (e.g., `{user.name}`).
        Falls back to standard defaults if enabled, or retains original `{placeholder}` if unresolved.
        """
        active_vars = dict(variables or {})
        defaults = dict(STANDARD_VARIABLE_DEFAULTS) if use_standard_defaults else {}
        if custom_defaults:
            defaults.update(custom_defaults)

        def get_value_from_context(var_path: str) -> Optional[Any]:
            # 1. Direct match in provided variables
            if var_path in active_vars:
                return active_vars[var_path]

            # 2. Check dotted path in provided variables
            if "." in var_path:
                parts = var_path.split(".")
                curr = active_vars
                found = True
                for part in parts:
                    if isinstance(curr, dict) and part in curr:
                        curr = curr[part]
                    else:
                        found = False
                        break
                if found:
                    return curr

            # 3. Check defaults
            if var_path in defaults:
                return defaults[var_path]

            return None

        def replacer(match: re.Match) -> str:
            path = match.group(1)
            val = get_value_from_context(path)
            if val is not None:
                return str(val)
            return match.group(0)

        return cls.VAR_PATTERN.sub(replacer, text)
