#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
User API - 用户接口
"""
from typing import List, Optional

from fastapi import APIRouter, Depends, HTTPException, Query, UploadFile, File
from fastapi.responses import StreamingResponse
from sqlalchemy.ext.asyncio import AsyncSession

from app.database import get_db
from app.config import settings
from app.base_schema import PaginatedResponse, ResponseModel
from core.user.schema import (
    UserCreate, UserUpdate, UserResponse, UserSimple, OrgChartNode, OrgChartChainNode,
    UserPasswordResetIn, UserPasswordSetIn,
    UserBatchDeleteIn, UserBatchDeleteOut,
    UserBatchUpdateStatusIn, UserBatchUpdateStatusOut,
    UserProfileUpdateIn
)
from core.user.service import UserService
from utils.security import get_current_user, get_current_user_id

router = APIRouter(prefix="/user", tags=["用户管理"])


@router.post("", response_model=UserResponse, summary="创建用户")
async def create_user(data: UserCreate, db: AsyncSession = Depends(get_db)):
    """创建用户"""
    # 用户名唯一性校验
    if not await UserService.check_unique(db, field="username", value=data.username):
        raise HTTPException(status_code=400, detail="用户名已存在")

    # 邮箱唯一性校验
    if data.email:
        if not await UserService.check_unique(db, field="email", value=data.email):
            raise HTTPException(status_code=400, detail="邮箱已存在")

    # 手机号唯一性校验
    if data.mobile:
        if not await UserService.check_unique(db, field="mobile", value=data.mobile):
            raise HTTPException(status_code=400, detail="手机号已存在")

    user = await UserService.create(db=db, data=data)

    # 构建响应并添加 role_ids
    user_dict = _build_user_response(user).model_dump()
    role_ids = await UserService.get_user_role_ids(db, user.id)
    user_dict['role_ids'] = role_ids
    return user_dict


@router.get("", response_model=PaginatedResponse[UserResponse], summary="获取用户列表")
async def get_user_list(
        page: int = Query(default=1, ge=1, description="页码"),
        page_size: int = Query(default=settings.PAGE_SIZE, ge=1, le=settings.PAGE_MAX_SIZE, alias="pageSize",
                               description="每页数量"),
        name: Optional[str] = Query(None, description="姓名"),
        username: Optional[str] = Query(None, description="用户名"),
        mobile: Optional[str] = Query(None, description="手机号"),
        email: Optional[str] = Query(None, description="邮箱"),
        user_status: Optional[int] = Query(None, alias="user_status", description="用户状态"),
        user_type: Optional[int] = Query(None, alias="user_type", description="用户类型"),
        dept_id: Optional[str] = Query(None, alias="dept_ids", description="部门ID"),
        db: AsyncSession = Depends(get_db)
):
    """获取用户列表（分页）"""
    from core.user.model import User

    filters = []
    if name:
        filters.append(User.name.ilike(f"%{name}%"))
    if username:
        filters.append(User.username.ilike(f"%{username}%"))
    if mobile:
        filters.append(User.mobile.ilike(f"%{mobile}%"))
    if email:
        filters.append(User.email.ilike(f"%{email}%"))
    if user_status is not None:
        filters.append(User.user_status == user_status)
    if user_type is not None:
        filters.append(User.user_type == user_type)
    if dept_id:
        filters.append(User.dept_id == dept_id)

    items, total = await UserService.get_list(db, page=page, page_size=page_size, filters=filters)

    # 为每个用户添加 role_ids
    response_items = []
    for item in items:
        user_dict = _build_user_response(item).model_dump()
        # 获取用户的角色ID列表
        role_ids = await UserService.get_user_role_ids(db, item.id)
        user_dict['role_ids'] = role_ids
        response_items.append(user_dict)

    return PaginatedResponse(
        items=response_items,
        total=total
    )


@router.get("/simple", response_model=List[UserSimple], summary="获取用户简单列表")
async def get_user_simple_list(
        user_status: Optional[int] = Query(None, alias="userStatus", description="用户状态"),
        dept_id: Optional[str] = Query(None, alias="deptId", description="部门ID"),
        db: AsyncSession = Depends(get_db)
):
    """获取用户简单列表（用于选择器）"""
    from core.user.model import User

    filters = []
    if user_status is not None:
        filters.append(User.user_status == user_status)
    if dept_id:
        filters.append(User.dept_id == dept_id)

    items, _ = await UserService.get_list(db, page=1, page_size=1000, filters=filters)
    return [_build_user_simple(item) for item in items]


@router.get("/export/excel", summary="导出用户Excel")
async def export_user_excel(db: AsyncSession = Depends(get_db)):
    """导出用户到Excel"""
    output = await UserService.export_to_excel(db)
    return StreamingResponse(
        output,
        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
        headers={"Content-Disposition": "attachment; filename=users.xlsx"}
    )


@router.get("/import/template", summary="下载用户导入模板")
async def download_user_template():
    """下载用户导入模板"""
    output = UserService.get_import_template()
    return StreamingResponse(
        output,
        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
        headers={"Content-Disposition": "attachment; filename=user_template.xlsx"}
    )


@router.post("/import/excel", response_model=ResponseModel, summary="导入用户Excel")
async def import_user_excel(
        file: UploadFile = File(..., description="Excel文件(.xlsx)"),
        db: AsyncSession = Depends(get_db)
):
    """从Excel导入用户"""
    if not file.filename.endswith(".xlsx"):
        raise HTTPException(status_code=400, detail="只支持.xlsx格式")

    content = await file.read()
    success, fail = await UserService.import_from_excel(db, content)
    return ResponseModel(message=f"成功{success}条，失败{fail}条", data={"success": success, "fail": fail})


@router.get("/check/unique", response_model=ResponseModel, summary="检查用户唯一性")
async def check_user_unique(
        field: str = Query(..., description="字段名"),
        value: str = Query(..., description="字段值"),
        exclude_id: Optional[str] = Query(None, alias="excludeId", description="排除ID"),
        db: AsyncSession = Depends(get_db)
):
    """检查用户字段唯一性"""
    allowed_fields = ["username", "email", "mobile"]
    if field not in allowed_fields:
        raise HTTPException(status_code=400, detail=f"不支持检查字段: {field}")

    is_unique = await UserService.check_unique(db, field=field, value=value, exclude_id=exclude_id)
    return ResponseModel(message="可用" if is_unique else "已存在", data={"unique": is_unique})


@router.post("/batch_delete", response_model=UserBatchDeleteOut, summary="批量删除用户")
async def batch_delete_users(
        data: UserBatchDeleteIn,
        db: AsyncSession = Depends(get_db)
):
    """批量删除用户"""
    success_count, fail_count = await UserService.batch_delete(db, data.ids)
    return UserBatchDeleteOut(success_count=success_count, fail_count=fail_count)


@router.post("/batch/status", response_model=UserBatchUpdateStatusOut, summary="批量更新用户状态")
async def batch_update_user_status(
        data: UserBatchUpdateStatusIn,
        db: AsyncSession = Depends(get_db)
):
    """批量更新用户状态"""
    count = await UserService.batch_update_status(db, data.ids, data.user_status)
    return UserBatchUpdateStatusOut(count=count)


@router.get("/org-chart/top", response_model=List[OrgChartNode], summary="获取组织架构顶层节点")
async def get_org_chart_top(
        db: AsyncSession = Depends(get_db)
):
    """获取组织架构顶层用户（无上级）"""
    users = await UserService.get_top_users(db)
    result = []
    for user in users:
        count = await UserService.get_subordinate_count(db, user.id)
        result.append(_build_org_chart_node(user, count))
    return result


@router.get("/org-chart/{user_id}", response_model=OrgChartNode, summary="获取指定用户的组织架构节点")
async def get_org_chart_node(
        user_id: str,
        db: AsyncSession = Depends(get_db)
):
    """获取指定用户的组织架构节点信息"""
    user = await UserService.get_by_id(db, record_id=user_id)
    if not user:
        raise HTTPException(status_code=404, detail="用户不存在")
    count = await UserService.get_subordinate_count(db, user.id)
    return _build_org_chart_node(user, count)


@router.get("/org-chart/{user_id}/chain", response_model=OrgChartChainNode, summary="获取用户汇报链")
async def get_org_chart_chain(
        user_id: str,
        db: AsyncSession = Depends(get_db)
):
    """获取从指定用户到顶层的完整汇报链（嵌套树结构，顶层为根）"""
    chain = await UserService.get_report_chain(db, user_id)
    if not chain:
        raise HTTPException(status_code=404, detail="用户不存在")

    # chain: [当前用户, 上级, 上上级, ..., 顶层]
    # 从当前用户开始往上构建嵌套，每个上级把下级作为 children
    result = None
    for user in chain:
        count = await UserService.get_subordinate_count(db, user.id)
        node = _build_org_chart_node(user, count)
        chain_node = OrgChartChainNode(
            id=node.id,
            name=node.name,
            username=node.username,
            avatar=node.avatar,
            dept_name=node.dept_name,
            post_name=node.post_name,
            subordinate_count=node.subordinate_count,
            children=[result] if result else [],
        )
        result = chain_node

    return result


@router.get("/org-chart/{user_id}/children", response_model=List[OrgChartNode], summary="获取组织架构子节点")
async def get_org_chart_children(
        user_id: str,
        db: AsyncSession = Depends(get_db)
):
    """获取指定用户的下属（组织架构子节点）"""
    subordinates = await UserService.get_subordinates(db, user_id)
    result = []
    for user in subordinates:
        count = await UserService.get_subordinate_count(db, user.id)
        result.append(_build_org_chart_node(user, count))
    return result


@router.get("/{user_id}/subordinates", response_model=List[UserSimple], summary="获取下属用户")
async def get_user_subordinates(
        user_id: str,
        db: AsyncSession = Depends(get_db)
):
    """获取下属用户列表"""
    subordinates = await UserService.get_subordinates(db, user_id)
    return [_build_user_simple(item) for item in subordinates]


@router.post("/{user_id}/reset-password", response_model=ResponseModel, summary="重置用户密码")
async def reset_user_password(
        user_id: str,
        data: UserPasswordSetIn,
        db: AsyncSession = Depends(get_db)
):
    """管理员重置用户密码"""
    success = await UserService.reset_password(db, user_id, data.new_password)
    if not success:
        raise HTTPException(status_code=404, detail="用户不存在")
    return ResponseModel(message="密码重置成功")


@router.post("/change-password", response_model=ResponseModel, summary="当前用户修改密码")
async def change_my_password(
        data: UserPasswordResetIn,
        user_id: str = Depends(get_current_user_id),
        db: AsyncSession = Depends(get_db)
):
    """当前登录用户修改自己的密码"""
    success, message = await UserService.change_password(
        db, user_id, data.old_password, data.new_password
    )
    if not success:
        raise HTTPException(status_code=400, detail=message)
    return ResponseModel(message=message)


@router.post("/{user_id}/change-password", response_model=ResponseModel, summary="管理员修改用户密码")
async def change_user_password(
        user_id: str,
        data: UserPasswordResetIn,
        db: AsyncSession = Depends(get_db)
):
    """管理员修改指定用户的密码"""
    success, message = await UserService.change_password(
        db, user_id, data.old_password, data.new_password
    )
    if not success:
        raise HTTPException(status_code=400, detail=message)
    return ResponseModel(message=message)


@router.get("/profile", response_model=UserResponse, summary="获取当前用户详细信息")
async def get_my_profile(
        current_user=Depends(get_current_user)
):
    """获取当前登录用户的详细信息"""
    return _build_user_response(current_user)


@router.put("/profile", response_model=UserResponse, summary="更新当前用户个人信息")
async def update_my_profile(
        data: UserProfileUpdateIn,
        user_id: str = Depends(get_current_user_id),
        db: AsyncSession = Depends(get_db)
):
    """更新当前登录用户的个人信息"""
    # 邮箱唯一性校验
    if data.email:
        if not await UserService.check_unique(db, field="email", value=data.email, exclude_id=user_id):
            raise HTTPException(status_code=400, detail="邮箱已存在")

    # 手机号唯一性校验
    if data.mobile:
        if not await UserService.check_unique(db, field="mobile", value=data.mobile, exclude_id=user_id):
            raise HTTPException(status_code=400, detail="手机号已存在")

    # 转换为UserUpdate
    update_data = UserUpdate(**data.model_dump(exclude_unset=True))
    user = await UserService.update(db, record_id=user_id, data=update_data)
    if user is None:
        raise HTTPException(status_code=404, detail="用户不存在")
    return _build_user_response(user)


@router.put("/{user_id}/profile", response_model=UserResponse, summary="更新指定用户个人信息（管理员）")
async def update_user_profile(
        user_id: str,
        data: UserProfileUpdateIn,
        db: AsyncSession = Depends(get_db)
):
    """更新指定用户的个人信息（管理员功能）"""
    # 邮箱唯一性校验
    if data.email:
        if not await UserService.check_unique(db, field="email", value=data.email, exclude_id=user_id):
            raise HTTPException(status_code=400, detail="邮箱已存在")

    # 手机号唯一性校验
    if data.mobile:
        if not await UserService.check_unique(db, field="mobile", value=data.mobile, exclude_id=user_id):
            raise HTTPException(status_code=400, detail="手机号已存在")

    # 转换为UserUpdate
    update_data = UserUpdate(**data.model_dump(exclude_unset=True))
    user = await UserService.update(db, record_id=user_id, data=update_data)
    if user is None:
        raise HTTPException(status_code=404, detail="用户不存在")
    return _build_user_response(user)


@router.get("/{user_id}", response_model=UserResponse, summary="获取用户详情")
async def get_user_by_id(user_id: str, db: AsyncSession = Depends(get_db)):
    """获取用户详情"""
    user = await UserService.get_by_id(db, user_id)
    if user is None:
        raise HTTPException(status_code=404, detail="用户不存在")

    # 构建响应并添加 role_ids
    user_dict = _build_user_response(user).model_dump()
    role_ids = await UserService.get_user_role_ids(db, user_id)
    user_dict['role_ids'] = role_ids
    return user_dict


@router.put("/{user_id}", response_model=UserResponse, summary="更新用户")
async def update_user(user_id: str, data: UserUpdate, db: AsyncSession = Depends(get_db)):
    """更新用户"""
    # 用户名唯一性校验
    if data.username:
        if not await UserService.check_unique(db, field="username", value=data.username, exclude_id=user_id):
            raise HTTPException(status_code=400, detail="用户名已存在")

    # 邮箱唯一性校验
    if data.email:
        if not await UserService.check_unique(db, field="email", value=data.email, exclude_id=user_id):
            raise HTTPException(status_code=400, detail="邮箱已存在")

    # 手机号唯一性校验
    if data.mobile:
        if not await UserService.check_unique(db, field="mobile", value=data.mobile, exclude_id=user_id):
            raise HTTPException(status_code=400, detail="手机号已存在")

    user = await UserService.update(db, record_id=user_id, data=data)
    if user is None:
        raise HTTPException(status_code=404, detail="用户不存在")

    # 构建响应并添加 role_ids
    user_dict = _build_user_response(user).model_dump()
    role_ids = await UserService.get_user_role_ids(db, user_id)
    user_dict['role_ids'] = role_ids
    return user_dict


@router.delete("/{user_id}", response_model=ResponseModel, summary="删除用户")
async def delete_user(
        user_id: str,
        hard: bool = Query(default=False, description="是否物理删除"),
        db: AsyncSession = Depends(get_db)
):
    """删除用户"""
    user = await UserService.get_by_id(db, user_id)
    if not user:
        raise HTTPException(status_code=404, detail="用户不存在")

    if not user.can_delete():
        raise HTTPException(status_code=400, detail="系统用户或超级管理员不能删除")

    success = await UserService.delete(db, record_id=user_id, hard=hard)
    if not success:
        raise HTTPException(status_code=404, detail="用户不存在")
    return ResponseModel(message="删除成功")


def _build_user_response(user) -> UserResponse:
    """构建用户响应"""
    # 获取岗位名称
    post_name = None
    if hasattr(user, 'post') and user.post:
        post_name = user.post.name

    return UserResponse(
        id=user.id,
        username=user.username,
        email=user.email,
        mobile=user.mobile,
        avatar=user.avatar,
        name=user.name,
        gender=user.gender if user.gender is not None else 0,
        gender_display=user.get_gender_display(),
        user_type=user.user_type if user.user_type is not None else 1,
        user_type_display=user.get_user_type_display(),
        user_status=user.user_status if user.user_status is not None else 1,
        user_status_display=user.get_user_status_display(),
        birthday=user.birthday,
        city=user.city,
        address=user.address,
        bio=user.bio,
        is_superuser=user.is_superuser,
        is_active=user.is_active,
        dept_id=user.dept_id,
        post_id=user.post_id,
        post_name=post_name,
        manager_id=user.manager_id,
        last_login=user.last_login,
        last_login_ip=user.last_login_ip,
        last_login_type=user.last_login_type,
        sort=user.sort,
        is_deleted=user.is_deleted,
        sys_create_datetime=user.sys_create_datetime,
        sys_update_datetime=user.sys_update_datetime,
    )


def _build_org_chart_node(user, subordinate_count: int = 0) -> OrgChartNode:
    """构建组织架构节点"""
    post_name = None
    if hasattr(user, 'post') and user.post:
        post_name = user.post.name
    return OrgChartNode(
        id=user.id,
        name=user.name,
        username=user.username,
        avatar=user.avatar,
        dept_name=user.dept.name if user.dept else None,
        post_name=post_name,
        subordinate_count=subordinate_count,
    )


def _build_user_simple(user) -> UserSimple:
    """构建用户简单响应"""
    return UserSimple(
        id=user.id,
        name=user.name,
        username=user.username,
        avatar=user.avatar,
        email=user.email,
        mobile=user.mobile,
        dept_name=user.dept.name if user.dept else None,
    )