"""
Personalidade e tom da IA
"""
from typing import Dict, List
from enum import Enum


class Tone(Enum):
    """Tons de comunicação disponíveis"""
    PROFESSIONAL = "profissional"
    FRIENDLY = "amigavel"
    CASUAL = "casual"
    TECHNICAL = "tecnico"
    EMPATHETIC = "empatico"


class Personality:
    """
    Define a personalidade da IA
    Pode ser customizada por usuário ou contexto
    """
    
    DEFAULT_TRAITS = {
        "helpful": 0.9,
        "creative": 0.6,
        "precise": 0.8,
        "humor": 0.3,
        "formality": 0.7
    }
    
    TONE_INSTRUCTIONS = {
        Tone.PROFESSIONAL: "Mantenha um tom formal e corporativo.",
        Tone.FRIENDLY: "Seja caloroso, use emojis ocasionais e informalidade leve.",
        Tone.CASUAL: "Converse como um amigo, linguagem coloquial é bem-vinda.",
        Tone.TECHNICAL: "Use terminologia técnica precisa, seja detalhado.",
        Tone.EMPATHETIC: "Demonstre compreensão e empatia genuína."
    }
    
    def __init__(self, traits: Optional[Dict[str, float]] = None):
        self.traits = traits or self.DEFAULT_TRAITS.copy()
        self.tone = Tone.PROFESSIONAL
        self.custom_instructions: List[str] = []
    
    def set_tone(self, tone: Tone):
        """Define o tom de comunicação"""
        self.tone = tone
    
    def set_trait(self, trait: str, value: float):
        """Ajusta uma característica (0.0 a 1.0)"""
        self.traits[trait] = max(0.0, min(1.0, value))
    
    def add_instruction(self, instruction: str):
        """Adiciona instrução personalizada"""
        self.custom_instructions.append(instruction)
    
    def get_system_addendum(self) -> str:
        """Gera instruções de personalidade para o prompt"""
        lines = [
            f"Tom: {self.TONE_INSTRUCTIONS[self.tone]}",
            "",
            "Características:"
        ]
        
        for trait, value in self.traits.items():
            level = "alta" if value > 0.7 else "média" if value > 0.4 else "baixa"
            lines.append(f"- {trait}: {level}")
        
        if self.custom_instructions:
            lines.extend(["", "Instruções adicionais:"])
            for instr in self.custom_instructions:
                lines.append(f"- {instr}")
        
        return "\n".join(lines)
    
    def adapt_to_user(self, user_history: List[Dict]):
        """
        Adapta personalidade baseada no histórico do usuário
        """
        # Analisar padrões do usuário e ajustar
        msg_count = len([m for m in user_history if m["role"] == "user"])
        
        if msg_count > 10:
            # Usuário recorrente - pode ser mais casual
            if self.traits["formality"] > 0.5:
                self.traits["formality"] -= 0.1
        
        # Detectar preferência por técnico
        technical_words = ["código", "api", "database", "função", "erro"]
        technical_count = sum(
            1 for m in user_history 
            if any(w in m.get("content", "").lower() for w in technical_words)
        )
        
        if technical_count > 3:
            self.tone = Tone.TECHNICAL


# Factory para criar personalidades pré-configuradas
class PersonalityFactory:
    
    @staticmethod
    def support_agent() -> Personality:
        """Personalidade para atendimento"""
        p = Personality()
        p.set_tone(Tone.EMPATHETIC)
        p.set_trait("helpful", 1.0)
        p.set_trait("precise", 0.9)
        p.add_instruction("Sempre verifique se o problema foi resolvido")
        p.add_instruction("Ofereça alternativas quando possível")
        return p
    
    @staticmethod
    def sales_assistant() -> Personality:
        """Personalidade para vendas"""
        p = Personality()
        p.set_tone(Tone.FRIENDLY)
        p.set_trait("helpful", 0.8)
        p.set_trait("creative", 0.8)
        p.add_instruction("Destaque benefícios, não apenas features")
        p.add_instruction("Crie senso de urgência sutilmente")
        return p
    
    @staticmethod
    def tech_expert() -> Personality:
        """Personalidade técnica"""
        p = Personality()
        p.set_tone(Tone.TECHNICAL)
        p.set_trait("precise", 1.0)
        p.set_trait("creative", 0.5)
        p.add_instruction("Forneça exemplos de código quando relevante")
        p.add_instruction("Explique o 'porquê' por trás das soluções")
        return p