# Import the ResponseModel
from typing import Any, Dict

from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from starlette import status
from starlette.requests import Request

from src.apps.auth.schemas.auth_schemas import (  # UserSchema,
    LoginRequest,
    LoginResponse,
)
from src.apps.auth.schemas.user_schemas import UserRegisterSchema
from src.apps.auth.services.auth_services import get_user, login_user, logout_user
from src.apps.auth.services.user_services import create_user
from src.apps.base.schemas.response_model import ResponseModel
from src.apps.files.models.file import File
from src.apps.user.models.user_model import Users
from src.apps.user.schemas.user_schemas import UserReturnSchema
from src.apps.user.services.user_services import get_user_by_user_id_service
from src.core.dependencies import get_db
from src.core.exceptions import APIException
from src.utils.enums import UserAccessLevel
from src.utils.guard import AuthGuard, get_current_user

router = APIRouter()


@router.post("/login", response_model=LoginResponse)
async def login(payload: LoginRequest, request: Request, db: Session = Depends(get_db)):
    """
    Authenticate user and return access token.
    """
    try:
        access_token, expires_at = await login_user(
            db=db,
            payload=payload,
            request=request,
        )

        return {"access_token": access_token, "token_type": "bearer", "expires_at": expires_at}
    except HTTPException as e:
        raise APIException(
            module=__name__,
            error={},
            status_code=status.HTTP_400_BAD_REQUEST,
            message=str(e),
        )
    except Exception as e:
        raise APIException(
            module=__name__,
            error={},
            status_code=status.HTTP_400_BAD_REQUEST,
            message=str(e),
        )


@router.get("/me", response_model=ResponseModel)
async def read_users_me(db: Session = Depends(get_db), current_user: Users = Depends(get_current_user)):
    result = UserReturnSchema.model_validate(current_user)
    return ResponseModel(data=result, status_code=status.HTTP_200_OK, message="User profile fetched successfully")


@router.post("/register", response_model=ResponseModel, status_code=status.HTTP_201_CREATED)
async def register_user_route(payload: UserRegisterSchema, db: Session = Depends(get_db)):
    """
    Register a new user (local or foreign visitor) .
    """
    # Remove await because create_user is sync
    created_user = await create_user(db, payload, access_level=UserAccessLevel.SUPER_ADMIN.value)
    return ResponseModel(
        data=created_user, status_code=status.HTTP_201_CREATED, message="Verification mail sent successfully"
    )


@router.post("/logout", response_model=ResponseModel)
async def logout(token: str = Depends(AuthGuard()), db: Session = Depends(get_db), other_sessions: bool = False):
    """
    Logout a user by invalidating their session
    """
    result = await logout_user(db=db, token=token, other_sessions=other_sessions)

    return ResponseModel(data=result, status_code=status.HTTP_200_OK, message="User logged out successfully")