package com.ruoyi.lavorissue.service.impl;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.framework.web.domain.AjaxResult;
import com.ruoyi.lavorissue.mapper.DeptPositionMapper;
import com.ruoyi.lavorissue.mapper.LaborConfMapper;
import com.ruoyi.lavorissue.pojo.DeptPosition;
import com.ruoyi.lavorissue.pojo.LaborConf;
import com.ruoyi.lavorissue.service.DeptPositionService;
import com.ruoyi.staff.mapper.StaffOnJobMapper;
import com.ruoyi.staff.pojo.StaffJoinLeaveRecord;
import com.ruoyi.staff.pojo.StaffOnJob;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @author :yys
 * @date : 2025/11/19 13:21
 */
@Service
@Slf4j
public class DeptPositionServiceImpl extends ServiceImpl<DeptPositionMapper, DeptPosition> implements DeptPositionService {

    @Autowired
    private DeptPositionMapper deptPositionMapper;


    /**
     * 递归获取部门岗位树形结构
     * @return
     */
    @Override
    public AjaxResult getDeptPositionTree() {
        List<DeptPosition> deptPositions = deptPositionMapper.selectList(null);
        // 2. 筛选根部门（parentId为0或null，且类型为部门type=1）
        List<DeptPosition> rootDepts = deptPositions.stream()
                .filter(item -> (item.getParentId() == null || item.getParentId() == 0)
                        && item.getType() == 1) // 根节点必须是部门
                .sorted(Comparator.comparingInt(DeptPosition::getSort)) // 按排序字段升序
                .collect(Collectors.toList());

        // 3. 为每个根部门递归查找下属岗位（子集）
        for (DeptPosition rootDept : rootDepts) {
            buildDeptChildren(rootDept, deptPositions);
        }
        return AjaxResult.success(rootDepts);
    }

    @Autowired
    private StaffOnJobMapper staffOnJobMapper;

    /**
     * 通过id递归查询所有的岗位
     * @param deptPosition
     * @return
     */
    @Override
    public List<StaffOnJob> getDeptPositionByDeptId(DeptPosition deptPosition) {
        Long deptId = deptPosition.getId();
        // 1. 校验部门是否存在
        DeptPosition dept = deptPositionMapper.selectById(deptId);
        if (dept == null) {
            throw new IllegalArgumentException("无效的部门或岗位ID");
        }
        if(dept.getType() == 2){
            return staffOnJobMapper.selectList(Wrappers.lambdaQuery(StaffOnJob.class)
                    .eq(StaffOnJob::getStaffState, 1)
                    .eq(StaffOnJob::getDeptPositionId, deptId));
        }

        // 2. 递归获取当前部门及所有子部门的ID集合
        Set<Long> deptIdSet = new HashSet<>();
        // 先添加当前部门ID
        deptIdSet.add(deptId);
        // 递归获取所有子部门ID
        findAllChildDeptIds(deptId, deptIdSet);

        // 3. 查询这些部门下的所有岗位（type=2）
        if (deptIdSet.isEmpty()) {
            return Collections.emptyList();
        }
        List<DeptPosition> deptPositions = deptPositionMapper.selectList(
                Wrappers.<DeptPosition>lambdaQuery()
                        .in(DeptPosition::getParentId, deptIdSet) // 父ID在部门ID集合中
                        .eq(DeptPosition::getType, 2) // 类型为岗位
                        .orderByAsc(DeptPosition::getSort) // 按排序字段升序
        );
        if(CollectionUtils.isEmpty(deptPositions)){
            return Collections.emptyList();
        }
        return staffOnJobMapper.selectList(Wrappers.lambdaQuery(StaffOnJob.class)
                .eq(StaffOnJob::getStaffState, 1)
                .in(StaffOnJob::getDeptPositionId, deptPositions
                        .stream()
                        .map(DeptPosition::getId)
                        .collect(Collectors.toSet())));
    }

    @Autowired
    private LaborConfMapper laborConfMapper;

    @Override
    public List<LaborConf> getDeptPositionByDeptIdLabor(DeptPosition deptPosition) {
        Long deptId = deptPosition.getId();
        // 1. 校验部门是否存在
        DeptPosition dept = deptPositionMapper.selectById(deptId);
        if (dept == null) {
            throw new IllegalArgumentException("无效的部门或岗位ID");
        }
        if(dept.getType() == 2){
            return laborConfMapper.selectList(Wrappers.lambdaQuery(LaborConf.class)
                    .eq(LaborConf::getDeptPositionId, deptId));
        }

        // 2. 递归获取当前部门及所有子部门的ID集合
        Set<Long> deptIdSet = new HashSet<>();
        // 先添加当前部门ID
        deptIdSet.add(deptId);
        // 递归获取所有子部门ID
        findAllChildDeptIds(deptId, deptIdSet);

        // 3. 查询这些部门下的所有岗位（type=2）
        if (deptIdSet.isEmpty()) {
            return Collections.emptyList();
        }
        List<DeptPosition> deptPositions = deptPositionMapper.selectList(
                Wrappers.<DeptPosition>lambdaQuery()
                        .in(DeptPosition::getParentId, deptIdSet) // 父ID在部门ID集合中
                        .eq(DeptPosition::getType, 2) // 类型为岗位
                        .orderByAsc(DeptPosition::getSort) // 按排序字段升序
        );
        if(CollectionUtils.isEmpty(deptPositions)){
            return Collections.emptyList();
        }
        return laborConfMapper.selectList(Wrappers.lambdaQuery(LaborConf.class)
                .in(LaborConf::getDeptPositionId, deptPositions.stream()
                        .map(DeptPosition::getId)
                        .collect(Collectors.toSet())));
    }

    /**
     * 递归获取所有子部门ID（仅包括type=1的部门）
     * @param parentDeptId 父部门ID
     * @param deptIdSet 存储部门ID的集合（引用传递，持续添加子部门ID）
     */
    private void findAllChildDeptIds(Long parentDeptId, Set<Long> deptIdSet) {
        // 查询当前父部门下的所有子部门（type=1）
        List<DeptPosition> childDepts = deptPositionMapper.selectList(
                Wrappers.<DeptPosition>lambdaQuery()
                        .eq(DeptPosition::getParentId, parentDeptId)
                        .eq(DeptPosition::getType, 1) // 只查子部门，不查岗位
        );

        // 若有子部门，添加ID到集合，并继续递归查询其子部门
        if (!childDepts.isEmpty()) {
            for (DeptPosition childDept : childDepts) {
                Long childDeptId = childDept.getId();
                deptIdSet.add(childDeptId); // 添加子部门ID
                findAllChildDeptIds(childDeptId, deptIdSet); // 递归查询该子部门的子部门
            }
        }
    }


    /**
     * 递归构建部门的子节点（可能是子部门或岗位）
     * @param parent 父节点（部门）
     * @param allList 所有数据
     */
    private void buildDeptChildren(DeptPosition parent, List<DeptPosition> allList) {
        // 第一步：查找当前部门的子部门（type=1），构建部门层级
        List<DeptPosition> childDepts = allList.stream()
                .filter(item -> parent.getId().equals(item.getParentId())
                        && item.getType() == 1) // 子节点是部门
                .sorted(Comparator.comparingInt(DeptPosition::getSort))
                .collect(Collectors.toList());

        // 第二步：查找当前部门的岗位（type=2），作为子节点
        List<DeptPosition> childPositions = allList.stream()
                .filter(item -> parent.getId().equals(item.getParentId())
                        && item.getType() == 2) // 子节点是岗位
                .sorted(Comparator.comparingInt(DeptPosition::getSort))
                .collect(Collectors.toList());

        // 合并子部门和岗位（子部门在前，岗位在后，或按sort排序）
        List<DeptPosition> allChildren = new ArrayList<>();
        allChildren.addAll(childDepts);
        allChildren.addAll(childPositions);

        // 设置子节点
        if (!allChildren.isEmpty()) {
            parent.setChildren(allChildren);

            // 递归处理子部门（岗位无需递归，因为岗位是叶子节点）
            for (DeptPosition child : childDepts) {
                buildDeptChildren(child, allList); // 子部门继续找它的子节点
            }
        }
    }
}