"""
管理员后台路由
"""
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy.orm import Session
from typing import List, Optional
from ..core.database import get_db
from ..models.streamer import StreamerProfile
from ..schemas.user import UserResponse, UserUpdate, UserBalanceAdjust, UserBatchAction
from ..schemas.streamer import StreamerProfileResponse, StreamerProfileUpdate, StreamerStatistics
from ..schemas.system import SystemConfigResponse, SystemConfigCreate, SystemConfigUpdate, SystemConfigBatchUpdate
from ..schemas.announcement import AnnouncementResponse, AnnouncementCreate, AnnouncementUpdate
from ..services.user_service import UserService
from ..services.streamer_service import StreamerService
from ..services.system_service import SystemService
from ..services.announcement_service import AnnouncementService
from ..utils.deps import get_current_admin
router = APIRouter(prefix="/api/admin", tags=["admin"])


# ==================== 用户管理 ====================

@router.get("/users", response_model=List[UserResponse])
def get_users(
    page: int = Query(1, ge=1),
    size: int = Query(20, ge=1, le=100),
    search: Optional[str] = Query(None, description="搜索关键词"),
    role: Optional[str] = Query(None, description="角色筛选"),
    status: Optional[str] = Query(None, description="状态筛选"),
    sort: str = Query("created_at", description="排序字段"),
    order: str = Query("desc", description="排序方向"),
    db: Session = Depends(get_db),
    current_admin: UserService = Depends(get_current_admin)
):
    """获取用户列表（管理员）"""
    skip = (page - 1) * size
    return UserService.get_user_list(db, skip, size, search, role, status, sort, order)


@router.get("/users/{user_id}", response_model=UserResponse)
def get_user_detail(
    user_id: int,
    db: Session = Depends(get_db),
    current_admin: UserService = Depends(get_current_admin)
):
    """获取用户详情"""
    user = UserService.get_user_by_id(db, user_id)
    if not user:
        raise HTTPException(status_code=404, detail="用户不存在")
    return user


@router.put("/users/{user_id}", response_model=UserResponse)
def update_user(
    user_id: int,
    user_data: UserUpdate,
    db: Session = Depends(get_db),
    current_admin: UserService = Depends(get_current_admin)
):
    """更新用户信息"""
    user = UserService.get_user_by_id(db, user_id)
    if not user:
        raise HTTPException(status_code=404, detail="用户不存在")

    return UserService.update_user(db, user, user_data)


@router.post("/users/{user_id}/adjust-balance")
def adjust_user_balance(
    user_id: int,
    adjust_data: UserBalanceAdjust,
    db: Session = Depends(get_db),
    current_admin: UserService = Depends(get_current_admin)
):
    """调整用户余额"""
    user = UserService.get_user_by_id(db, user_id)
    if not user:
        raise HTTPException(status_code=404, detail="用户不存在")

    try:
        UserService.adjust_balance_with_version(db, user, adjust_data.amount, adjust_data.description, current_admin)
        return {"message": "余额调整成功", "new_balance": user.balance}
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))


@router.put("/users/{user_id}/set-role")
def set_user_role(
    user_id: int,
    role_data: dict,
    db: Session = Depends(get_db),
    current_admin: UserService = Depends(get_current_admin)
):
    """设置用户身份"""
    user = UserService.get_user_by_id(db, user_id)
    if not user:
        raise HTTPException(status_code=404, detail="用户不存在")
    
    # 检查请求数据
    new_role = role_data.get("role")
    if not new_role:
        raise HTTPException(status_code=400, detail="缺少角色参数")
    
    # 验证角色值是否有效
    valid_roles = ["USER", "STREAMER", "ADMIN"]
    if new_role not in valid_roles:
        raise HTTPException(status_code=400, detail=f"无效的角色值，有效值为: {', '.join(valid_roles)}")
    
    # 如果设置为主播角色，检查是否已有主播配置
    if new_role == "STREAMER":
        existing_streamer = db.query(StreamerProfile).filter(StreamerProfile.user_id == user_id).first()
        if not existing_streamer:
            # 自动创建默认的主播配置
            default_streamer = StreamerProfile(
                user_id=user_id,
                display_name=user.username,
                commission_rate=5.00,
                max_active_chests=10
            )
            db.add(default_streamer)
    
    # 更新用户角色
    user.role = new_role
    db.commit()
    db.refresh(user)
    
    return {"message": "用户身份设置成功", "user": user}


@router.post("/users/batch-action")
def batch_action_users(
    batch_data: UserBatchAction,
    db: Session = Depends(get_db),
    current_admin: UserService = Depends(get_current_admin)
):
    """批量操作用户"""
    try:
        affected_count = UserService.batch_action_users(db, batch_data.user_ids, batch_data.action, batch_data.reason)
        return {"message": f"成功操作 {affected_count} 个用户", "affected_count": affected_count}
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))


@router.get("/users/{user_id}/transactions", response_model=List[dict])
def get_user_transactions(
    user_id: int,
    page: int = Query(1, ge=1),
    size: int = Query(20, ge=1, le=100),
    db: Session = Depends(get_db),
    current_admin: UserService = Depends(get_current_admin)
):
    """获取用户交易流水"""
    user = UserService.get_user_by_id(db, user_id)
    if not user:
        raise HTTPException(status_code=404, detail="用户不存在")

    skip = (page - 1) * size
    return UserService.get_user_transactions_paginated(db, user_id, skip, size)


# ==================== 主播管理 ====================

@router.get("/streamers", response_model=List[StreamerProfileResponse])
def get_streamers(
    page: int = Query(1, ge=1),
    size: int = Query(20, ge=1, le=100),
    status: Optional[str] = Query(None, description="状态筛选"),
    sort: str = Query("created_at", description="排序字段"),
    order: str = Query("desc", description="排序方向"),
    db: Session = Depends(get_db),
    current_admin: UserService = Depends(get_current_admin)
):
    """获取主播列表"""
    skip = (page - 1) * size
    return StreamerService.get_streamer_list(db, skip, size, status, sort, order)


@router.get("/streamers/{streamer_id}", response_model=StreamerProfileResponse)
def get_streamer_detail(
    streamer_id: int,
    db: Session = Depends(get_db),
    current_admin: UserService = Depends(get_current_admin)
):
    """获取主播详情"""
    streamer = StreamerService.get_streamer_profile(db, streamer_id)
    if not streamer:
        raise HTTPException(status_code=404, detail="主播不存在")
    return streamer


@router.put("/streamers/{streamer_id}", response_model=StreamerProfileResponse)
def update_streamer(
    streamer_id: int,
    streamer_data: StreamerProfileUpdate,
    db: Session = Depends(get_db),
    current_admin: UserService = Depends(get_current_admin)
):
    """更新主播配置"""
    streamer = StreamerService.get_streamer_profile(db, streamer_id)
    if not streamer:
        raise HTTPException(status_code=404, detail="主播不存在")

    return StreamerService.update_streamer_profile(db, streamer, streamer_data)


@router.get("/streamers/{streamer_id}/stats", response_model=StreamerStatistics)
def get_streamer_statistics(
    streamer_id: int,
    db: Session = Depends(get_db),
    current_admin: UserService = Depends(get_current_admin)
):
    """获取主播统计"""
    return StreamerService.get_streamer_statistics(db, streamer_id)


@router.get("/streamers/{streamer_id}/chests")
def get_streamer_chests(
    streamer_id: int,
    page: int = Query(1, ge=1),
    size: int = Query(20, ge=1, le=100),
    status: Optional[str] = Query(None, description="状态筛选"),
    db: Session = Depends(get_db),
    current_admin: UserService = Depends(get_current_admin)
):
    """获取主播宝箱列表"""
    skip = (page - 1) * size
    return StreamerService.get_streamer_chests(db, streamer_id, skip, size, status)


# ==================== 系统设置 ====================

@router.get("/system/configs", response_model=List[SystemConfigResponse])
def get_system_configs(
    db: Session = Depends(get_db),
    current_admin: UserService = Depends(get_current_admin)
):
    """获取所有系统配置"""
    return SystemService.get_all_configs(db)


@router.post("/system/configs", response_model=SystemConfigResponse)
def create_system_config(
    config_data: SystemConfigCreate,
    db: Session = Depends(get_db),
    current_admin: UserService = Depends(get_current_admin)
):
    """创建系统配置"""
    return SystemService.create_config(db, config_data)


@router.put("/system/configs/{config_key}", response_model=SystemConfigResponse)
def update_system_config(
    config_key: str,
    config_data: SystemConfigUpdate,
    db: Session = Depends(get_db),
    current_admin: UserService = Depends(get_current_admin)
):
    """更新系统配置"""
    config = SystemService.get_config(db, config_key)
    if not config:
        raise HTTPException(status_code=404, detail="配置不存在")

    return SystemService.update_config(db, config_key, config_data)


@router.delete("/system/configs/{config_key}")
def delete_system_config(
    config_key: str,
    db: Session = Depends(get_db),
    current_admin: UserService = Depends(get_current_admin)
):
    """删除系统配置"""
    success = SystemService.delete_config(db, config_key)
    if not success:
        raise HTTPException(status_code=404, detail="配置不存在")
    return {"message": "配置删除成功"}


@router.put("/system/configs/batch")
def batch_update_configs(
    batch_data: SystemConfigBatchUpdate,
    db: Session = Depends(get_db),
    current_admin: UserService = Depends(get_current_admin)
):
    """批量更新配置"""
    updated_count = SystemService.batch_update_configs(db, batch_data.configs)
    return {"message": f"成功更新 {updated_count} 项配置", "updated_count": updated_count}


# ==================== 公告管理 ====================

@router.get("/announcements", response_model=List[AnnouncementResponse])
def get_announcements(
    page: int = Query(1, ge=1),
    size: int = Query(20, ge=1, le=100),
    include_expired: bool = Query(False, description="包含过期公告"),
    db: Session = Depends(get_db),
    current_admin: UserService = Depends(get_current_admin)
):
    """获取公告列表"""
    skip = (page - 1) * size
    return AnnouncementService.get_announcements(db, skip, size, include_expired)


@router.post("/announcements", response_model=AnnouncementResponse)
def create_announcement(
    announcement_data: AnnouncementCreate,
    db: Session = Depends(get_db),
    current_admin: UserService = Depends(get_current_admin)
):
    """创建公告"""
    return AnnouncementService.create_announcement(db, announcement_data)


@router.put("/announcements/{announcement_id}", response_model=AnnouncementResponse)
def update_announcement(
    announcement_id: int,
    announcement_data: AnnouncementUpdate,
    db: Session = Depends(get_db),
    current_admin: UserService = Depends(get_current_admin)
):
    """更新公告"""
    announcement = AnnouncementService.get_announcement(db, announcement_id)
    if not announcement:
        raise HTTPException(status_code=404, detail="公告不存在")

    return AnnouncementService.update_announcement(db, announcement, announcement_data)


@router.delete("/announcements/{announcement_id}")
def delete_announcement(
    announcement_id: int,
    db: Session = Depends(get_db),
    current_admin: UserService = Depends(get_current_admin)
):
    """删除公告"""
    success = AnnouncementService.delete_announcement(db, announcement_id)
    if not success:
        raise HTTPException(status_code=404, detail="公告不存在")
    return {"message": "公告删除成功"}