"""
Base parser interface for query processing.
"""

from abc import ABC, abstractmethod
from typing import Dict, List, Any, Optional
from pydantic import BaseModel


class ParsedQuery(BaseModel):
    """Structured representation of a parsed query."""
    
    original_query: str
    keywords: List[str]
    entities: List[Dict[str, Any]]
    intent: Optional[str] = None
    confidence: float = 0.0
    metadata: Dict[str, Any] = {}


class BaseParser(ABC):
    """Abstract base class for query parsers."""
    
    def __init__(self, config: Optional[Dict[str, Any]] = None):
        """
        Initialize the parser with configuration.
        
        Args:
            config: Parser configuration dictionary
        """
        self.config = config or {}
        self._initialize()
    
    @abstractmethod
    def _initialize(self) -> None:
        """Initialize parser-specific components."""
        pass
    
    @abstractmethod
    def parse(self, query: str) -> ParsedQuery:
        """
        Parse a natural language query.
        
        Args:
            query: Input query string
            
        Returns:
            ParsedQuery object with extracted information
        """
        pass
    
    @abstractmethod
    def extract_keywords(self, query: str) -> List[str]:
        """
        Extract keywords from a query.
        
        Args:
            query: Input query string
            
        Returns:
            List of extracted keywords
        """
        pass
    
    def preprocess_query(self, query: str) -> str:
        """
        Preprocess the query before parsing.
        
        Args:
            query: Raw input query
            
        Returns:
            Preprocessed query string
        """
        # Basic preprocessing
        query = query.strip()
        query = ' '.join(query.split())  # Normalize whitespace
        return query
    
    def postprocess_results(self, parsed_query: ParsedQuery) -> ParsedQuery:
        """
        Postprocess parsing results.
        
        Args:
            parsed_query: Initial parsing results
            
        Returns:
            Postprocessed ParsedQuery
        """
        # Remove duplicate keywords while preserving order
        seen = set()
        unique_keywords = []
        for keyword in parsed_query.keywords:
            if keyword.lower() not in seen:
                seen.add(keyword.lower())
                unique_keywords.append(keyword)
        
        parsed_query.keywords = unique_keywords
        return parsed_query