"""
Modelos de dados para conversação
"""
from dataclasses import dataclass, field
from datetime import datetime
from typing import List, Dict, Optional, Any
from enum import Enum


class MessageRole(Enum):
    """Papéis das mensagens"""
    USER = "user"
    ASSISTANT = "assistant"
    SYSTEM = "system"
    TOOL = "tool"


class ConversationStatus(Enum):
    """Status da conversa"""
    ACTIVE = "active"
    PAUSED = "paused"
    CLOSED = "closed"
    ESCALATED = "escalated"


@dataclass
class Message:
    """Mensagem individual"""
    role: MessageRole
    content: str
    timestamp: datetime = field(default_factory=datetime.now)
    metadata: Dict[str, Any] = field(default_factory=dict)
    tool_calls: Optional[List[Dict]] = None
    tokens_used: int = 0

    def to_dict(self) -> Dict[str, Any]:
        return {
            "role": self.role.value,
            "content": self.content,
            "timestamp": self.timestamp.isoformat(),
            "metadata": self.metadata,
            "tokens_used": self.tokens_used
        }


@dataclass
class Conversation:
    """Conversa completa"""
    id: str
    user_id: str
    messages: List[Message] = field(default_factory=list)
    status: ConversationStatus = ConversationStatus.ACTIVE
    created_at: datetime = field(default_factory=datetime.now)
    updated_at: datetime = field(default_factory=datetime.now)
    metadata: Dict[str, Any] = field(default_factory=dict)
    summary: Optional[str] = None

    def add_message(self, message: Message):
        """Adiciona mensagem à conversa"""
        self.messages.append(message)
        self.updated_at = datetime.now()

    def get_last_messages(self, count: int = 10) -> List[Message]:
        """Retorna últimas mensagens"""
        return self.messages[-count:]

    def get_user_messages(self) -> List[Message]:
        """Retorna apenas mensagens do usuário"""
        return [m for m in self.messages if m.role == MessageRole.USER]

    def get_assistant_messages(self) -> List[Message]:
        """Retorna apenas mensagens do assistente"""
        return [m for m in self.messages if m.role == MessageRole.ASSISTANT]

    def total_tokens(self) -> int:
        """Total de tokens usados"""
        return sum(m.tokens_used for m in self.messages)

    def duration_seconds(self) -> float:
        """Duração da conversa em segundos"""
        if len(self.messages) < 2:
            return 0
        first = self.messages[0].timestamp
        last = self.messages[-1].timestamp
        return (last - first).total_seconds()

    def to_dict(self) -> Dict[str, Any]:
        return {
            "id": self.id,
            "user_id": self.user_id,
            "status": self.status.value,
            "message_count": len(self.messages),
            "total_tokens": self.total_tokens(),
            "duration_seconds": self.duration_seconds(),
            "created_at": self.created_at.isoformat(),
            "updated_at": self.updated_at.isoformat(),
            "summary": self.summary,
            "metadata": self.metadata
        }


@dataclass
class ConversationMetrics:
    """Métricas de conversa"""
    conversation_id: str
    total_messages: int = 0
    user_messages: int = 0
    assistant_messages: int = 0
    avg_response_time: float = 0.0
    total_tokens: int = 0
    satisfaction_score: Optional[float] = None

    def calculate_avg_response_time(self, messages: List[Message]):
        """Calcula tempo médio de resposta"""
        response_times = []
        for i in range(1, len(messages)):
            if messages[i].role == MessageRole.ASSISTANT and messages[i-1].role == MessageRole.USER:
                diff = (messages[i].timestamp - messages[i-1].timestamp).total_seconds()
                response_times.append(diff)

        if response_times:
            self.avg_response_time = sum(response_times) / len(response_times)