"""Bot connection API endpoints."""

import asyncio
import time
from typing import Any, Dict

from fastapi import APIRouter, Request, HTTPException
from loguru import logger

from bot import run_bot_webrtc_global_agent
from utils.daily_client import DailyClient, DailyAPIError
from utils.logging_config import log_error
from utils.redis_client import add_active_session, remove_active_session, cleanup_pod_sessions, redis_available, _get_pod_name
from utils.pod_lifecycle import on_session_complete

router = APIRouter(tags=["bot"])

# Daily client instance
daily_client = DailyClient()

# Track active sessions: {task: room_name}
active_sessions: dict[asyncio.Task, str] = {}


def get_active_sessions() -> dict:
    """Get reference to active sessions for cleanup."""
    return active_sessions


async def cleanup_active_sessions():
    """Cleanup active sessions on shutdown."""
    if active_sessions:
        logger.info(f"SHUTDOWN_CLEANUP: active_sessions={len(active_sessions)}")
        rooms_to_delete = list(active_sessions.values())
        
        # Cancel all bot tasks
        for task in list(active_sessions.keys()):
            task.cancel()
        await asyncio.gather(*active_sessions.keys(), return_exceptions=True)
        
        # Delete all rooms from Daily
        for room_name in rooms_to_delete:
            await daily_client.delete_room(room_name)
        
        logger.info(f"SHUTDOWN_CLEANUP_DONE: deleted_rooms={len(rooms_to_delete)}")
    
    # Cleanup Redis sessions for this pod
    if redis_available():
        pod_name = _get_pod_name()
        if pod_name:
            cleaned_count = await cleanup_pod_sessions(pod_name)
            logger.info(f"REDIS_SHUTDOWN_CLEANUP: pod={pod_name} sessions_cleaned={cleaned_count}")


@router.post("/connect-webrtc-global-agent")
async def bot_connect_webrtc_global_agent(request: Request) -> Dict[Any, Any]:
    """WebRTC (Daily) connection endpoint for Global Agent Bot or Character."""
    device_id = None
    try:
        version = None
        character_id = None
        try:
            body = await request.json()
            device_id = body.get("device_id")
            version = body.get("version")  # Optional: "explore" to enable video
            character_id = body.get("character_id")  # Optional: character ID for character sessions
        except:
            pass

        # Log session start with character info if provided
        if character_id:
            logger.info(f"SESSION_START: device_id={device_id or 'common'} version={version} character_id={character_id}")
        else:
            logger.info(f"SESSION_START: device_id={device_id or 'common'} version={version} (Maya)")

        room_creation_start = time.time()
        room_url, room_name, token = await daily_client.create_room_with_token()
        room_token_time = time.time() - room_creation_start

        logger.info(f"ROOM_CREATED: device_id={device_id or 'common'} room_name={room_name} character={character_id or 'maya'} time={room_token_time:.3f}s")

        task = asyncio.create_task(run_bot_webrtc_global_agent(
            room_url, token, device_id, room_name, 
            version=version, 
            character_id=character_id
        ))
        active_sessions[task] = room_name
        
        # Add to Redis session tracking
        if redis_available():
            await add_active_session(room_name, device_id, character_id)
        
        # Remove from both local dict and Redis when task completes
        # Capture room_name in closure
        def cleanup_session(t):
            room = active_sessions.pop(t, None)
            on_session_complete(active_sessions)
            if room and redis_available():
                # Run async cleanup in background
                try:
                    loop = asyncio.get_event_loop()
                    if loop.is_running():
                        # Schedule async cleanup task
                        asyncio.create_task(remove_active_session(room))
                        logger.info(f"REDIS_CLEANUP_SCHEDULED: room={room}")
                    else:
                        # Loop not running (shutdown) - skip Redis cleanup
                        logger.warning(f"REDIS_CLEANUP_SKIPPED: room={room} reason=loop_not_running")
                except RuntimeError:
                    # No event loop - skip Redis cleanup (pod shutting down)
                    logger.warning(f"REDIS_CLEANUP_SKIPPED: room={room} reason=no_event_loop")
                except Exception as e:
                    logger.error(f"REDIS_CLEANUP_CALLBACK_ERROR: room={room} error={e}")
        
        task.add_done_callback(cleanup_session)

        return {"room_url": room_url, "token": token}

    except DailyAPIError as e:
        log_error("DAILY_API_FAILED", e, device_id=device_id or "common", endpoint="/connect-webrtc-global-agent")
        raise HTTPException(status_code=e.status_code or 500, detail=e.message)
    except Exception as e:
        log_error("SESSION_START_FAILED", e, device_id=device_id or "common", endpoint="/connect-webrtc-global-agent")
        raise HTTPException(status_code=500, detail=str(e))