"""User listing and deletion endpoints."""

import uuid

from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy import func, select
from sqlalchemy.ext.asyncio import AsyncSession

from app.config import GLOBAL_USER_ID
from app.dependencies import get_db
from app.models.face import FaceEmbedding
from app.models.garment import Garment
from app.models.user import User
from app.schemas.user import (
    UserCreateRequest,
    UserCreateResponse,
    UserDeleteResponse,
    UserListResponse,
    UserSummary,
)
from app.services.user_service import get_or_create_user
from app.utils.image import delete_user_storage

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


@router.get("", response_model=UserListResponse)
async def list_users(
    db: AsyncSession = Depends(get_db),
):
    """List all registered users with garment counts."""
    query = (
        select(
            User.id,
            User.name,
            func.count(Garment.id).label("garment_count"),
        )
        .outerjoin(Garment, Garment.user_id == User.id)
        .group_by(User.id)
        .order_by(User.name)
    )

    result = await db.execute(query)
    rows = result.all()

    users = [
        UserSummary(
            id=row.id,
            name=row.name,
            garment_count=row.garment_count,
        )
        for row in rows
    ]

    return UserListResponse(users=users)


@router.post("", response_model=UserCreateResponse)
async def create_user(
    body: UserCreateRequest,
    db: AsyncSession = Depends(get_db),
):
    """Get or create a user by name.

    If a user with the given name already exists, returns that user.
    Otherwise creates a new one. Name must be unique among non-global users.
    """
    user, created = await get_or_create_user(db, body.name)
    await db.commit()
    return UserCreateResponse(user_id=user.id, name=user.name, created=created)


@router.delete("/{user_id}", response_model=UserDeleteResponse)
async def delete_user(
    user_id: uuid.UUID,
    db: AsyncSession = Depends(get_db),
):
    """Delete a user and all associated data (garments, faces, images).

    The global user (00000000-...) cannot be deleted.
    """
    if user_id == GLOBAL_USER_ID:
        raise HTTPException(status_code=400, detail="unknown 사용자는 삭제할 수 없습니다.")

    result = await db.execute(select(User).where(User.id == user_id))
    user = result.scalar_one_or_none()
    if user is None:
        raise HTTPException(status_code=404, detail="사용자를 찾을 수 없습니다.")

    # Count related records before cascade deletion
    garment_count = (await db.execute(
        select(func.count()).where(Garment.user_id == user_id)
    )).scalar_one()
    face_count = (await db.execute(
        select(func.count()).where(FaceEmbedding.user_id == user_id)
    )).scalar_one()

    # Delete user (cascades to garments + face_embeddings)
    await db.delete(user)
    await db.commit()

    # Delete all storage files for this user
    deleted_files = delete_user_storage(user_id)

    return UserDeleteResponse(
        user_id=user_id,
        deleted_garments=garment_count,
        deleted_faces=face_count,
        deleted_files=deleted_files,
    )