package shop.alien.store.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import shop.alien.entity.result.R;
import shop.alien.entity.store.LifeSys;
import shop.alien.entity.store.LifeSysDept;
import shop.alien.entity.store.dto.LifeSysDeptAddDto;
import shop.alien.entity.store.dto.LifeSysDeptSortDto;
import shop.alien.entity.store.dto.LifeSysDeptUpdateDto;
import shop.alien.entity.store.vo.LifeSysDeptVo;
import shop.alien.entity.store.vo.LifeSysVo;
import shop.alien.mapper.LifeSysDeptMapper;
import shop.alien.mapper.LifeSysMapper;
import shop.alien.store.service.LifeSysDeptService;

import java.util.*;

/**
 * 部门表 服务实现类
 *
 * @author system
 * @since 2025-01-XX
 */
@Slf4j
@Service
@RequiredArgsConstructor
@Transactional
public class LifeSysDeptServiceImpl implements LifeSysDeptService {

    private final LifeSysDeptMapper lifeSysDeptMapper;

    private final LifeSysMapper lifeSysMapper;

    @Override
    public R<LifeSysDept> addDept(LifeSysDeptAddDto addDto) {
        log.info("LifeSysDeptServiceImpl.addDept?addDto={}", addDto);

        // 参数校验
        if (addDto == null) {
            log.warn("新增部门失败：参数为空");
            return R.fail("参数不能为空");
        }

        // 校验必填字段：部门名称
        if (!StringUtils.hasText(addDto.getDeptName())) {
            return R.fail("部门名称不能为空");
        }

        // 校验部门名称是否已存在（同一父部门下不能有重名）
        QueryWrapper<LifeSysDept> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("dept_name", addDto.getDeptName());
        queryWrapper.eq("del_flag", "0"); // 未删除的部门
        if (addDto.getParentId() != null && addDto.getParentId() != 0) {
            queryWrapper.eq("parent_id", addDto.getParentId());
        } else {
            queryWrapper.eq("parent_id", 0);
        }
        LifeSysDept existingDept = lifeSysDeptMapper.selectOne(queryWrapper);
        if (existingDept != null) {
            return R.fail("该部门名称已存在，请更换其他名称");
        }

        // 如果指定了父部门，校验父部门是否存在
        if (addDto.getParentId() != null && addDto.getParentId() != 0) {
            LifeSysDept parentDept = lifeSysDeptMapper.selectById(addDto.getParentId());
            if (parentDept == null || !"0".equals(parentDept.getDelFlag())) {
                return R.fail("父部门不存在或已被删除");
            }
        }

        // 确定父部门ID
        Long parentId = addDto.getParentId() != null ? addDto.getParentId() : 0L;
        
        // 查询同级别部门的最大排序值，实现排序累加
        QueryWrapper<LifeSysDept> sortQueryWrapper = new QueryWrapper<>();
        sortQueryWrapper.eq("parent_id", parentId);
        sortQueryWrapper.eq("del_flag", "0"); // 只统计未删除的部门
        sortQueryWrapper.orderByDesc("dept_sort");
        sortQueryWrapper.last("LIMIT 1");
        LifeSysDept maxSortDept = lifeSysDeptMapper.selectOne(sortQueryWrapper);
        
        // 计算新的排序值：如果存在同级别部门，则取最大排序值+1，否则从1开始
        Integer newDeptSort = 1;
        if (maxSortDept != null && maxSortDept.getDeptSort() != null) {
            newDeptSort = maxSortDept.getDeptSort() + 1;
        }

        // 创建新部门
        LifeSysDept lifeSysDept = new LifeSysDept();
        lifeSysDept.setDeptName(addDto.getDeptName());
        lifeSysDept.setParentId(parentId);
        lifeSysDept.setDeptSort(newDeptSort); // 使用自动累加的排序值
        lifeSysDept.setLeader(addDto.getLeader());
        lifeSysDept.setPhone(addDto.getPhone());
        lifeSysDept.setEmail(addDto.getEmail());
        lifeSysDept.setStatus(StringUtils.hasText(addDto.getStatus()) ? addDto.getStatus() : "0");
        lifeSysDept.setDelFlag("0"); // 未删除
        lifeSysDept.setDescription(addDto.getDescription());

        // 设置祖级列表
        if (lifeSysDept.getParentId() != null && lifeSysDept.getParentId() != 0) {
            LifeSysDept parentDept = lifeSysDeptMapper.selectById(lifeSysDept.getParentId());
            if (parentDept != null && StringUtils.hasText(parentDept.getAncestors())) {
                lifeSysDept.setAncestors(parentDept.getAncestors() + "," + parentDept.getDeptId());
            } else if (parentDept != null) {
                lifeSysDept.setAncestors(String.valueOf(parentDept.getDeptId()));
            } else {
                lifeSysDept.setAncestors("0");
            }
        } else {
            lifeSysDept.setAncestors("0");
        }

        // 保存部门
        int result = lifeSysDeptMapper.insert(lifeSysDept);
        if (result > 0) {
            log.info("新增部门成功，部门ID={}", lifeSysDept.getDeptId());
            return R.data(lifeSysDept, "新增部门成功");
        }
        return R.fail("新增部门失败，请稍后重试");
    }

    @Override
    public R<Boolean> updateFirstLevelDeptSort(LifeSysDeptSortDto sortDto) {
        log.info("LifeSysDeptServiceImpl.updateFirstLevelDeptSort?sortDto={}", sortDto);

        // 参数校验
        if (sortDto == null || sortDto.getDeptId() == null) {
            log.warn("更新一级部门排序失败：参数为空或部门ID为空");
            return R.fail("参数不能为空，且部门ID不能为空");
        }

        if (sortDto.getNewSort() == null || sortDto.getNewSort() < 1) {
            log.warn("更新一级部门排序失败：新排序值无效");
            return R.fail("新排序值不能为空且必须大于1");
        }

        Long deptId = sortDto.getDeptId();
        Integer newSort = sortDto.getNewSort();

        // 查询当前部门信息
        LifeSysDept currentDept = lifeSysDeptMapper.selectById(deptId);
        if (currentDept == null) {
            return R.fail("部门不存在");
        }

        // 校验是否是一级部门且未删除
        if (currentDept.getParentId() == null || currentDept.getParentId() != 0) {
            return R.fail("该部门不是一级部门");
        }
        if (!"0".equals(currentDept.getDelFlag())) {
            return R.fail("该部门已被删除");
        }

        // 获取旧排序值
        Integer oldSort = currentDept.getDeptSort();
        if (oldSort == null) {
            oldSort = 0; // 如果旧排序值为空，默认为0
        }

        // 如果新旧排序值相同，无需更新
        if (oldSort.equals(newSort)) {
            log.info("部门排序值未变化，部门ID={}, 排序值={}", deptId, oldSort);
            return R.success("排序值未变化");
        }

        try {
            // 查询所有一级部门（排除当前部门），按排序值排序
            QueryWrapper<LifeSysDept> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("parent_id", 0);
            queryWrapper.eq("del_flag", "0");
            queryWrapper.ne("dept_id", deptId); // 排除当前部门
            queryWrapper.orderByAsc("dept_sort");
            List<LifeSysDept> otherDepts = lifeSysDeptMapper.selectList(queryWrapper);

            // 根据新旧位置差异，调整其他部门的排序 TODO 有优化空间，批量更新
            if (newSort < oldSort) {
                // 向上移动：旧位置到新位置之间的部门排序值 +1
                for (LifeSysDept dept : otherDepts) {
                    if (dept.getDeptSort() != null && dept.getDeptSort() >= newSort && dept.getDeptSort() < oldSort) {
                        LambdaUpdateWrapper<LifeSysDept> updateWrapper = new LambdaUpdateWrapper<>();
                        updateWrapper.eq(LifeSysDept::getDeptId, dept.getDeptId())
                                .set(LifeSysDept::getDeptSort, dept.getDeptSort() + 1);
                        lifeSysDeptMapper.update(null, updateWrapper);
                        log.debug("向上移动：部门ID={}的排序值从{}调整为{}", dept.getDeptId(), dept.getDeptSort(), dept.getDeptSort() + 1);
                    }
                }
            } else {
                // 向下移动：旧位置到新位置之间的部门排序值 -1
                for (LifeSysDept dept : otherDepts) {
                    if (dept.getDeptSort() != null && dept.getDeptSort() > oldSort && dept.getDeptSort() <= newSort) {
                        LambdaUpdateWrapper<LifeSysDept> updateWrapper = new LambdaUpdateWrapper<>();
                        updateWrapper.eq(LifeSysDept::getDeptId, dept.getDeptId())
                                .set(LifeSysDept::getDeptSort, dept.getDeptSort() - 1);
                        lifeSysDeptMapper.update(null, updateWrapper);
                        log.debug("向下移动：部门ID={}的排序值从{}调整为{}", dept.getDeptId(), dept.getDeptSort(), dept.getDeptSort() - 1);
                    }
                }
            }

            // 更新当前部门的排序值
            LambdaUpdateWrapper<LifeSysDept> currentUpdateWrapper = new LambdaUpdateWrapper<>();
            currentUpdateWrapper.eq(LifeSysDept::getDeptId, deptId)
                    .set(LifeSysDept::getDeptSort, newSort);
            int result = lifeSysDeptMapper.update(null, currentUpdateWrapper);

            if (result > 0) {
                log.info("更新一级部门排序成功，部门ID={}, 从位置{}移动到位置{}", deptId, oldSort, newSort);
                return R.success("更新排序成功");
            } else {
                return R.fail("更新排序失败");
            }
        } catch (Exception e) {
            log.error("更新一级部门排序失败", e);
            return R.fail("更新排序失败：" + e.getMessage());
        }
    }

    @Override
    public R<Boolean> deleteDept(Long deptId) {
        log.info("LifeSysDeptServiceImpl.deleteDept?deptId={}", deptId);

        // 参数校验
        if (deptId == null) {
            log.warn("删除部门失败：部门ID为空");
            return R.fail("部门ID不能为空");
        }

        // 查询部门信息
        LifeSysDept dept = lifeSysDeptMapper.selectById(deptId);
        if (dept == null) {
            return R.fail("部门不存在");
        }

        // 检查是否已被删除
        if (!"0".equals(dept.getDelFlag())) {
            return R.fail("该部门已被删除");
        }

        // 检查是否有子部门（未删除的子部门）
        QueryWrapper<LifeSysDept> childQueryWrapper = new QueryWrapper<>();
        childQueryWrapper.eq("parent_id", deptId);
        childQueryWrapper.eq("del_flag", "0"); // 未删除的子部门
        Integer childCount = lifeSysDeptMapper.selectCount(childQueryWrapper);
        
        if (childCount != null && childCount > 0) {
            log.warn("删除部门失败：该部门下存在{}个子部门，不允许删除", childCount);
            return R.fail("该部门下存在子部门，请先删除子部门后再删除");
        }

        try {
            // 获取被删除部门的父部门ID和排序值
            Long parentId = dept.getParentId() != null ? dept.getParentId() : 0L;
            Integer deletedSort = dept.getDeptSort();
            
            // 执行逻辑删除（设置 del_flag = "2"）
            LambdaUpdateWrapper<LifeSysDept> updateWrapper = new LambdaUpdateWrapper<>();
            updateWrapper.eq(LifeSysDept::getDeptId, deptId)
                    .set(LifeSysDept::getDelFlag, "2");
            
            int result = lifeSysDeptMapper.update(null, updateWrapper);
            
            if (result > 0) {
                // 删除成功后，自动更新同级别部门的排序
                // 将排在删除部门后面的所有部门的排序值减1
                if (deletedSort != null) {
                    QueryWrapper<LifeSysDept> sortUpdateQueryWrapper = new QueryWrapper<>();
                    sortUpdateQueryWrapper.eq("parent_id", parentId);
                    sortUpdateQueryWrapper.eq("del_flag", "0"); // 只更新未删除的部门
                    sortUpdateQueryWrapper.gt("dept_sort", deletedSort); // 排序值大于被删除部门的排序值
                    List<LifeSysDept> deptsToUpdate = lifeSysDeptMapper.selectList(sortUpdateQueryWrapper);
                    
                    // 批量更新排序值（减1）
                    for (LifeSysDept deptToUpdate : deptsToUpdate) {
                        if (deptToUpdate.getDeptSort() != null) {
                            LambdaUpdateWrapper<LifeSysDept> sortUpdateWrapper = new LambdaUpdateWrapper<>();
                            sortUpdateWrapper.eq(LifeSysDept::getDeptId, deptToUpdate.getDeptId())
                                    .set(LifeSysDept::getDeptSort, deptToUpdate.getDeptSort() - 1);
                            lifeSysDeptMapper.update(null, sortUpdateWrapper);
                            log.debug("删除后更新排序：部门ID={}的排序值从{}调整为{}", 
                                    deptToUpdate.getDeptId(), deptToUpdate.getDeptSort(), deptToUpdate.getDeptSort() - 1);
                        }
                    }
                    
                    if (!deptsToUpdate.isEmpty()) {
                        log.info("删除部门后，已更新{}个同级别部门的排序值", deptsToUpdate.size());
                    }
                }
                
                log.info("删除部门成功，部门ID={}, 部门名称={}", deptId, dept.getDeptName());
                return R.success("删除部门成功");
            } else {
                return R.fail("删除部门失败");
            }
        } catch (Exception e) {
            log.error("删除部门失败，部门ID={}", deptId, e);
            return R.fail("删除部门失败：" + e.getMessage());
        }
    }

    @Override
    public R<LifeSysDept> updateDept(LifeSysDeptUpdateDto updateDto) {
        log.info("LifeSysDeptServiceImpl.updateDept?updateDto={}", updateDto);

        // 参数校验
        if (updateDto == null) {
            log.warn("编辑部门失败：参数为空");
            return R.fail("参数不能为空");
        }

        // 校验必填字段：部门ID
        if (updateDto.getDeptId() == null) {
            return R.fail("部门ID不能为空");
        }

        // 校验必填字段：部门名称
        if (!StringUtils.hasText(updateDto.getDeptName())) {
            return R.fail("部门名称不能为空");
        }

        // 查询部门是否存在
        LifeSysDept dept = lifeSysDeptMapper.selectById(updateDto.getDeptId());
        if (dept == null) {
            return R.fail("部门不存在");
        }

        // 检查是否已被删除
        if (!"0".equals(dept.getDelFlag())) {
            return R.fail("该部门已被删除");
        }

        // 如果部门名称有变化，校验新名称是否与其他部门重复（同一父部门下不能有重名）
        if (!updateDto.getDeptName().equals(dept.getDeptName())) {
            QueryWrapper<LifeSysDept> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("dept_name", updateDto.getDeptName());
            queryWrapper.eq("del_flag", "0"); // 未删除的部门
            queryWrapper.ne("dept_id", updateDto.getDeptId()); // 排除当前部门
            Long parentId = dept.getParentId() != null ? dept.getParentId() : 0L;
            queryWrapper.eq("parent_id", parentId);
            LifeSysDept existingDept = lifeSysDeptMapper.selectOne(queryWrapper);
            if (existingDept != null) {
                return R.fail("该部门名称已存在，请更换其他名称");
            }
        }

        // 更新部门信息
        dept.setDeptName(updateDto.getDeptName());
        if (StringUtils.hasText(updateDto.getDescription())) {
            dept.setDescription(updateDto.getDescription());
        }
        if (updateDto.getLeader() != null) {
            dept.setLeader(updateDto.getLeader());
        }

        // 保存更新
        int result = lifeSysDeptMapper.updateById(dept);
        if (result > 0) {
            log.info("编辑部门成功，部门ID={}, 部门名称={}", dept.getDeptId(), dept.getDeptName());
            return R.data(dept, "编辑部门成功");
        }
        return R.fail("编辑部门失败，请稍后重试");
    }

    @Override
    public R<List<LifeSysDeptVo>> searchDeptByName(String deptName) {
        log.info("LifeSysDeptServiceImpl.searchDeptByName?deptName={}", deptName);

        // 构建查询条件
        QueryWrapper<LifeSysDept> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("del_flag", "0"); // 只查询未删除的部门

        // 如果部门名称不为空，添加模糊查询条件
        if (StringUtils.hasText(deptName)) {
            queryWrapper.like("dept_name", deptName.trim());
        }

        // 按排序值升序排列
        queryWrapper.orderByAsc("dept_sort");

        // 执行查询，获取匹配的部门
        List<LifeSysDept> matchedDeptList = lifeSysDeptMapper.selectList(queryWrapper);

        // 如果部门名称为空，直接返回所有部门的树形结构
        if (!StringUtils.hasText(deptName)) {
            List<LifeSysDeptVo> treeList = buildTree(matchedDeptList);
            log.info("搜索部门成功，查询条件：部门名称={}, 结果数量={}", deptName, matchedDeptList != null ? matchedDeptList.size() : 0);
            return R.data(treeList, "查询成功");
        }

        // 收集所有需要返回的部门ID（包括匹配的部门和它们的父部门）
        java.util.Set<Long> deptIdSet = new java.util.HashSet<>();
        
        if (matchedDeptList != null && !matchedDeptList.isEmpty()) {
            for (LifeSysDept dept : matchedDeptList) {
                // 添加匹配的部门ID
                if (dept.getDeptId() != null) {
                    deptIdSet.add(dept.getDeptId());
                }
                
                // 解析 ancestors 字段，获取所有父部门ID
                if (StringUtils.hasText(dept.getAncestors())) {
                    String ancestors = dept.getAncestors();
                    // ancestors 格式：0,100,101 或 100,101
                    String[] ancestorIds = ancestors.split(",");
                    for (String ancestorIdStr : ancestorIds) {
                        try {
                            Long ancestorId = Long.parseLong(ancestorIdStr.trim());
                            // 排除根部门（0）
                            if (ancestorId != null && ancestorId != 0) {
                                deptIdSet.add(ancestorId);
                            }
                        } catch (NumberFormatException e) {
                            log.warn("解析父部门ID失败：{}", ancestorIdStr, e);
                        }
                    }
                }
                
                // 如果 parentId 不为空且不为0，也添加父部门ID（防止 ancestors 为空的情况）
                if (dept.getParentId() != null && dept.getParentId() != 0) {
                    deptIdSet.add(dept.getParentId());
                }
            }
        }

        // 如果没有任何匹配结果，直接返回空列表
        if (deptIdSet.isEmpty()) {
            log.info("搜索部门成功，查询条件：部门名称={}, 结果数量=0", deptName);
            return R.data(new ArrayList<>(), "查询成功");
        }

        // 查询所有需要返回的部门（包括匹配的部门和它们的父部门）
        QueryWrapper<LifeSysDept> finalQueryWrapper = new QueryWrapper<>();
        finalQueryWrapper.in("dept_id", deptIdSet);
        finalQueryWrapper.eq("del_flag", "0"); // 只查询未删除的部门
        finalQueryWrapper.orderByAsc("dept_sort");
        
        List<LifeSysDept> finalDeptList = lifeSysDeptMapper.selectList(finalQueryWrapper);

        // 构建树形结构
        List<LifeSysDeptVo> treeList = buildTree(finalDeptList);

        log.info("搜索部门成功，查询条件：部门名称={}, 匹配数量={}, 最终结果数量={}", 
                deptName, matchedDeptList != null ? matchedDeptList.size() : 0, 
                finalDeptList != null ? finalDeptList.size() : 0);
        return R.data(treeList, "查询成功");
    }

    /**
     * 构建树形结构
     *
     * @param flatList 扁平列表
     * @return 树形结构列表
     */
    private List<LifeSysDeptVo> buildTree(List<LifeSysDept> flatList) {
        if (flatList == null || flatList.isEmpty()) {
            return new ArrayList<>();
        }

        // 创建映射：ID到节点的映射，父ID到子节点列表的映射
        Map<Long, LifeSysDeptVo> nodeMap = new HashMap<>();
        Map<Long, List<LifeSysDeptVo>> parentChildMap = new HashMap<>();
        List<LifeSysDeptVo> result = new ArrayList<>();

        // 第一步：将实体转换为VO，并建立映射关系
        for (LifeSysDept dept : flatList) {
            LifeSysDeptVo vo = LifeSysDeptVo.fromEntity(dept);
            Long deptId = vo.getDeptId();
            Long parentId = vo.getParentId() != null ? vo.getParentId() : 0L;

            // 存入节点映射
            nodeMap.put(deptId, vo);

            // 如果是根节点（parentId为0或null），直接添加到结果
            if (parentId == null || parentId == 0) {
                result.add(vo);
            } else {
                // 否则，记录父子关系
                parentChildMap.computeIfAbsent(parentId, k -> new ArrayList<>()).add(vo);
            }
        }

        // 第二步：建立父子关系
        for (LifeSysDeptVo vo : nodeMap.values()) {
            Long deptId = vo.getDeptId();
            if (parentChildMap.containsKey(deptId)) {
                // 对子节点按排序值排序
                List<LifeSysDeptVo> children = parentChildMap.get(deptId);
                children.sort(Comparator.comparing(LifeSysDeptVo::getDeptSort, Comparator.nullsLast(Integer::compareTo)));
                vo.setChildren(children);
            }
        }

        // 对根节点按排序值排序
        result.sort(Comparator.comparing(LifeSysDeptVo::getDeptSort, Comparator.nullsLast(Integer::compareTo)));

        // 第三步：统计每个部门的人员数量（包含子部门）
        for (LifeSysDeptVo vo : result) {
            calculateMemberCount(vo);
        }

        return result;
    }

    /**
     * 递归计算部门人员数量（包含子部门）
     *
     * @param deptVo 部门VO
     * @return 人员数量
     */
    private Integer calculateMemberCount(LifeSysDeptVo deptVo) {
        if (deptVo == null || deptVo.getDeptId() == null) {
            return 0;
        }

        // 统计当前部门直接的人员数量
        QueryWrapper<LifeSys> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("department_id", String.valueOf(deptVo.getDeptId()));
        queryWrapper.eq("delete_flag", 0); // 未删除的用户
        queryWrapper.eq("status", 1); // 启用的用户
        Integer directMemberCount = lifeSysMapper.selectCount(queryWrapper);
        if (directMemberCount == null) {
            directMemberCount = 0;
        }

        // 递归统计所有子部门的人员数量
        Integer childrenMemberCount = 0;
        if (deptVo.getChildren() != null && !deptVo.getChildren().isEmpty()) {
            for (LifeSysDeptVo child : deptVo.getChildren()) {
                childrenMemberCount += calculateMemberCount(child);
            }
        }

        // 总人员数量 = 当前部门人员数量 + 所有子部门人员数量
        Integer totalMemberCount = directMemberCount + childrenMemberCount;
        deptVo.setMemberCount(totalMemberCount);
        deptVo.setCurrentMemberCount(directMemberCount);

        return totalMemberCount;
    }

    @Override
    public R<List<LifeSysVo>> viewMembers(Integer pageNum, Integer pageSize, Long deptId) {
        log.info("LifeSysDeptServiceImpl.viewMembers?pageNum={}, pageSize={}, deptId={}", pageNum, pageSize, deptId);

        // 参数校验
        if (deptId == null) {
            log.warn("查看部门成员失败：部门ID为空");
            return R.fail("部门ID不能为空");
        }

        // 校验部门是否存在
        LifeSysDept dept = lifeSysDeptMapper.selectById(deptId);
        if (dept == null) {
            return R.fail("部门不存在");
        }

        // 检查部门是否已被删除
        if (!"0".equals(dept.getDelFlag())) {
            return R.fail("该部门已被删除");
        }

        try {
            // 收集当前部门ID和所有子部门ID
            Set<Long> deptIdSet = new HashSet<>();
            deptIdSet.add(deptId);
            
            // 递归收集所有子部门ID
            collectChildDeptIds(deptId, deptIdSet);
            
            log.debug("查询部门成员，部门ID={}，包含子部门数量={}", deptId, deptIdSet.size() - 1);

            // 如果没有任何部门（理论上不会发生），直接返回空列表
            if (deptIdSet.isEmpty()) {
                return R.data(new ArrayList<>(), "查询成功");
            }

            // 构建查询条件：查询当前部门及所有子部门下的所有用户
            QueryWrapper<LifeSys> voQueryWrapper = new QueryWrapper<>();
            // 将部门ID集合转换为String集合，因为department_id是String类型
            List<String> deptIdStrList = new ArrayList<>();
            for (Long id : deptIdSet) {
                deptIdStrList.add(String.valueOf(id));
            }
            voQueryWrapper.in("ls.department_id", deptIdStrList);
            voQueryWrapper.eq("ls.delete_flag", 0);
            voQueryWrapper.eq("ls.status", 1);
            voQueryWrapper.orderByDesc("ls.created_time");
            
            // 先查询用户数量，用于分页
             IPage<LifeSysVo> voList = lifeSysMapper.selectPageAndRoleName(new Page<>(pageNum, pageSize), voQueryWrapper);
            if (voList == null || voList.getRecords().isEmpty()) {
                log.info("查看部门成员成功，部门ID={}, 部门名称={}, 成员数量=0", deptId, dept.getDeptName());
                return R.data(new ArrayList<>(), "查询成功");
            }


            return R.data(voList.getRecords(), "查询成功");
        } catch (Exception e) {
            log.error("查看部门成员失败，部门ID={}", deptId, e);
            return R.fail("查询部门成员失败：" + e.getMessage());
        }
    }

    /**
     * 递归收集所有子部门ID
     *
     * @param parentDeptId 父部门ID
     * @param deptIdSet    部门ID集合（用于收集结果）
     */
    private void collectChildDeptIds(Long parentDeptId, Set<Long> deptIdSet) {
        if (parentDeptId == null) {
            return;
        }

        // 查询所有子部门
        QueryWrapper<LifeSysDept> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("parent_id", parentDeptId);
        queryWrapper.eq("del_flag", "0"); // 只查询未删除的部门
        List<LifeSysDept> childDepts = lifeSysDeptMapper.selectList(queryWrapper);

        if (childDepts != null && !childDepts.isEmpty()) {
            for (LifeSysDept childDept : childDepts) {
                Long childDeptId = childDept.getDeptId();
                if (childDeptId != null && !deptIdSet.contains(childDeptId)) {
                    deptIdSet.add(childDeptId);
                    // 递归查询子部门的子部门
                    collectChildDeptIds(childDeptId, deptIdSet);
                }
            }
        }
    }
}

