"""
Modele Pydantic pentru Page Asist
"""
from pydantic import BaseModel, Field, validator
from typing import List, Optional, Dict, Any
from datetime import datetime
import re


class Agent(BaseModel):
    """Model pentru configurarea unui agent AI"""
    ip: str = Field(..., description="Adresa IP a serverului Ollama")
    port: str = Field(default="11434", description="Port server Ollama")
    rol: str = Field(..., description="Rolul agentului: generator/critic/moderator/sintetizator")
    model: str = Field(..., description="Modelul Ollama de utilizat")
    max_tokens: int = Field(default=700, ge=50, le=4000, description="Limita de tokeni pentru răspuns")
    timeout: int = Field(default=120, ge=10, le=600, description="Timeout pentru cereri în secunde")
    
    @validator('ip')
    def validate_ip(cls, v):
        """Validare format IP"""
        pattern = r'^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$'
        if not re.match(pattern, v):
            raise ValueError('Format IP invalid')
        return v
    
    @validator('rol')
    def validate_rol(cls, v):
        """Validare rol agent"""
        roluri_valide = ['generator', 'critic', 'moderator', 'sintetizator']
        if v.lower() not in roluri_valide:
            raise ValueError(f'Rol invalid. Opțiuni valide: {", ".join(roluri_valide)}')
        return v.lower()
    
    @property
    def url(self) -> str:
        """Returnează URL-ul complet al agentului"""
        return f"{self.ip}:{self.port}"


class ConversationConfig(BaseModel):
    """Configurare conversație"""
    subiect: str = Field(..., min_length=3, description="Tema de discuție")
    numar_runde: int = Field(..., ge=1, le=100, description="Numărul de runde")
    pauza_intre_runde: int = Field(default=3, ge=0, le=60, description="Pauza între runde în secunde")
    agenti: List[Agent] = Field(..., min_items=2, description="Lista de agenți AI")
    
    @validator('agenti')
    def validate_agenti(cls, v):
        """Validare listă agenți - minim 2"""
        if len(v) < 2:
            raise ValueError('Sunt necesari minim 2 agenți')
        return v


class Message(BaseModel):
    """Model pentru un mesaj în conversație"""
    rol: str
    content: str
    timestamp: datetime = Field(default_factory=datetime.now)
    agent_url: Optional[str] = None
    agent_role: Optional[str] = None
    tokens: Optional[int] = None
    idei_noi: Optional[int] = None


class ConversationState(BaseModel):
    """Starea curentă a conversației"""
    id: str
    config: ConversationConfig
    runda_curenta: int = 0
    mesaje: List[Message] = []
    registry_idei: Dict[str, bool] = {}
    is_running: bool = False
    start_time: Optional[datetime] = None
    end_time: Optional[datetime] = None


class ModelListResponse(BaseModel):
    """Răspuns pentru lista de modele disponibile"""
    success: bool
    models: List[str] = []
    error: Optional[str] = None


class ConversationHistoryItem(BaseModel):
    """Item pentru istoric conversații"""
    id: str
    subiect: str
    start_time: datetime
    end_time: Optional[datetime]
    numar_runde: int
    numar_agenti: int
    total_mesaje: int


class StreamMessage(BaseModel):
    """Mesaj pentru streaming WebSocket"""
    type: str  # "message", "round_start", "round_end", "conversation_end", "error"
    data: Dict[str, Any]