from fastapi import APIRouter, Depends, Query
from sqlalchemy.orm import Session

from app.application.feishu.personal_data import FeishuPersonalDataService
from app.core.database import get_db
from app.core.security import ApiPrincipal, require_api_key
from app.modules.feishu_users.constants import FeishuUserRole, FeishuUserStatus
from app.modules.feishu_users.schemas import (
    FeishuUserListRead,
    FeishuUserRead,
    FeishuUserUpdate,
)
from app.modules.feishu_users.services import FeishuUserManagementService
from app.modules.personalization.schemas import ErasureResult

router = APIRouter(prefix="/users", dependencies=[Depends(require_api_key)])


@router.get("", response_model=FeishuUserListRead)
def list_users(
    role: FeishuUserRole | None = None,
    status_filter: FeishuUserStatus | None = Query(default=None, alias="status"),
    tenant_key: str | None = None,
    limit: int = Query(default=100, ge=1, le=500),
    offset: int = Query(default=0, ge=0),
    db: Session = Depends(get_db),
    principal: ApiPrincipal = Depends(require_api_key),
) -> dict:
    items, total = FeishuUserManagementService(db).list_users(
        role=role,
        status_filter=status_filter,
        tenant_key=tenant_key,
        limit=limit,
        offset=offset,
        actor=principal.actor,
    )
    return {
        "items": items,
        "total": total,
        "limit": limit,
        "offset": offset,
    }


@router.get("/{code}", response_model=FeishuUserRead)
def get_user(
    code: str,
    db: Session = Depends(get_db),
    principal: ApiPrincipal = Depends(require_api_key),
) -> FeishuUserRead:
    return FeishuUserManagementService(db).get_user(
        code,
        actor=principal.actor,
    )


@router.patch("/{code}", response_model=FeishuUserRead)
def update_user(
    code: str,
    payload: FeishuUserUpdate,
    db: Session = Depends(get_db),
    principal: ApiPrincipal = Depends(require_api_key),
) -> FeishuUserRead:
    return FeishuUserManagementService(db).update_user(
        code,
        changes=payload.model_dump(exclude_unset=True),
        actor=principal.actor,
    )


@router.delete("/{code}/personal-data", response_model=ErasureResult)
def erase_user_personal_data(
    code: str,
    db: Session = Depends(get_db),
    principal: ApiPrincipal = Depends(require_api_key),
) -> ErasureResult:
    return FeishuPersonalDataService(db).erase_by_user_code(
        code,
        actor=principal.actor,
    )