"""
  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()