src/api/routes/login.py

from fastapi import APIRouter, Depends, HTTPException, status
from sqlmodel.ext.asyncio.session import AsyncSession

from ...auth.dependencies import get_current_user
from ...services.user_service import UserService
from ...models import UserResponse
from ...db.database import get_session
import logging

logger = logging.getLogger(__name__)

router = APIRouter(prefix="/profile", tags=["Profile"])

@router.get("/me", response_model=UserResponse)
async def get_my_profile(
    current_user = Depends(get_current_user),
    session: AsyncSession = Depends(get_session),
):
    """
    Get current user profile. This route is PROTECTED.
    
    Args:
        current_user: Injected by JWT authentication dependency
        
    Returns:
        UserResponse with user profile data
    """
    try:
        user_id = int(current_user["user_id"])
        user = await UserService.get_user_by_id(user_id, session)
        
        if user is None:
            raise HTTPException(
                status_code=status.HTTP_404_NOT_FOUND,
                detail="User not found"
            )
        
        return user
        
    except ValueError:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="Invalid user ID"
        )
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Error fetching profile: {e}", exc_info=True)
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail="Failed to fetch profile"
        )

@router.post("/logout")
async def logout(
    current_user = Depends(get_current_user),
    session: AsyncSession = Depends(get_session),
):
    """
    Logout current user by closing all active sessions.
    
    Args:
        current_user: Injected by JWT authentication dependency
        
    Returns:
        Success message
    """
    try:
        user_id = int(current_user["user_id"])
        await UserService.log_logout(user_id, session)
        
        logger.info(f"User logged out: {user_id}")
        return {
            "message": "Logged out successfully",
            "user_id": user_id
        }
        
    except Exception as e:
        logger.error(f"Logout error: {e}", exc_info=True)
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail="Failed to logout"
        )

@router.get("/sessions")
async def get_active_sessions(
    current_user = Depends(get_current_user),
    session: AsyncSession = Depends(get_session),
):
    """
    Get all active sessions for the current user.
    
    Args:
        current_user: Injected by JWT authentication dependency
        
    Returns:
        List of active sessions
    """
    try:
        user_id = int(current_user["user_id"])
        sessions = await UserService.get_active_sessions(user_id, session)
        
        return {
            "user_id": user_id,
            "active_sessions": sessions,
            "count": len(sessions)
        }
        
    except Exception as e:
        logger.error(f"Error fetching sessions: {e}", exc_info=True)
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail="Failed to fetch sessions"
        )

@router.get("/sessions/history")
async def get_session_history(
    current_user = Depends(get_current_user),
    limit: int = 10,
    session: AsyncSession = Depends(get_session),
):
    """
    Get login/logout history for the current user.
    
    Args:
        current_user: Injected by JWT authentication dependency
        limit: Maximum number of sessions to return (default: 10)
        
    Returns:
        List of session history
    """
    try:
        user_id = int(current_user["user_id"])
        history = await UserService.get_user_session_history(user_id, session, limit)
        
        return {
            "user_id": user_id,
            "session_history": history,
            "count": len(history)
        }
        
    except Exception as e:
        logger.error(f"Error fetching session history: {e}", exc_info=True)
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail="Failed to fetch session history"
        )