"""
Pydantic models for AI-related API requests and responses
"""

from typing import List, Optional, Dict, Any
from pydantic import BaseModel, Field
from enum import Enum

class AICommand(str, Enum):
    """Supported AI commands"""
    EXPLAIN = "explain"
    REFACTOR = "refactor"
    FIX = "fix"
    COMPLETE = "complete"
    COMMENT = "comment"
    TEST = "test"
    OPTIMIZE = "optimize"
    DOCUMENT = "document"

class LanguageType(str, Enum):
    """Supported programming languages"""
    PYTHON = "python"
    JAVASCRIPT = "javascript"
    TYPESCRIPT = "typescript"
    JAVA = "java"
    GO = "go"
    RUST = "rust"
    CPP = "cpp"
    C = "c"
    CSHARP = "csharp"
    PHP = "php"
    RUBY = "ruby"
    SWIFT = "swift"
    KOTLIN = "kotlin"
    SCALA = "scala"
    HTML = "html"
    CSS = "css"
    SQL = "sql"
    SHELL = "shell"
    MARKDOWN = "markdown"
    YAML = "yaml"
    JSON = "json"
    XML = "xml"

class AIRequest(BaseModel):
    """Base AI request model"""
    command: AICommand
    code: str = Field(..., description="The code to process")
    language: Optional[LanguageType] = Field(None, description="Programming language")
    context: Optional[str] = Field(None, description="Additional context")
    file_path: Optional[str] = Field(None, description="File path for context")
    selection: Optional[Dict[str, int]] = Field(None, description="Code selection range")
    model: Optional[str] = Field(None, description="LLM model to use")
    
class AIResponse(BaseModel):
    """AI response model"""
    success: bool
    result: str
    suggestions: Optional[List[str]] = None
    metadata: Optional[Dict[str, Any]] = None
    execution_time: Optional[float] = None
    model_used: Optional[str] = None

class CodeCompletionRequest(BaseModel):
    """Code completion specific request"""
    code: str = Field(..., description="Code context for completion")
    cursor_position: int = Field(..., description="Cursor position in code")
    language: Optional[LanguageType] = None
    max_tokens: Optional[int] = Field(50, description="Maximum tokens to generate")
    
class CodeCompletionResponse(BaseModel):
    """Code completion response"""
    success: bool
    completions: List[str]
    cursor_position: int
    execution_time: Optional[float] = None

class ExplainRequest(BaseModel):
    """Code explanation request"""
    code: str = Field(..., description="Code to explain")
    language: Optional[LanguageType] = None
    detail_level: Optional[str] = Field("medium", description="Detail level: brief, medium, detailed")
    
class RefactorRequest(BaseModel):
    """Code refactoring request"""
    code: str = Field(..., description="Code to refactor")
    language: Optional[LanguageType] = None
    refactor_type: Optional[str] = Field("general", description="Type of refactoring")
    
class FixRequest(BaseModel):
    """Code fix request"""
    code: str = Field(..., description="Code with issues to fix")
    language: Optional[LanguageType] = None
    error_message: Optional[str] = Field(None, description="Error message if available")
    
class MultiFileRequest(BaseModel):
    """Multi-file analysis request"""
    files: List[Dict[str, str]] = Field(..., description="List of files with path and content")
    command: AICommand
    context: Optional[str] = None
    focus_file: Optional[str] = Field(None, description="Primary file to focus on")
    
class ModelInfo(BaseModel):
    """Model information"""
    name: str
    size: str
    description: Optional[str] = None
    capabilities: List[str] = []
    is_available: bool = True
    
class ModelListResponse(BaseModel):
    """Model list response"""
    models: List[ModelInfo]
    default_model: str
    current_model: Optional[str] = None