import time
from typing import List

from fastapi import APIRouter, HTTPException, BackgroundTasks, Request

from models import SessionData
from session_manager import session_manager
from session_auth import revoke_session_auth_token
from logging_config import (
    RequestContext,
    log_performance,
    log_request,
    log_session_operation,
)

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


@router.post("/sessions", response_model=SessionData)
async def create_session(request: Request):
    start_time = time.time()

    with RequestContext():
        try:
            log_request("POST", "/sessions", 200, 0, operation="create_session_start")

            session = await session_manager.create_session()

            duration_ms = (time.time() - start_time) * 1000
            log_session_operation(
                session.session_id, "created", duration_ms=duration_ms
            )
            log_performance(
                "create_session", duration_ms, session_id=session.session_id
            )

            return session
        except HTTPException as e:
            duration_ms = (time.time() - start_time) * 1000
            log_request(
                "POST", "/sessions", e.status_code, duration_ms, error=str(e.detail)
            )
            raise
        except Exception as e:
            duration_ms = (time.time() - start_time) * 1000
            log_request("POST", "/sessions", 500, duration_ms, error=str(e))
            raise HTTPException(
                status_code=500, detail=f"Failed to create session: {str(e)}"
            )


@router.get("/sessions/{session_id}", response_model=SessionData)
async def get_session(session_id: str, request: Request):
    start_time = time.time()

    with RequestContext():
        try:
            log_request(
                "GET", f"/sessions/{session_id}", 200, 0, operation="get_session_start"
            )

            session = await session_manager.get_session(session_id)
            if not session:
                duration_ms = (time.time() - start_time) * 1000
                log_request(
                    "GET",
                    f"/sessions/{session_id}",
                    404,
                    duration_ms,
                    session_id=session_id,
                )
                raise HTTPException(status_code=404, detail="Session not found")

            duration_ms = (time.time() - start_time) * 1000
            log_request(
                "GET",
                f"/sessions/{session_id}",
                200,
                duration_ms,
                session_id=session_id,
            )
            log_session_operation(session_id, "accessed", duration_ms=duration_ms)

            return session
        except HTTPException:
            raise
        except Exception as e:
            duration_ms = (time.time() - start_time) * 1000
            log_request(
                "GET", f"/sessions/{session_id}", 500, duration_ms, error=str(e)
            )
            raise HTTPException(
                status_code=500, detail=f"Failed to get session: {str(e)}"
            )


@router.get("/sessions", response_model=List[SessionData])
async def list_sessions():
    return await session_manager.list_sessions()


@router.delete("/sessions/{session_id}")
async def delete_session(session_id: str, background_tasks: BackgroundTasks):
    session = await session_manager.get_session(session_id)
    if not session:
        raise HTTPException(status_code=404, detail="Session not found")

    revoke_session_auth_token(session_id)

    background_tasks.add_task(session_manager.cleanup_expired_sessions)

    del session_manager.sessions[session_id]
    session_manager._save_sessions()

    return {"message": f"Session {session_id} scheduled for deletion"}


@router.post("/cleanup")
async def trigger_cleanup():
    await session_manager.cleanup_expired_sessions()
    return {"message": "Cleanup completed"}