"""Bot API endpoints"""
from fastapi import APIRouter, HTTPException
from logger import logger

# Import shared models with fallback handling
try:
    from ...shared.models import (
        BotProviderRegisterRequest,
        BotProviderRegisterResponse,
        BotProviderListResponse,
        BotListResponse,
        BotJoinLobbyRequest,
        BotJoinLobbyResponse,
        BotLeaveLobbyRequest,
        BotLeaveLobbyResponse,
    )
except ImportError:
    try:
        from shared.models import (
            BotProviderRegisterRequest,
            BotProviderRegisterResponse,
            BotProviderListResponse,
            BotListResponse,
            BotJoinLobbyRequest,
            BotJoinLobbyResponse,
            BotLeaveLobbyRequest,
            BotLeaveLobbyResponse,
        )
    except ImportError:
        # Create dummy models for standalone testing
        from pydantic import BaseModel
        from typing import List, Dict, Optional
        
        class BotProviderRegisterRequest(BaseModel):
            base_url: str
            name: str
            description: str
            provider_key: str
        
        class BotProviderRegisterResponse(BaseModel):
            provider_id: str
        
        class BotProviderListResponse(BaseModel):
            providers: List[dict]
        
        class BotListResponse(BaseModel):
            bots: List[dict]
            providers: Dict[str, str]
        
        class BotJoinLobbyRequest(BaseModel):
            lobby_id: str
            provider_id: Optional[str] = None
            nick: Optional[str] = None
        
        class BotJoinLobbyResponse(BaseModel):
            status: str
            bot_name: str
            run_id: str
            provider_id: str
        
        class BotLeaveLobbyRequest(BaseModel):
            session_id: str
        
        class BotLeaveLobbyResponse(BaseModel):
            status: str
            session_id: str
            run_id: Optional[str] = None


def create_bot_router(bot_manager, session_manager, lobby_manager):
    """Create bot API router with dependencies"""
    
    router = APIRouter(prefix="/bots", tags=["bots"])
    
    @router.post("/providers/register", response_model=BotProviderRegisterResponse)
    async def register_bot_provider(request: BotProviderRegisterRequest) -> BotProviderRegisterResponse:
        """Register a new bot provider with authentication"""
        try:
            return await bot_manager.register_provider(request)
        except ValueError as e:
            if "Invalid provider key" in str(e):
                raise HTTPException(status_code=403, detail=str(e))
            else:
                raise HTTPException(status_code=400, detail=str(e))
    
    @router.get("/providers", response_model=BotProviderListResponse)
    async def list_bot_providers() -> BotProviderListResponse:
        """List all registered bot providers"""
        return bot_manager.list_providers()
    
    @router.get("", response_model=BotListResponse)
    async def list_available_bots() -> BotListResponse:
        """List all available bots from all registered providers"""
        return await bot_manager.list_bots()
    
    @router.post("/{bot_name}/join", response_model=BotJoinLobbyResponse)
    async def request_bot_join_lobby(bot_name: str, request: BotJoinLobbyRequest) -> BotJoinLobbyResponse:
        """Request a bot to join a specific lobby"""
        try:
            return await bot_manager.request_bot_join(bot_name, request, session_manager, lobby_manager)
        except ValueError as e:
            if "not found" in str(e).lower():
                raise HTTPException(status_code=404, detail=str(e))
            elif "timeout" in str(e).lower():
                raise HTTPException(status_code=504, detail=str(e))
            elif "provider error" in str(e).lower():
                raise HTTPException(status_code=502, detail=str(e))
            else:
                raise HTTPException(status_code=500, detail=str(e))
    
    @router.post("/leave", response_model=BotLeaveLobbyResponse)
    async def request_bot_leave_lobby(request: BotLeaveLobbyRequest) -> BotLeaveLobbyResponse:
        """Request a bot to leave from all lobbies and disconnect"""
        try:
            return await bot_manager.request_bot_leave(request, session_manager)
        except ValueError as e:
            if "not found" in str(e).lower():
                raise HTTPException(status_code=404, detail=str(e))
            elif "not a bot" in str(e).lower():
                raise HTTPException(status_code=400, detail=str(e))
            else:
                raise HTTPException(status_code=500, detail=str(e))
    
    return router