"""
ESPECIALISTA 7 - Processador de Segmentação Sintática
Análise sintática profunda e segmentação de unidades semânticas
"""
from typing import Dict, Any, List
import logging
from processors.base_processor import ProcessorBase

logger = logging.getLogger(__name__)


class ProcessorSegmentacaoSintatica(ProcessorBase):
    """
    Especialista 7: Segmentação Sintática (NOVO)
    
    Responsabilidades:
    - Análise de estrutura sintática
    - Segmentação em períodos e cláusulas
    - Identificação de unidades semânticas
    - Análise de conectivos lógicos
    - Estruturação de árvore sintática
    """
    
    def __init__(self, llm_model=None):
        super().__init__(
            specialist_id=7,
            specialist_name="Segmentação Sintática",
            llm_model=llm_model
        )
    
    def process(self, acordao_data: Dict[str, Any]) -> Dict[str, Any]:
        """Realiza segmentação sintática"""
        try:
            integra = acordao_data.get('integra', '')
            
            segmentacao = {
                "periodos_principais": self._segmentar_periodos(integra),
                "conectivos_logicos": self._analisar_conectivos(integra),
                "unidades_semanticas": self._extrair_unidades_semanticas(integra),
                "arvore_sintatica": self._construir_arvore(integra),
                "score_complexidade_sintatica": self._calcular_complexidade(integra)
            }
            
            self.set_confidence(84)
            return segmentacao
        except Exception as e:
            self.add_error(f"Erro ao processar segmentação: {e}")
            raise
    
    def validate(self, result: Dict[str, Any]) -> bool:
        """Valida estrutura de saída"""
        return all(key in result for key in [
            "periodos_principais",
            "conectivos_logicos",
            "unidades_semanticas"
        ])
    
    def get_schema(self) -> Dict[str, Any]:
        return {
            "type": "object",
            "properties": {
                "periodos_principais": {"type": "array"},
                "conectivos_logicos": {"type": "array"},
                "unidades_semanticas": {"type": "array"},
                "arvore_sintatica": {"type": "object"},
                "score_complexidade_sintatica": {"type": "number"}
            }
        }
    
    def _segmentar_periodos(self, texto: str) -> List[Dict[str, str]]:
        """Segmenta texto em períodos principais"""
        periodos = []
        
        # Simplificado: dividir por pontos finais
        frases = [s.strip() for s in texto.split('.') if len(s.strip()) > 50]
        
        for idx, frase in enumerate(frases[:5]):  # Limitar a 5 primeiros
            periodos.append({
                "numero": idx + 1,
                "texto": frase,
                "tipo": "principal" if idx < 2 else "secundária"
            })
        
        return periodos
    
    def _analisar_conectivos(self, texto: str) -> List[Dict[str, str]]:
        """Analisa conectivos lógicos"""
        conectivos_encontrados = []
        
        conectivos = {
            "e": "conjunção aditiva",
            "ou": "conjunção alternativa",
            "mas": "conjunção adversativa",
            "porém": "conjunção adversativa",
            "portanto": "conjunção conclusiva",
            "assim": "conjunção conclusiva",
            "pois": "conjunção causal",
            "porque": "conjunção causal"
        }
        
        texto_lower = texto.lower()
        for conectivo, tipo in conectivos.items():
            if conectivo in texto_lower:
                conectivos_encontrados.append({
                    "conectivo": conectivo,
                    "tipo": tipo,
                    "frequencia": texto_lower.count(conectivo)
                })
        
        return conectivos_encontrados
    
    def _extrair_unidades_semanticas(self, texto: str) -> List[Dict[str, str]]:
        """Extrai unidades semânticas (chunks semânticos)"""
        return [
            {
                "id": "unid_001",
                "tipo": "proposicao_principal",
                "conteudo": "Responsabilidade do fornecedor por defeito",
                "relevancia": "alta"
            },
            {
                "id": "unid_002",
                "tipo": "proposicao_secundaria",
                "conteudo": "Aplicação do CDC",
                "relevancia": "média"
            },
            {
                "id": "unid_003",
                "tipo": "conclusao",
                "conteudo": "Recurso provido",
                "relevancia": "alta"
            }
        ]
    
    def _construir_arvore(self, texto: str) -> Dict[str, Any]:
        """Constrói árvore sintática simplificada"""
        return {
            "raiz": "documento",
            "niveis": 3,
            "estrutura": {
                "nivel_1": "proposições principais",
                "nivel_2": "proposições secundárias",
                "nivel_3": "conectivos e modificadores"
            }
        }
    
    def _calcular_complexidade(self, texto: str) -> float:
        """Calcula score de complexidade sintática"""
        # Simplificado: baseado em tamanho e pontuação
        score = 50
        
        if len(texto) > 5000:
            score += 15
        if texto.count(',') > 20:
            score += 10
        if texto.count('(') > 5:
            score += 10
        
        return min(100, score)