"""
Query parser - main module for query processing.

Handles query rewriting, translation, and embedding generation.
"""

from typing import Dict, List, Optional, Any
import numpy as np

from config import CustomerConfig, QueryConfig
from embeddings import BgeEncoder
from .language_detector import LanguageDetector
from .translator import Translator
from .query_rewriter import QueryRewriter, QueryNormalizer


class ParsedQuery:
    """Container for parsed query results."""

    def __init__(
        self,
        original_query: str,
        normalized_query: str,
        rewritten_query: Optional[str] = None,
        detected_language: str = "unknown",
        translations: Dict[str, str] = None,
        query_vector: Optional[np.ndarray] = None,
        domain: str = "default"
    ):
        self.original_query = original_query
        self.normalized_query = normalized_query
        self.rewritten_query = rewritten_query or normalized_query
        self.detected_language = detected_language
        self.translations = translations or {}
        self.query_vector = query_vector
        self.domain = domain

    def to_dict(self) -> Dict[str, Any]:
        """Convert to dictionary representation."""
        result = {
            "original_query": self.original_query,
            "normalized_query": self.normalized_query,
            "rewritten_query": self.rewritten_query,
            "detected_language": self.detected_language,
            "translations": self.translations,
            "domain": self.domain,
            "has_vector": self.query_vector is not None
        }
        return result


class QueryParser:
    """
    Main query parser that processes queries through multiple stages:
    1. Normalization
    2. Query rewriting (brand/category mappings, synonyms)
    3. Language detection
    4. Translation to target languages
    5. Text embedding generation (for semantic search)
    """

    def __init__(
        self,
        config: CustomerConfig,
        text_encoder: Optional[BgeEncoder] = None,
        translator: Optional[Translator] = None
    ):
        """
        Initialize query parser.

        Args:
            config: Customer configuration
            text_encoder: Text embedding encoder (lazy loaded if not provided)
            translator: Translator instance (lazy loaded if not provided)
        """
        self.config = config
        self.query_config = config.query_config
        self._text_encoder = text_encoder
        self._translator = translator

        # Initialize components
        self.normalizer = QueryNormalizer()
        self.language_detector = LanguageDetector()
        self.rewriter = QueryRewriter(self.query_config.rewrite_dictionary)

    @property
    def text_encoder(self) -> BgeEncoder:
        """Lazy load text encoder."""
        if self._text_encoder is None and self.query_config.enable_text_embedding:
            print("[QueryParser] Initializing text encoder...")
            self._text_encoder = BgeEncoder()
        return self._text_encoder

    @property
    def translator(self) -> Translator:
        """Lazy load translator."""
        if self._translator is None and self.query_config.enable_translation:
            print("[QueryParser] Initializing translator...")
            self._translator = Translator(
                api_key=self.query_config.translation_api_key,
                use_cache=True
            )
        return self._translator

    def parse(self, query: str, generate_vector: bool = True) -> ParsedQuery:
        """
        Parse query through all processing stages.

        Args:
            query: Raw query string
            generate_vector: Whether to generate query embedding

        Returns:
            ParsedQuery object with all processing results
        """
        print(f"\n[QueryParser] Parsing query: '{query}'")

        # Stage 1: Normalize
        normalized = self.normalizer.normalize(query)
        print(f"[QueryParser] Normalized: '{normalized}'")

        # Extract domain if present (e.g., "brand:Nike" -> domain="brand", query="Nike")
        domain, query_text = self.normalizer.extract_domain_query(normalized)
        print(f"[QueryParser] Domain: '{domain}', Query: '{query_text}'")

        # Stage 2: Query rewriting
        rewritten = None
        if self.query_config.enable_query_rewrite:
            rewritten = self.rewriter.rewrite(query_text)
            if rewritten != query_text:
                print(f"[QueryParser] Rewritten: '{rewritten}'")
                query_text = rewritten

        # Stage 3: Language detection
        detected_lang = self.language_detector.detect(query_text)
        print(f"[QueryParser] Detected language: {detected_lang}")

        # Stage 4: Translation
        translations = {}
        if self.query_config.enable_translation:
            target_langs = self.translator.get_translation_needs(
                detected_lang,
                self.query_config.supported_languages
            )

            if target_langs:
                print(f"[QueryParser] Translating to: {target_langs}")
                translations = self.translator.translate_multi(
                    query_text,
                    target_langs,
                    source_lang=detected_lang
                )
                print(f"[QueryParser] Translations: {translations}")

        # Stage 5: Text embedding
        query_vector = None
        if (generate_vector and
            self.query_config.enable_text_embedding and
            domain == "default"):  # Only generate vector for default domain
            print(f"[QueryParser] Generating query embedding...")
            query_vector = self.text_encoder.encode([query_text])[0]
            print(f"[QueryParser] Query vector shape: {query_vector.shape}")

        # Build result
        result = ParsedQuery(
            original_query=query,
            normalized_query=normalized,
            rewritten_query=rewritten,
            detected_language=detected_lang,
            translations=translations,
            query_vector=query_vector,
            domain=domain
        )

        print(f"[QueryParser] Parsing complete")
        return result

    def get_search_queries(self, parsed_query: ParsedQuery) -> List[str]:
        """
        Get list of queries to search (original + translations).

        Args:
            parsed_query: Parsed query object

        Returns:
            List of query strings to search
        """
        queries = [parsed_query.rewritten_query]

        # Add translations
        for lang, translation in parsed_query.translations.items():
            if translation and translation != parsed_query.rewritten_query:
                queries.append(translation)

        return queries

    def update_rewrite_rules(self, rules: Dict[str, str]) -> None:
        """
        Update query rewrite rules.

        Args:
            rules: Dictionary of pattern -> replacement mappings
        """
        for pattern, replacement in rules.items():
            self.rewriter.add_rule(pattern, replacement)

    def get_rewrite_rules(self) -> Dict[str, str]:
        """Get current rewrite rules."""
        return self.rewriter.get_rules()