package com.engine.salary.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
import com.engine.core.impl.Service;
import com.engine.salary.entity.datacollection.DataCollectionEmployee;
import com.engine.salary.entity.taxagent.bo.TaxAgentBO;
import com.engine.salary.entity.taxagent.dto.TaxAgentManageRangeEmployeeDTO;
import com.engine.salary.entity.taxagent.dto.TaxAgentManageRangeListDTO;
import com.engine.salary.entity.taxagent.param.*;
import com.engine.salary.entity.taxagent.po.TaxAgentManageRangePO;
import com.engine.salary.entity.taxagent.po.TaxAgentPO;
import com.engine.salary.entity.taxagent.po.TaxAgentSubAdminPO;
import com.engine.salary.enums.SalaryJobFlagEnum;
import com.engine.salary.enums.salarysob.SalaryEmployeeStatusEnum;
import com.engine.salary.enums.salarysob.TargetTypeEnum;
import com.engine.salary.enums.taxagent.TaxAgentRangeTypeEnum;
import com.engine.salary.exception.SalaryRunTimeException;
import com.engine.salary.mapper.datacollection.EmployMapper;
import com.engine.salary.mapper.taxagent.TaxAgentManageRangeMapper;
import com.engine.salary.service.*;
import com.engine.salary.util.JsonUtil;
import com.engine.salary.util.SalaryEntityUtil;
import com.engine.salary.util.SalaryI18nUtil;
import com.engine.salary.util.page.PageInfo;
import com.engine.salary.util.page.PageUtil;
import com.google.common.collect.Lists;
import com.weaver.common.async.bean.AsyncBean;
import com.weaver.common.async.consumer.anno.method.AsyncListener;
import com.weaver.common.cache.tablecache.impl.ComInfoCache;
import com.weaver.common.hrm.cache.HrmDepartmentComInfo;
import com.weaver.common.hrm.cache.HrmEmployeeComInfo;
import com.weaver.common.hrm.cache.HrmPositionComInfo;
import com.weaver.common.hrm.domain.employee.HrmStatus;
import com.weaver.common.hrm.domain.queue.HrmCommonQueue;
import com.weaver.common.hrm.service.employee.HrmCommonHrmStatusService;
import com.weaver.datasecurity.interceptor.DSTenantKeyThreadVar;
import com.weaver.hrm.salary.common.SalaryEmployee;
import com.weaver.hrm.salary.entity.taxagent.param.*;
import com.weaver.hrm.salary.service.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.springframework.transaction.annotation.Transactional;

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

/**
 * 个税扣缴义务人的管理范围
 * <p>Copyright: Copyright (c) 2022</p>
 * <p>Company: 泛微软件</p>
 *
 * @author qiantao
 * @version 1.0
 **/
@Slf4j
public class TaxAgentManageRangeServiceImpl extends Service implements TaxAgentManageRangeService {

    private TaxAgentManageRangeMapper taxAgentManageRangeMapper;

    private TaxAgentV2Service taxAgentService;

    private TaxAgentSubAdminService taxAgentSubAdminService;

    private TaxAgentEmpService taxAgentEmployeeService;

    private TaxAgentSubAdminEmpService taxAgentSubAdminEmployeeService;

    private ComInfoCache comInfoCache;

    private EmployMapper employeeMapper;

    private ExecutorService taskExecutor;

    private HrmCommonHrmStatusService hrmCommonHrmStatusService;

    private List<TaxAgentManageRangePO> listByTaxAgentIds(List<Long> taxAgentIds) {
        if (CollectionUtils.isEmpty(taxAgentIds)) {
            return Lists.newArrayList();
        }
        return taxAgentManageRangeMapper.listSome(TaxAgentManageRangePO.builder().rangeType(TaxAgentRangeTypeEnum.TAXAGENT.getValue()).taxAgentIds(taxAgentIds).build());
    }

    @Override
    public List<TaxAgentManageRangeEmployeeDTO> listSalaryEmployeeByTaxAgentIds(List<Long> taxAgentIds) {
        return listSalaryEmployeeByTaxAgentIds(null, taxAgentIds);
    }

    @Override
    public List<TaxAgentManageRangeEmployeeDTO> listSalaryEmployeeByTaxAgentIds(SalaryEmployeeStatusEnum employeeStatus, List<Long> taxAgentIds) {
        List<TaxAgentManageRangePO> allTaxAgentManageRanges = this.listByTaxAgentIds(taxAgentIds);
        return convertTaxAgentEmployee(employeeStatus, taxAgentIds, allTaxAgentManageRanges);
    }

    @Override
    public List<TaxAgentManageRangePO> listBySubAdminIds(Collection<Long> taxAgentSubAdminIds) {
        if (CollectionUtils.isEmpty(taxAgentSubAdminIds)) {
            return Lists.newArrayList();
        }
        taxAgentManageRangeMapper.listSome(TaxAgentManageRangePO.builder().rangeType(TaxAgentRangeTypeEnum.SUBADMIN.getValue()).build())
        return new LambdaQueryChainWrapper<>(taxAgentManageRangeMapper)
                .eq(TaxAgentManageRangePO::getTenantKey)
                .eq(TaxAgentManageRangePO::getDeleteType, 0)
                .eq(TaxAgentManageRangePO::getRangeType, TaxAgentRangeTypeEnum.SUBADMIN.getValue())
                .in(TaxAgentManageRangePO::getTaxAgentSubAdminId, taxAgentSubAdminIds)
                .orderByDesc(TaxAgentManageRangePO::getId)
                .list();
    }

    @Override
    public List<TaxAgentManageRangeEmployeeDTO> listSalaryEmployeeBySubAdminIds(List<Long> taxAgentIds) {
        return listSalaryEmployeeBySubAdminIds(null, taxAgentIds);
    }

    @Override
    public List<TaxAgentManageRangeEmployeeDTO> listSalaryEmployeeBySubAdminIds(SalaryEmployeeStatusEnum employeeStatus, List<Long> taxAgentSubAdminIds) {
        List<TaxAgentManageRangePO> allTaxAgentManageRanges = this.listBySubAdminIds(taxAgentSubAdminIds);
        List<Long> taxAgentIds = allTaxAgentManageRanges.stream().map(TaxAgentManageRangePO::getTaxAgentId).distinct().collect(Collectors.toList());

        return convertTaxAgentEmployee(employeeStatus, taxAgentIds, allTaxAgentManageRanges);
    }

    private List<TaxAgentManageRangeEmployeeDTO> convertTaxAgentEmployee(SalaryEmployeeStatusEnum employeeStatus, List<Long> taxAgentIds, List<TaxAgentManageRangePO> allTaxAgentManageRanges) {
        return taxAgentIds.stream().distinct().map(e -> {
            // 获取范围下的人员
            List<DataCollectionEmployee> salaryEmployees = getManageRangeSalaryEmployees(employeeStatus, e, allTaxAgentManageRanges);
            if (CollectionUtils.isEmpty(salaryEmployees)) {
                return null;
            }
            List<TaxAgentManageRangeEmployeeDTO.TaxAgentEmployee> taxAgentEmployees = salaryEmployees.stream().map(m -> {
                TaxAgentManageRangeEmployeeDTO.TaxAgentEmployee taxAgentEmployee = new TaxAgentManageRangeEmployeeDTO.TaxAgentEmployee();
                taxAgentEmployee.setEmployeeId(m.getEmployeeId());
                taxAgentEmployee.setUsername(m.getUsername());
                return taxAgentEmployee;
            }).collect(Collectors.toList());

            return TaxAgentManageRangeEmployeeDTO.builder()
                    .taxAgentId(e)
                    .taxAgentName("")
                    .employeeList(taxAgentEmployees)
                    .build();
        }).filter(Objects::nonNull).collect(Collectors.toList());
    }

    /**
     * 获取范围下的人员
     *
     * @param employeeStatus
     * @param taxAgentId
     * @param allTaxAgentManageRanges
     * @return
     */
    private List<DataCollectionEmployee> getManageRangeSalaryEmployees(SalaryEmployeeStatusEnum employeeStatus, Long taxAgentId,
                                                                       List<TaxAgentManageRangePO> allTaxAgentManageRanges) {
        List<TaxAgentManageRangePO> includeAllTaxAgentManageRanges = allTaxAgentManageRanges.stream().filter(f -> f.getIncludeType().equals(NumberUtils.INTEGER_ONE)).collect(Collectors.toList());
        if (CollectionUtils.isEmpty(includeAllTaxAgentManageRanges)) {
            return Collections.emptyList();
        }
        List<TaxAgentManageRangePO> excludeAllTaxAgentManageRanges = allTaxAgentManageRanges.stream().filter(f -> f.getIncludeType().equals(NumberUtils.INTEGER_ZERO)).collect(Collectors.toList());

        List<DataCollectionEmployee> includeSalaryEmployees = Lists.newArrayList();
        List<TaxAgentManageRangePO> includeTaxAgentManageRanges = includeAllTaxAgentManageRanges.stream().filter(f -> f.getTaxAgentId().equals(taxAgentId)).collect(Collectors.toList());
        if (CollectionUtils.isEmpty(includeTaxAgentManageRanges)) {
            return includeSalaryEmployees;
        }
        // 如果需要状态过滤
        List<String> personnelStatuss = Lists.newArrayList();
        if (employeeStatus != null) {
            // 查询人员状态
            List<HrmStatus> hrmStatusList = hrmCommonHrmStatusService.list();
            if (employeeStatus.equals(SalaryEmployeeStatusEnum.NORMAL)) {
                personnelStatuss = hrmStatusList.stream().filter(f -> f.getJobflag().equals(SalaryJobFlagEnum.normal.getValue())).map(m -> m.getCodeId() + "").collect(Collectors.toList());
            } else if (employeeStatus.equals(SalaryEmployeeStatusEnum.UNAVAILABLE)) {
                personnelStatuss = hrmStatusList.stream().filter(f -> f.getJobflag().equals(SalaryJobFlagEnum.unavailable.getValue())).map(m -> m.getCodeId() + "").collect(Collectors.toList());
            }
        }
        // 根据上一步的查询参数查询人员
        includeSalaryEmployees = listSalaryEmployeeByManageRange(includeTaxAgentManageRanges, personnelStatuss);
        if (CollectionUtils.isEmpty(includeSalaryEmployees)) {
            return includeSalaryEmployees;
        }
        // 查询管理范围（从范围中排除）
        List<TaxAgentManageRangePO> excludeTaxAgentManageRanges = excludeAllTaxAgentManageRanges.stream().filter(f -> f.getTaxAgentId().equals(taxAgentId)).collect(Collectors.toList());
        if (CollectionUtils.isNotEmpty(excludeTaxAgentManageRanges)) {
            // 根据上一步的查询参数查询人员
            List<DataCollectionEmployee> excludeSalaryEmployees = listSalaryEmployeeByManageRange(excludeTaxAgentManageRanges, personnelStatuss);
            // 需要排除的人员范围
            Set<Long> excludeEmployeeIds = SalaryEntityUtil.properties(excludeSalaryEmployees, DataCollectionEmployee::getEmployeeId);
            // 过滤人员
            includeSalaryEmployees = includeSalaryEmployees.stream()
                    .filter(salaryEmployee -> !excludeEmployeeIds.contains(salaryEmployee.getEmployeeId()))
                    .collect(Collectors.toList());
        }
        return includeSalaryEmployees;
    }

    /**
     * 根据范围加载人员
     *
     * @param taxAgentManageRanges
     * @return
     */
    private List<DataCollectionEmployee> listSalaryEmployeeByManageRange(List<TaxAgentManageRangePO> taxAgentManageRanges, List<String> personnelStatuss) {
        if (CollectionUtils.isEmpty(taxAgentManageRanges)) {
            return Collections.emptyList();
        }
        List<DataCollectionEmployee> salaryEmployees = employeeMapper.listAll();
        List<DataCollectionEmployee> salaryEmployeeList = Lists.newArrayList();
        for (TaxAgentManageRangePO manageRange : taxAgentManageRanges) {
            salaryEmployeeList.addAll(salaryEmployees.stream()
                    .filter(salaryEmployee -> {
                        // 判断人员状态
                        List<String> hrmStatusList = JsonUtil.parseList(manageRange.getEmployeeStatus(), String.class);
                        // 有状态过滤则取交集
                        if (CollectionUtils.isNotEmpty(personnelStatuss)) {
                            hrmStatusList = hrmStatusList.stream().filter(personnelStatuss::contains).collect(Collectors.toList());
                        }
                        if (CollectionUtils.isNotEmpty(hrmStatusList) && !hrmStatusList.contains(salaryEmployee.getPersonnelStatus())) {
                            return false;
                        }
                        if (Objects.equals(manageRange.getTargetType(), TargetTypeEnum.ALL.getValue())) {
                            return true;
                        }
                        if (Objects.equals(manageRange.getTargetType(), TargetTypeEnum.EMPLOYEE.getValue())
                                && Objects.equals(manageRange.getTargetId(), salaryEmployee.getEmployeeId())) {
                            return true;
                        }
                        if (Objects.equals(manageRange.getTargetType(), TargetTypeEnum.DEPT.getValue())
                                && Objects.equals(manageRange.getTargetId(), salaryEmployee.getDepartmentId())) {
                            return true;
                        }
                        if (Objects.equals(manageRange.getTargetType(), TargetTypeEnum.SUBCOMPANY.getValue())
                                && Objects.equals(manageRange.getTargetId(), salaryEmployee.getDepartmentId())) {
                            return true;
                        }
                        if (Objects.equals(manageRange.getTargetType(), TargetTypeEnum.POSITION.getValue())
                                && Objects.equals(manageRange.getTargetId(), salaryEmployee.getJobtitleId())) {
                            return true;
                        }
                        return false;
                    }).collect(Collectors.toList()));
        }
        // 去重
        salaryEmployeeList = salaryEmployeeList.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(DataCollectionEmployee::getEmployeeId))), ArrayList::new));
        return salaryEmployeeList;
    }

//    /**
//     * 根据分管理员id获取管理范围列表
//     *
//     * @param subAdminId
//     * @param includeType
//     * @return
//     */
//    private List<TaxAgentManageRangePO> listBySubAdminIdAndIncludeType(Long subAdminId, Integer includeType) {
//
//        return new LambdaQueryChainWrapper<>(taxAgentManageRangeMapper)
//                .eq(TaxAgentManageRangePO::getTenantKey)
//                .eq(TaxAgentManageRangePO::getDeleteType, 0)
//                .eq(TaxAgentManageRangePO::getTaxAgentSubAdminId, subAdminId)
//                .eq(TaxAgentManageRangePO::getRangeType, TaxAgentRangeTypeEnum.SUBADMIN.getValue())
//                .eq(TaxAgentManageRangePO::getIncludeType, includeType)
//                .orderByDesc(TaxAgentManageRangePO::getId)
//                .list();
//    }

    /**
     * 获取个税口角义务人的管理范围
     *
     * @param taxAgentId
     * @param includeType
     * @return
     */
    private List<TaxAgentManageRangePO> listByTaxAgentIdAndIncludeType(Long taxAgentId, Integer includeType) {
        return taxAgentManageRangeMapper.listSome(TaxAgentManageRangePO.builder().taxAgentId(taxAgentId).rangeType(TaxAgentRangeTypeEnum.TAXAGENT.getValue()).includeType(includeType).build());
    }

//    @Override
//    public Page<TaxAgentManageRangeListDTO> listPageByParamAndIncludeType(TaxAgentSubAdminRangeQueryParam queryParam, Integer includeType) {
//        // 查询已有的管理范围
//        List<TaxAgentManageRangePO> taxAgentManageRanges = listBySubAdminIdAndIncludeType(queryParam.getSubAdminId(), includeType);
//        return listPageByParamAndIncludeType(taxAgentManageRanges, queryParam, includeType);
//    }

    @Override
    public PageInfo<TaxAgentManageRangeListDTO> listPageByParamAndIncludeType(TaxAgentRangeQueryParam queryParam, Integer includeType) {
        // 查询已有的管理范围
        List<TaxAgentManageRangePO> taxAgentManageRanges = listByTaxAgentIdAndIncludeType(queryParam.getTaxAgentId(), includeType);
        return listPageByParamAndIncludeType(taxAgentManageRanges, queryParam, includeType);
    }

    private PageInfo<TaxAgentManageRangeListDTO> listPageByParamAndIncludeType(List<TaxAgentManageRangePO> taxAgentManageRanges, TaxAgentManageRangeQueryParam queryParam, Integer includeType) {

        // 查询人员信息
        List<Object> employeeIds = taxAgentManageRanges.stream()
                .filter(e -> Objects.equals(e.getTargetType(), TargetTypeEnum.EMPLOYEE.getValue()))
                .map(TaxAgentManageRangePO::getTargetId)
                .collect(Collectors.toList());
        List<HrmEmployeeComInfo> employeeComInfos = comInfoCache.getCacheList(HrmEmployeeComInfo.class, employeeIds);
        // 查询部门信息
        List<Object> departmentIds = taxAgentManageRanges.stream()
                .filter(e -> Objects.equals(e.getTargetType(), TargetTypeEnum.DEPT.getValue()))
                .map(TaxAgentManageRangePO::getTargetId)
                .collect(Collectors.toList());
        List<HrmDepartmentComInfo> departmentComInfos = comInfoCache.getCacheList(HrmDepartmentComInfo.class, departmentIds);
        // 查询分部信息
        List<Object> subDepartmentIds = taxAgentManageRanges.stream()
                .filter(e -> Objects.equals(e.getTargetType(), TargetTypeEnum.SUBCOMPANY.getValue()))
                .map(TaxAgentManageRangePO::getTargetId)
                .collect(Collectors.toList());
        List<HrmDepartmentComInfo> subDepartmentComInfos = comInfoCache.getCacheList(HrmDepartmentComInfo.class, subDepartmentIds);
        // 查询岗位信息
        List<Object> positionIds = taxAgentManageRanges.stream()
                .filter(e -> Objects.equals(e.getTargetType(), TargetTypeEnum.POSITION.getValue()))
                .map(TaxAgentManageRangePO::getTargetId)
                .collect(Collectors.toList());
        List<HrmPositionComInfo> positionComInfos = comInfoCache.getCacheList(HrmPositionComInfo.class, positionIds);
        // 分页参数
        PageInfo<TaxAgentManageRangeListDTO> dtoPage = PageUtil.buildPage(queryParam.getCurrent(), queryParam.getPageSize(), TaxAgentManageRangeListDTO.class);
        // 查询人员状态
        List<HrmStatus> hrmStatusList = hrmCommonHrmStatusService.list();
        // 薪资账套的人员范围po转换成列表dto
        List<TaxAgentManageRangeListDTO> taxAgentManageRangeList = TaxAgentBO.convert2ListDTO(taxAgentManageRanges, employeeComInfos, departmentComInfos, subDepartmentComInfos, positionComInfos, hrmStatusList);
        // 根据对象名称过滤
        if (StringUtils.isNotEmpty(queryParam.getTargetName())) {
            taxAgentManageRangeList = taxAgentManageRangeList.stream()
                    .filter(f -> f.getTargetName().contains(queryParam.getTargetName()))
                    .collect(Collectors.toList());
        }
        // 填充总数和当页数据
        dtoPage.setTotal(taxAgentManageRangeList.size());
        dtoPage.setList(PageUtil.subList(dtoPage.getPageNum(), dtoPage.getSize(), taxAgentManageRangeList));
        return dtoPage;
    }

    /**
     * 根据个税口角义务人id保存管理范围
     *
     * @param saveParam  保存参数
     * @param employeeId 人员id
     */
    @Override
    public void save(TaxAgentRangeSaveParam saveParam, Long employeeId) {
        // 查询薪资账套
        TaxAgentPO taxAgent = taxAgentService.getById(saveParam.getTaxAgentId());
        if (Objects.isNull(taxAgent)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(108605, "参数错误，个税扣缴义务人不存在或者已被删除"));
        }
        // 查询已有的管理范围
        List<TaxAgentManageRangePO> taxAgentManageAllRanges = listByTaxAgentId(saveParam.getTaxAgentId());

        List<TaxAgentManageRangePO> taxAgentManageRanges = taxAgentManageAllRanges.stream().filter(f -> f.getIncludeType().equals(saveParam.getIncludeType())).collect(Collectors.toList());
        // 处理一下本次的保存参数（如果原来添加过对应的人员（/部门/岗位），那么本次不需要新增，只需要更新）
        TaxAgentBO.Result result = TaxAgentBO.handleTaxAgentRange(taxAgentManageRanges, saveParam, taxAgent.getId(), employeeId);

        /** 检查当前个税扣缴义务人的所有人员范围与所有分管理员的管理范围===========================start */
        List<TaxAgentManageRangePO> allRanges = Lists.newArrayList(taxAgentManageAllRanges);
        allRanges.addAll(result.getNeedInsertTaxAgentManageRanges());
        allRanges.addAll(result.getNeedUpdateTaxAgentManageRanges());
        // 去重
        allRanges = allRanges.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(
                Comparator.comparing(f -> f.getTaxAgentId() + "." + f.getRangeType() + "." + f.getTargetType() + "." + f.getTargetId() + "." + f.getEmployeeStatus() + "." + f.getIncludeType()))
        ), ArrayList::new));
        List<DataCollectionEmployee> allSalaryEmployees = this.getManageRangeSalaryEmployees(null, saveParam.getTaxAgentId(), allRanges);
        // 如果是排除是否会对分管理范围产生影响
        List<TaxAgentManageRangePO> allSubAdminRanges = listSunAdminRangeByTaxAgentId(saveParam.getTaxAgentId());
        if (saveParam.getIncludeType().equals(NumberUtils.INTEGER_ZERO)) {
            List<DataCollectionEmployee> allSubAdminSalaryEmployees = this.getManageRangeSalaryEmployees(null, saveParam.getTaxAgentId(), allSubAdminRanges);

            List<Long> allSalaryEmployeeIds = allSalaryEmployees.stream().map(DataCollectionEmployee::getEmployeeId).collect(Collectors.toList());
            allSubAdminSalaryEmployees.removeIf(a -> allSalaryEmployeeIds.contains(a.getEmployeeId()));

            if (CollectionUtils.isNotEmpty(allSubAdminSalaryEmployees)) {
                throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(110122, "分管理员包含该范围，不能删除"));
            }
        }
        /** 检查当前个税扣缴义务人的所有人员范围与所有分管理员的管理范围===========================end */
        // 保存
        if (CollectionUtils.isNotEmpty(result.getNeedInsertTaxAgentManageRanges())) {
            this.saveBatch(result.getNeedInsertTaxAgentManageRanges());
        }
        if (CollectionUtils.isNotEmpty(result.getNeedUpdateTaxAgentManageRanges())) {
            this.updateBatchById(result.getNeedUpdateTaxAgentManageRanges());
        }

        /** 同步本地人员范围的关联人员=========================== */
        taskExecutor.execute(() -> {
            try {
                syncLocalEmp(saveParam.getTaxAgentId(), allSalaryEmployees, allSubAdminRanges, employeeId);
            } finally {
            }
        });

        // 记录日志 todo
    }

    /**
     * 获取个税口角义务人的管理范围
     *
     * @param taxAgentId
     * @return
     */
    private List<TaxAgentManageRangePO> listByTaxAgentId(Long taxAgentId) {
        return taxAgentManageRangeMapper.listSome(TaxAgentManageRangePO.builder().taxAgentId(taxAgentId).rangeType(TaxAgentRangeTypeEnum.TAXAGENT.getValue()).build());
    }

    private List<TaxAgentManageRangePO> listSunAdminRangeByTaxAgentId(Long taxAgentId) {
        return taxAgentManageRangeMapper.listSome(TaxAgentManageRangePO.builder().taxAgentId(taxAgentId).rangeType(TaxAgentRangeTypeEnum.SUBADMIN.getValue()).build());
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void save4SubAdmin(TaxAgentSubAdminRangeSaveParam saveParam, Long employeeId) {
        // 查询薪资账套
        TaxAgentSubAdminPO taxAgentSubAdmin = taxAgentSubAdminService.getById(saveParam.getSubAdminId());
        if (Objects.isNull(taxAgentSubAdmin)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(106687, "参数错误，分管理员不存在或者已被删除"));
        }
        // 查询已有的管理范围
        List<TaxAgentManageRangePO> taxAgentManageAllRanges = listBySubAdminId(saveParam.getSubAdminId());
        List<TaxAgentManageRangePO> taxAgentManageRanges = taxAgentManageAllRanges.stream().filter(f -> f.getIncludeType().equals(saveParam.getIncludeType())).collect(Collectors.toList());
        // 处理一下本次的保存参数（如果原来添加过对应的人员（/部门/岗位），那么本次不需要新增，只需要更新）
        TaxAgentBO.Result result = TaxAgentBO.handleSubAdminRange(taxAgentManageRanges, saveParam, taxAgentSubAdmin.getTaxAgentId(), taxAgentSubAdmin.getId(), employeeId);

        // 当前库中所有分管理员的管理范围
        List<TaxAgentManageRangePO> allSubAdminRangesExist = listSunAdminRangeByTaxAgentId(taxAgentSubAdmin.getTaxAgentId());
        /** 检查当前分管理员的范围与其他分管理员人员范围===========================start */
        // 当前分管理员的范围
        List<TaxAgentManageRangePO> allSubAdminRangesCuttent = Lists.newArrayList(taxAgentManageAllRanges);
        // 其他分管理员的范围
        List<TaxAgentManageRangePO> otherSubAdminRangesExist = allSubAdminRangesExist.stream().filter(f -> !f.getTaxAgentSubAdminId().equals(saveParam.getSubAdminId())).collect(Collectors.toList());
        allSubAdminRangesCuttent.addAll(result.getNeedInsertTaxAgentManageRanges());
        allSubAdminRangesCuttent.addAll(result.getNeedUpdateTaxAgentManageRanges());

        // 当前分管理员的所有人员
        List<SalaryEmployee> currentSubAdminSalaryEmployees = this.getManageRangeSalaryEmployees(null, taxAgentSubAdmin.getTaxAgentId(), allSubAdminRangesCuttent);
        // 其他分管理员的所有人员
        List<SalaryEmployee> otherSubAdminSalaryEmployees = this.getManageRangeSalaryEmployees(null, taxAgentSubAdmin.getTaxAgentId(), otherSubAdminRangesExist);
        for (SalaryEmployee se : currentSubAdminSalaryEmployees) {
            Optional<SalaryEmployee> optionalSe = otherSubAdminSalaryEmployees.stream().filter(f -> f.getEmployeeId().equals(se.getEmployeeId())).findFirst();
            if (optionalSe.isPresent()) {
                throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(110149, "不可包含其他分管理员的人员"));
            }
        }
        /** 检查当前分管理员的范围与其他分管理员人员范围===========================end */

        /** 检查当前分管理员的范围与所属个税扣缴义务人的人员范围===========================start */
        // 所属个税扣缴义务人的所有分管理员的管理范围
        List<TaxAgentManageRangePO> allSubAdminRanges = Lists.newArrayList(allSubAdminRangesExist);
        allSubAdminRanges.addAll(result.getNeedInsertTaxAgentManageRanges());
        allSubAdminRanges.addAll(result.getNeedUpdateTaxAgentManageRanges());
        // 去重
        allSubAdminRanges = allSubAdminRanges.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(
                Comparator.comparing(f -> f.getTaxAgentSubAdminId() + "." + f.getRangeType() + "." + f.getTargetType() + "." + f.getTargetId() + "." + f.getEmployeeStatus() + "." + f.getIncludeType()))
        ), ArrayList::new));
        // 所属个税扣缴义务人的所有人员
        List<TaxAgentManageRangePO> allRanges = listByTaxAgentId(taxAgentSubAdmin.getTaxAgentId());
        List<SalaryEmployee> allSalaryEmployees = this.getManageRangeSalaryEmployees(null, taxAgentSubAdmin.getTaxAgentId(), allRanges);
        // 所有分管理员的所有人员
        List<SalaryEmployee> allSubAdminSalaryEmployees = this.getManageRangeSalaryEmployees(null, taxAgentSubAdmin.getTaxAgentId(), allSubAdminRanges);
        List<Long> allSalaryEmployeeIds = allSalaryEmployees.stream().map(SalaryEmployee::getEmployeeId).collect(Collectors.toList());
        allSubAdminSalaryEmployees.removeIf(a -> allSalaryEmployeeIds.contains(a.getEmployeeId()));
        if (CollectionUtils.isNotEmpty(allSubAdminSalaryEmployees)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(110125, "超出了整体人员范围"));
        }
        /** 检查当前分管理员的范围与所属个税扣缴义务人的人员范围===========================end */

        // 保存
        if (CollectionUtils.isNotEmpty(result.getNeedInsertTaxAgentManageRanges())) {
            this.saveBatch(result.getNeedInsertTaxAgentManageRanges());
        }
        if (CollectionUtils.isNotEmpty(result.getNeedUpdateTaxAgentManageRanges())) {
            this.updateBatchById(result.getNeedUpdateTaxAgentManageRanges());
        }
        /** 同步本地人员范围的关联人员=========================== */
        List<TaxAgentManageRangePO> finalAllSubAdminRanges = allSubAdminRanges;
        taskExecutor.execute(() -> {
            try {
                DSTenantKeyThreadVar.tenantKey.set(tenantKey);
                syncLocalEmp(taxAgentSubAdmin.getTaxAgentId(), allSalaryEmployees, finalAllSubAdminRanges, employeeId);
            } finally {
                DSTenantKeyThreadVar.tenantKey.remove();
            }
        });
        // 记录日志 todo
    }

    /**
     * 根据分管理员id获取管理范围列表
     *
     * @param subAdminId
     * @return
     */
    private List<TaxAgentManageRangePO> listBySubAdminId(Long subAdminId) {
        return taxAgentManageRangeMapper.listSome(TaxAgentManageRangePO.builder().taxAgentSubAdminId(subAdminId).rangeType(TaxAgentRangeTypeEnum.SUBADMIN.getValue()).build());
    }

    private List<TaxAgentManageRangePO> listByIds(Collection<Long> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return Collections.emptyList();
        }
        return taxAgentManageRangeMapper.listSome(TaxAgentManageRangePO.builder().ids(ids).build());
    }

    @Override
    public void deleteByIds(Collection<Long> ids, Long employeeId) {
        // 查询管理范围
        List<TaxAgentManageRangePO> taxAgentManageRanges = listByIds(ids);
        if (CollectionUtils.isEmpty(taxAgentManageRanges)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(98604, "数据不存在或已被删除"));
        }
        List<Long> taxAgentIds = taxAgentManageRanges.stream().map(TaxAgentManageRangePO::getTaxAgentId).distinct().collect(Collectors.toList());
        if (taxAgentIds.size() > 1) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(110159, "一次只能删一个个税个税扣缴义务人的范围"));
        }
        Collection<Long> finalIds = ids;
        taxAgentManageRanges = this.listByTaxAgentIds(taxAgentIds);
        List<TaxAgentManageRangePO> allManageRanges = taxAgentManageRanges.stream().filter(f -> !finalIds.contains(f.getId())).collect(Collectors.toList());
        List<TaxAgentManageRangePO> allRanges = allManageRanges.stream().filter(f -> f.getRangeType().equals(TaxAgentRangeTypeEnum.TAXAGENT.getValue())).collect(Collectors.toList());
        List<TaxAgentManageRangePO> allSubAdminRanges = allManageRanges.stream().filter(f -> f.getRangeType().equals(TaxAgentRangeTypeEnum.SUBADMIN.getValue())).collect(Collectors.toList());
        Long taxAgentId = taxAgentIds.get(0);
        List<DataCollectionEmployee> allSalaryEmployees = this.getManageRangeSalaryEmployees(null, taxAgentId, allRanges);

        List<DataCollectionEmployee> allSubAdminSalaryEmployees = this.getManageRangeSalaryEmployees(null, taxAgentId, allSubAdminRanges);
        allSalaryEmployees.forEach(f -> {
            allSubAdminSalaryEmployees.removeIf(a -> a.getEmployeeId().equals(f.getEmployeeId()));
        });
        if (CollectionUtils.isNotEmpty(allSubAdminSalaryEmployees)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(110160, "分管理员存在超出整体人员范围以外的人员，不可删除"));
        }
        // 删除管理范围
        taxAgentManageRangeMapper.deleteByIds(ids);

        /** 同步本地人员范围的关联人员=========================== */
        taskExecutor.execute(() -> {
            try {
                syncLocalEmp(taxAgentId, allSalaryEmployees, allSubAdminRanges, employeeId);
            } finally {
            }
        });
        // 记录日志 todo
    }

    @Override
    public void deleteByTaxAgentIds(Collection<Long> taxAgentIds, String tenantKey) {
        new LambdaUpdateChainWrapper<>(taxAgentManageRangeMapper)
                .eq(TaxAgentManageRangePO::getDeleteType, 0)
                .eq(TaxAgentManageRangePO::getTenantKey)
                .in(TaxAgentManageRangePO::getTaxAgentId, taxAgentIds)
                .set(TaxAgentManageRangePO::getDeleteType, 1)
                .update();
        // 删除管理范围下的所有人员
        taxAgentEmployeeService.deleteByTaxAgentIds(taxAgentIds);
    }

    @Override
    public void deleteBySubAdmins(Collection<Long> subAdminIds, String tenantKey) {
        if (CollectionUtils.isEmpty(subAdminIds)) {
            return;
        }
        new LambdaUpdateChainWrapper<>(taxAgentManageRangeMapper)
                .eq(TaxAgentManageRangePO::getDeleteType, 0)
                .eq(TaxAgentManageRangePO::getTenantKey)
                .in(TaxAgentManageRangePO::getTaxAgentSubAdminId, subAdminIds)
                .set(TaxAgentManageRangePO::getDeleteType, 1)
                .update();
        // 删除管理范围下的所有人员
        taxAgentSubAdminEmployeeService.deleteBySubAdminIds(subAdminIds);
    }

    @AsyncListener(topic = "hrm_resource_queue")
    public void receiveHrmResourceQueue(AsyncBean<HrmCommonQueue> asyncBean) {
        log.info("接受到人员变动的结果:{}", JSONObject.toJSONString(asyncBean));
        // todo 过滤必要性事件类型进行处理,后续加上时间间隔，避免人事批量操作时，监听事件过多
        if (asyncBean == null || asyncBean.getMessage() == null) {
            log.error("接受到人员变动的结果失败");
        }
        String tenantKey = asyncBean.getMessage().getTenantKey();
        // 开始同步
        taskExecutor.execute(() -> {
            try {
                handleSyncTaxAgentEmpData();
            } finally {
            }
        });
    }

    /**
     * 同步处理所有人员泛微
     *
     * @param
     */
    private void handleSyncTaxAgentEmpData() {
        List<TaxAgentManageRangePO> allManageRanges = new LambdaQueryChainWrapper<>(taxAgentManageRangeMapper)
                .eq(TaxAgentManageRangePO::getTenantKey)
                .eq(TaxAgentManageRangePO::getDeleteType, 0)
                .orderByDesc(TaxAgentManageRangePO::getId)
                .list();
        if (CollectionUtils.isEmpty(allManageRanges)) {
            return;
        }
        List<Long> taxAgentIds = allManageRanges.stream().map(m -> m.getTaxAgentId()).distinct().collect(Collectors.toList());

        List<TaxAgentEmpSaveParam> taxAgentEmpSaveParamList = Lists.newArrayList();
        List<TaxAgentSubAdminEmpSaveParam> subAdminEmpSaveParamList = Lists.newArrayList();
        taxAgentIds.forEach(taxAgentId -> {
            // 当前个税扣缴义务人的所有范围
            List<TaxAgentManageRangePO> allRanges = allManageRanges.stream().filter(f -> f.getTaxAgentId().equals(taxAgentId) && f.getRangeType().equals(TaxAgentRangeTypeEnum.TAXAGENT.getValue())).collect(Collectors.toList());
            List<DataCollectionEmployee> allSalaryEmployees = this.getManageRangeSalaryEmployees(null, taxAgentId, allRanges);
            taxAgentEmpSaveParamList.add(getTaxAgentEmpSyncParam(taxAgentId, allSalaryEmployees));
            List<TaxAgentManageRangePO> allSubAdminRanges = allManageRanges.stream().filter(f -> f.getTaxAgentId().equals(taxAgentId) && f.getRangeType().equals(TaxAgentRangeTypeEnum.SUBADMIN.getValue())).collect(Collectors.toList());

            subAdminEmpSaveParamList.addAll(getTaxAgentSubAdminEmpSyncParam(taxAgentId, allSubAdminRanges));
        });
        Long employeeId = 0L;
        // 同步管理员的人员
        taxAgentEmployeeService.syncTaxAgentEmployee(taxAgentEmpSaveParamList, employeeId);
        // 同步分管理员的人员
        taxAgentSubAdminEmployeeService.syncTaxAgentSubAdminEmployee(subAdminEmpSaveParamList, employeeId);
    }

    /**
     * 获取个税扣缴义务人的同步参数
     *
     * @param taxAgentId
     * @param allSalaryEmployees
     * @return
     */
    private TaxAgentEmpSaveParam getTaxAgentEmpSyncParam(Long taxAgentId, List<DataCollectionEmployee> allSalaryEmployees) {
        return TaxAgentEmpSaveParam.builder()
                .taxAgentId(taxAgentId)
                .salaryEmployeeList(allSalaryEmployees)
                .build();
    }

    /**
     * 获取分管理员的同步参数
     *
     * @param taxAgentId
     * @param allSubAdminRanges
     * @return
     */
    private List<TaxAgentSubAdminEmpSaveParam> getTaxAgentSubAdminEmpSyncParam(Long taxAgentId, List<TaxAgentManageRangePO> allSubAdminRanges) {
        List<Long> allSubAdminIds = allSubAdminRanges.stream().map(TaxAgentManageRangePO::getTaxAgentSubAdminId).distinct().collect(Collectors.toList());
        List<TaxAgentSubAdminEmpSaveParam> subAdminEmpSaveParamList = Lists.newArrayList();
        allSubAdminIds.forEach(e -> {
            List<TaxAgentManageRangePO> singSubAdminRanges = allSubAdminRanges.stream().filter(r -> e.equals(r.getTaxAgentSubAdminId())).collect(Collectors.toList());
            List<DataCollectionEmployee> subAdminSalaryEmployees = this.getManageRangeSalaryEmployees(null, taxAgentId, singSubAdminRanges);

            subAdminEmpSaveParamList.add(TaxAgentSubAdminEmpSaveParam.builder()
                    .taxAgentId(taxAgentId)
                    .subAdminId(e)
                    .salaryEmployeeList(subAdminSalaryEmployees)
                    .build());
        });
        return subAdminEmpSaveParamList;
    }

    /**
     * 同步本地范围关联人员
     *
     * @param taxAgentId
     * @param allSalaryEmployees 个税扣缴义务人下的所有人员
     * @param allSubAdminRanges
     * @param employeeId
     */
    private void syncLocalEmp(Long taxAgentId, List<DataCollectionEmployee> allSalaryEmployees, List<TaxAgentManageRangePO> allSubAdminRanges, Long employeeId) {
        List<TaxAgentEmpSaveParam> taxAgentEmpSaveParamList = Collections.singletonList(getTaxAgentEmpSyncParam(taxAgentId, allSalaryEmployees));
        // 同步个税扣缴义务人的人员
        taxAgentEmployeeService.syncTaxAgentEmployee(taxAgentEmpSaveParamList, employeeId);

        List<TaxAgentSubAdminEmpSaveParam> subAdminEmpSaveParamList = getTaxAgentSubAdminEmpSyncParam(taxAgentId, allSubAdminRanges);
        // 同步分管理员的人员
        taxAgentSubAdminEmployeeService.syncTaxAgentSubAdminEmployee(subAdminEmpSaveParamList, employeeId);
    }
}