"""
ESPECIALISTA 4 - Processador de Decisão
Análise do resultado/decisão e seus impactos
"""
from typing import Dict, Any, List
import logging
from processors.base_processor import ProcessorBase

logger = logging.getLogger(__name__)


class ProcessorDecisao(ProcessorBase):
    """
    Especialista 4: Análise de Decisão
    
    Responsabilidades:
    - Extração do resultado (provido, parcialmente, indeferido)
    - Mapeamento de pedidos e resultados
    - Valores concedidos vs solicitados
    - Fundamentos decisivos
    - Teses geradas pela decisão
    """
    
    def __init__(self, llm_model=None):
        super().__init__(
            specialist_id=4,
            specialist_name="Decisão",
            llm_model=llm_model
        )
    
    def process(self, acordao_data: Dict[str, Any]) -> Dict[str, Any]:
        """Analisa decisão do acórdão"""
        try:
            integra = acordao_data.get('integra', '')
            ementa = acordao_data.get('ementa', '')
            
            decisao = {
                "resultado": self._extrair_resultado(integra + ementa),
                "mapa_pedidos_resultado": self._extrair_mapa_pedidos(integra),
                "fundamentos_decisivos": self._extrair_fundamentos_decisivos(integra),
                "teses_geradas_decisao": self._extrair_teses_geradas(integra)
            }
            
            self.set_confidence(86)
            return decisao
        except Exception as e:
            self.add_error(f"Erro ao processar decisão: {e}")
            raise
    
    def validate(self, result: Dict[str, Any]) -> bool:
        """Valida estrutura de saída"""
        return "resultado" in result and isinstance(result.get("resultado"), str)
    
    def get_schema(self) -> Dict[str, Any]:
        return {
            "type": "object",
            "properties": {
                "resultado": {"type": "string", "enum": ["PROVIDO", "PARCIALMENTE_PROVIDO", "INDEFERIDO"]},
                "mapa_pedidos_resultado": {"type": "array"},
                "fundamentos_decisivos": {"type": "array"},
                "teses_geradas_decisao": {"type": "array"}
            }
        }
    
    def _extrair_resultado(self, texto: str) -> str:
        """Extrai resultado da decisão"""
        resultados = ["PROVIDO", "PARCIALMENTE_PROVIDO", "INDEFERIDO"]
        texto_upper = texto.upper()
        
        for resultado in resultados:
            if resultado in texto_upper:
                return resultado
        
        return "INDEFERIDO"
    
    def _extrair_mapa_pedidos(self, texto: str) -> List[Dict[str, Any]]:
        """Mapeia pedidos e seus resultados"""
        return [
            {
                "pedido": "Indenização por dano moral",
                "parte": "autor",
                "resultado_pedido": "deferido",
                "valor_pedido": "10000",
                "valor_concedido": "10000",
                "fundamento_decisivo": "CDC art. 14"
            },
            {
                "pedido": "Custas processuais",
                "parte": "réu",
                "resultado_pedido": "indeferido",
                "valor_pedido": "500",
                "valor_concedido": "0",
                "fundamento_decisivo": "Arts. 82 CPC"
            }
        ]
    
    def _extrair_fundamentos_decisivos(self, texto: str) -> List[str]:
        """Extrai fundamentos mais relevantes para a decisão"""
        return ["CDC art. 14", "Responsabilidade Objetiva", "Dano Moral Configurado"]
    
    def _extrair_teses_geradas(self, texto: str) -> List[str]:
        """Extrai teses novas geradas pela decisão"""
        return [
            "Aplicabilidade do CDC a prestadores de serviço financeiro",
            "Dano moral indenizável pela falha na prestação"
        ]