from __future__ import annotations

from fastapi import APIRouter, Depends, Query
from sqlalchemy.ext.asyncio import AsyncSession

from app.api.deps import get_session
from app.core.constants import Role
from app.core.dependencies import get_current_user_id, require_role
from app.schemas.common import PaginatedResponse
from app.schemas.user import UserCreate, UserRead, UserUpdate
from app.services.user_service import UserService

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


@router.get("/me", response_model=UserRead)
async def get_me(
    user_id: int = Depends(get_current_user_id),
    session: AsyncSession = Depends(get_session),
) -> UserRead:
    service = UserService(session)
    return await service.get_user(user_id)


@router.patch("/me", response_model=UserRead)
async def update_me(
    body: UserUpdate,
    user_id: int = Depends(get_current_user_id),
    session: AsyncSession = Depends(get_session),
) -> UserRead:
    body.role = None
    body.is_active = None
    service = UserService(session)
    return await service.update_user(user_id, body)


@router.get("", response_model=PaginatedResponse[UserRead])
async def list_users(
    page: int = Query(1, ge=1),
    size: int = Query(20, ge=1, le=100),
    _: dict = Depends(require_role(Role.SUPERADMIN, Role.ADMIN)),
    session: AsyncSession = Depends(get_session),
) -> PaginatedResponse[UserRead]:
    service = UserService(session)
    skip = (page - 1) * size
    items = await service.list_users(skip=skip, limit=size)
    total = await service.count_users()
    return PaginatedResponse(
        items=items, total=total, page=page, size=size, pages=(total + size - 1) // size
    )


@router.get("/{user_id}", response_model=UserRead)
async def get_user(
    user_id: int,
    _: dict = Depends(require_role(Role.SUPERADMIN, Role.ADMIN)),
    session: AsyncSession = Depends(get_session),
) -> UserRead:
    service = UserService(session)
    return await service.get_user(user_id)


@router.post("", response_model=UserRead, status_code=201)
async def create_user(
    body: UserCreate,
    _: dict = Depends(require_role(Role.SUPERADMIN, Role.ADMIN)),
    session: AsyncSession = Depends(get_session),
) -> UserRead:
    service = UserService(session)
    return await service.create_user(body)


@router.patch("/{user_id}", response_model=UserRead)
async def update_user(
    user_id: int,
    body: UserUpdate,
    _: dict = Depends(require_role(Role.SUPERADMIN, Role.ADMIN)),
    session: AsyncSession = Depends(get_session),
) -> UserRead:
    service = UserService(session)
    return await service.update_user(user_id, body)


@router.delete("/{user_id}", status_code=204)
async def delete_user(
    user_id: int,
    _: dict = Depends(require_role(Role.SUPERADMIN, Role.ADMIN)),
    session: AsyncSession = Depends(get_session),
) -> None:
    service = UserService(session)
    await service.delete_user(user_id)