from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select
from fastcrud import FastCRUD

from database import get_db
from models import Role, User
from schemas import RoleCreate, RoleResponse
from middleware import get_current_user
from utils.like_filter import ilike_contains

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

# 创建FastCRUD实例
role_crud = FastCRUD(Role, RoleResponse)


@router.post("/", response_model=RoleResponse)
async def create_role(
    role_data: RoleCreate,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    """创建角色"""
    # 检查角色名是否已存在
    from sqlalchemy import select

    result = await db.execute(select(Role).filter(Role.name == role_data.name))
    existing_role = result.scalar_one_or_none()
    if existing_role:
        raise HTTPException(status_code=400, detail="角色名已存在")

    # 准备创建数据
    create_data = role_data.model_dump()

    # 使用FastCRUD创建角色
    created_role = await role_crud.create(db, create_data)
    return created_role


@router.get("/", response_model=list[RoleResponse])
async def get_roles(
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
    name: str | None = Query(None, description="角色名称，模糊匹配"),
):
    """获取角色列表；支持按名称模糊查询"""
    stmt = select(Role)
    cond = ilike_contains(Role.name, name)
    if cond is not None:
        stmt = stmt.where(cond)
    result = await db.execute(stmt)
    rows = result.scalars().all()
    return [RoleResponse.model_validate(r) for r in rows]


@router.get("/{role_id}", response_model=RoleResponse)
async def get_role(
    role_id: int,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    """获取单个角色"""
    role = await role_crud.get(db, {"id": role_id})
    if not role:
        raise HTTPException(status_code=404, detail="角色不存在")
    return role


@router.put("/{role_id}", response_model=RoleResponse)
async def update_role(
    role_id: int,
    role_data: RoleCreate,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    """更新角色"""
    # 检查角色名是否被其他角色使用
    from sqlalchemy import select

    result = await db.execute(
        select(Role).filter(Role.name == role_data.name, Role.id != role_id)
    )
    existing_role = result.scalar_one_or_none()
    if existing_role:
        raise HTTPException(status_code=400, detail="角色名已存在")

    # 准备更新数据
    update_data = role_data.model_dump()

    # 使用FastCRUD更新角色
    updated_role = await role_crud.update(db, {"id": role_id}, update_data)
    if not updated_role:
        raise HTTPException(status_code=404, detail="角色不存在")
    return updated_role


@router.delete("/{role_id}")
async def delete_role(
    role_id: int,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    """删除角色"""
    # 检查是否有用户使用此角色
    from sqlalchemy import select

    result = await db.execute(select(User).filter(User.role_id == role_id))
    users = result.scalars().all()
    if users:
        raise HTTPException(
            status_code=400, detail=f"该角色正在被 {len(users)} 个用户使用，无法删除"
        )

    # 使用FastCRUD删除角色
    deleted = await role_crud.delete(db, {"id": role_id})
    if not deleted:
        raise HTTPException(status_code=404, detail="角色不存在")
    return {"message": "角色删除成功"}