"""
Query rewriter for handling synonyms, brand mappings, and query transformations.
"""

from typing import Dict, Optional
import re


class QueryRewriter:
    """Rewrites queries based on exact word matching with configured dictionary rules.

    Only performs full word matching - no partial matching or substring replacement.
    The entire query must exactly match a key in the rewrite dictionary to be rewritten.
    """

    def __init__(self, rewrite_dict: Dict[str, str] = None):
        """
        Initialize query rewriter for exact word matching only.

        Args:
            rewrite_dict: Dictionary mapping exact query terms to rewrite expressions
                         e.g., {"芭比": "brand:芭比 OR name:芭比娃娃"}
                         Only full word matches will be rewritten, no partial matching.
        """
        self.rewrite_dict = rewrite_dict or {}

    def rewrite(self, query: str) -> str:
        """
        Rewrite query based on dictionary rules using exact word matching only.

        Args:
            query: Original query string

        Returns:
            Rewritten query string
        """
        if not query or not query.strip():
            return query

        # Only check for exact matches - no partial matching
        if query in self.rewrite_dict:
            rewritten = self.rewrite_dict[query]
            print(f"[QueryRewriter] Exact match: '{query}' -> '{rewritten}'")
            return rewritten

        # No rewrite needed - no partial matching
        return query

    def add_rule(self, pattern: str, replacement: str) -> None:
        """
        Add a rewrite rule.

        Args:
            pattern: Query pattern to match
            replacement: Replacement expression
        """
        self.rewrite_dict[pattern] = replacement

    def remove_rule(self, pattern: str) -> bool:
        """
        Remove a rewrite rule.

        Args:
            pattern: Query pattern to remove

        Returns:
            True if rule was removed, False if not found
        """
        if pattern in self.rewrite_dict:
            del self.rewrite_dict[pattern]
            return True
        return False

    def get_rules(self) -> Dict[str, str]:
        """Get all rewrite rules."""
        return self.rewrite_dict.copy()

    def clear_rules(self) -> None:
        """Clear all rewrite rules."""
        self.rewrite_dict.clear()


class QueryNormalizer:
    """Normalizes queries for consistent processing."""

    @staticmethod
    def normalize(query: str) -> str:
        """
        Normalize query string.

        - Trim whitespace
        - Convert multiple spaces to single space
        - Remove special characters (optional)

        Args:
            query: Original query

        Returns:
            Normalized query
        """
        if not query:
            return ""

        # Trim and collapse whitespace
        query = " ".join(query.split())

        return query

    @staticmethod
    def remove_punctuation(query: str, keep_operators: bool = True) -> str:
        """
        Remove punctuation from query.

        Args:
            query: Original query
            keep_operators: Whether to keep boolean operators (AND, OR, etc.)

        Returns:
            Query without punctuation
        """
        if not query:
            return ""

        if keep_operators:
            # Keep alphanumeric, spaces, and operator characters
            pattern = r'[^a-zA-Z0-9\u4e00-\u9fff\u0400-\u04ff\s\(\)|&!-]'
        else:
            # Keep only alphanumeric and spaces
            pattern = r'[^a-zA-Z0-9\u4e00-\u9fff\u0400-\u04ff\s]'

        return re.sub(pattern, '', query)

    @staticmethod
    def extract_domain_query(query: str) -> tuple:
        """
        Extract domain prefix from query if present.

        Examples:
            "brand:Nike shoes" -> ("brand", "Nike shoes")
            "category:toys" -> ("category", "toys")
            "default query" -> ("default", "default query")

        Args:
            query: Query string

        Returns:
            Tuple of (domain, query_text)
        """
        # Check for domain:query pattern
        match = re.match(r'^(\w+):(.+)$', query.strip())
        if match:
            return match.group(1), match.group(2).strip()

        # No domain specified, use default
        return "default", query.strip()