package com.engine.salary.service.impl;


import com.engine.common.util.ServiceUtil;
import com.engine.core.impl.Service;
import com.engine.salary.common.LocalDateRange;
import com.engine.salary.entity.datacollection.DataCollectionEmployee;
import com.engine.salary.entity.employeedeclare.bo.EmployeeDeclareList;
import com.engine.salary.entity.employeedeclare.bo.EmployeeDeclareRefresh;
import com.engine.salary.entity.employeedeclare.dto.EmployeeDeclareFailListDTO;
import com.engine.salary.entity.employeedeclare.dto.EmployeeDeclareInfoDTO;
import com.engine.salary.entity.employeedeclare.dto.EmployeeDeclareListDTO;
import com.engine.salary.entity.employeedeclare.dto.EmployeeDeclareRefreshDTO;
import com.engine.salary.entity.employeedeclare.param.*;
import com.engine.salary.entity.employeedeclare.po.EmployeeDeclarePO;
import com.engine.salary.entity.salaryarchive.dto.SalaryArchiveDataDTO;
import com.engine.salary.entity.salaryarchive.po.SalaryArchivePO;
import com.engine.salary.entity.taxagent.po.TaxAgentPO;
import com.engine.salary.enums.SalaryCycleTypeEnum;
import com.engine.salary.enums.employeedeclare.DeclareStatusEnum;
import com.engine.salary.enums.employeedeclare.EmploymentStatusEnum;
import com.engine.salary.enums.salaryaccounting.EmployeeTypeEnum;
import com.engine.salary.exception.SalaryRunTimeException;
import com.engine.salary.mapper.employeedeclare.EmployeeDeclareMapper;
import com.engine.salary.service.EmployeeDeclareService;
import com.engine.salary.service.SalaryArchiveService;
import com.engine.salary.service.SalaryEmployeeService;
import com.engine.salary.service.TaxAgentService;
import com.engine.salary.util.SalaryDateUtil;
import com.engine.salary.util.SalaryEntityUtil;
import com.engine.salary.util.SalaryI18nUtil;
import com.engine.salary.util.db.MapperProxyFactory;
import com.engine.salary.util.page.PageInfo;
import com.engine.salary.util.page.SalaryPageUtil;
import com.engine.salary.util.valid.ValidUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.transaction.annotation.Transactional;
import weaver.hrm.User;

import java.time.YearMonth;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @description: 人员报送（人员）
 * @author: xiajun
 * @modified By: xiajun
 * @date: Created in 9/2/22 3:17 PM
 * @version:v1.0
 */
@Slf4j
public class EmployeeDeclareServiceImpl extends Service implements EmployeeDeclareService {

    private EmployeeDeclareMapper getEmployeeDeclareMapper() {
        return MapperProxyFactory.getProxy(EmployeeDeclareMapper.class);
    }

    private TaxAgentService getTaxAgentService(User user) {
        return ServiceUtil.getService(TaxAgentServiceImpl.class, user);
    }

    private SalaryEmployeeService getSalaryEmployeeService(User user) {
        return ServiceUtil.getService(SalaryEmployeeServiceImpl.class, user);
    }

    private SalaryArchiveService getSalaryArchiveService(User user) {
        return ServiceUtil.getService(SalaryArchiveServiceImpl.class, user);
    }

    @Override
    public EmployeeDeclarePO getById(Long id) {
        return getEmployeeDeclareMapper().getById(id);
    }

    @Override
    public List<EmployeeDeclarePO> listByIds(Collection<Long> ids) {
        if (CollectionUtils.isEmpty(ids)){
            return Collections.emptyList();
        }
        return getEmployeeDeclareMapper().listSome(EmployeeDeclarePO.builder().ids(ids).build());
    }

    @Override
    public List<EmployeeDeclarePO> listByTaxCycleAndTaxAgentId(YearMonth taxCycle, Long taxAgentId) {
        return getEmployeeDeclareMapper().listSome(EmployeeDeclarePO.builder()
                .taxCycle(taxCycle.toString())
                .taxAgentId(taxAgentId)
                .build());
    }

    @Override
    public List<EmployeeDeclarePO> listByTaxCycleAndTaxAgentIdAndEmployeeIds(YearMonth taxCycle, Long taxAgentId, Collection<Long> employeeIds) {
        if (CollectionUtils.isEmpty(employeeIds)) {
            return Collections.emptyList();
        }
        return getEmployeeDeclareMapper().listSome(EmployeeDeclarePO.builder()
                .taxCycle(taxCycle.toString())
                .taxAgentId(taxAgentId)
                .employeeIds(employeeIds)
                .build());
    }

    @Override
    public List<EmployeeDeclarePO> listByParam(EmployeeDeclareListQueryParam queryParam) {
        return getEmployeeDeclareMapper().listByParam(queryParam);
    }


    @Override
    public List<EmployeeDeclarePO> list4AddByParam(EmployeeDeclareAddListQueryParam queryParam) {
        queryParam.setPreTaxCycle(queryParam.getTaxCycle().plus(-1, ChronoUnit.MONTHS).toString());
        return getEmployeeDeclareMapper().list4AddByParam(queryParam);
    }

    @Override
    public List<EmployeeDeclarePO> list4UpdateByParam(EmployeeDeclareListQueryParam queryParam) {
        return getEmployeeDeclareMapper().list4UpdateByParam(queryParam);
    }

    @Override
    public PageInfo<EmployeeDeclarePO> listPage4UpdateByParam(EmployeeDeclareListQueryParam queryParam) {
        List<EmployeeDeclarePO> list = getEmployeeDeclareMapper().list4UpdateByParam(queryParam);
        return SalaryPageUtil.buildPage(queryParam.getCurrent(), queryParam.getPageSize(), list, EmployeeDeclarePO.class);
    }

//    @Override
//    public List<EmployeeDeclarePO> list4FailByParam(EmployeeDeclareFailListQueryParam queryParam) {
//        return new LambdaQueryChainWrapper<>(employeeDeclareMapper)
//                .eq(EmployeeDeclarePO::getTenantKey, tenantKey)
//                .eq(EmployeeDeclarePO::getDeleteType, DeleteTypeEnum.NOT_DELETED.getValue())
//                .eq(EmployeeDeclarePO::getTaxAgentId, queryParam.getTaxAgentId())
//                .eq(EmployeeDeclarePO::getTaxCycle, queryParam.getTaxCycle().toString())
//                .eq(EmployeeDeclarePO::getDeclareStatus, DeclareStatusEnum.DECLARE_FAIL.getValue())
//                .list();
//    }

    @Override
    public PageInfo<EmployeeDeclarePO> listPage4FailByParam(EmployeeDeclareFailListQueryParam queryParam) {
        ValidUtil.doValidator(queryParam);
        List<EmployeeDeclarePO> list = getEmployeeDeclareMapper().listSome(EmployeeDeclarePO.builder()
                .taxAgentId(queryParam.getTaxAgentId())
                .taxCycle(queryParam.getTaxCycle().toString())
                .declareStatus(DeclareStatusEnum.DECLARE_FAIL.getValue())
                .build());
        PageInfo<EmployeeDeclarePO> page = SalaryPageUtil.buildPage(queryParam.getCurrent(), queryParam.getPageSize(),
                list, EmployeeDeclarePO.class);
        return page;
    }

//    @Override
//    public void save(EmployeeDeclareSaveParam saveParam, Long employeeId) {
//        LocalDateTime now = LocalDateTime.now();
//        EmployeeDeclarePO employeeDeclare = new EmployeeDeclarePO()
//                .setTaxAgentId(saveParam.getTaxAgentId())
//                .setTaxCycle(saveParam.getTaxCycle().toString())
//                .setEmployeeName(saveParam.getEmployeeName())
//                .setJobNum(saveParam.getJobNum())
//                .setCardType(CardTypeEnum.RESIDENT_IDENTITY_CARDS.getValue())
//                .setCardNum(saveParam.getCardNum())
//                .setGender(SalaryCardUtil.judgeGender(saveParam.getCardNum()).getValue())
//                .setBirthday(SalaryCardUtil.judgeBirthday(saveParam.getCardNum()))
//                .setEmploymentStatus(saveParam.getEmploymentStatus().getValue())
//                .setMobile(saveParam.getMobile())
//                .setEmploymentType(saveParam.getEmploymentType().getValue())
//                .setEmploymentFirstYear("")
//                .setEmploymentDate(saveParam.getEmploymentDate())
//                .setDismissDate(saveParam.getDismissDate())
//                .setDisability(saveParam.getDisability().getValue())
//                .setDisabilityCardNo(saveParam.getDisabilityCardNo())
//                .setLonelyOld(saveParam.getLonelyOld().getValue())
//                .setMartyrDependents(saveParam.getMartyrDependents().getValue())
//                .setMartyrDependentsCardNo(saveParam.getMartyrDependentsCardNo())
//                .setDeductExpenses(saveParam.getDeductExpenses().getValue())
//                .setSuccessfullyDeclared(0)
//                .setNewEmployeeInfo(0)
//                .setDeclareStatus(DeclareStatusEnum.NOT_DECLARE.getValue())
//                .setDeclareErrorMsg("");
//        if (Objects.isNull(saveParam.getId())) {
//            employeeDeclare.setId(IdGenerator.generate())
//                    .setEmployeeId(saveParam.getEmployeeId())
//                    .setEmployeeType(saveParam.getEmployeeType().getValue())
//                    .setTenantKey(tenantKey)
//                    .setCreator(employeeId)
//                    .setDeleteType(DeleteTypeEnum.NOT_DELETED.getValue())
//                    .setCreateTime(now)
//                    .setUpdateTime(now);
//            save(employeeDeclare);
//            // 记录日志
//            LoggerContext<EmployeeDeclarePO> loggerContext = new LoggerContext<>();
//            loggerContext.setTargetId(Util.null2String(saveParam.getTaxAgentId()));
//            loggerContext.setTargetName(employeeDeclare.getEmployeeName());
//            loggerContext.setOperateType(OperateTypeEnum.ADD.getValue());
//            loggerContext.setOperateTypeName(SalaryI18nUtil.getI18nLabel(156441, "新增报送人员"));
//            loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(156441, "新增报送人员：") + employeeDeclare.getEmployeeName());
//            loggerContext.setNewValues(employeeDeclare);
//            employeeDeclareLoggerTemplate.write(loggerContext);
//        } else {
//            EmployeeDeclarePO originEmployeeDeclare = getById(saveParam.getId(), tenantKey);
//            if (Objects.isNull(originEmployeeDeclare)) {
//                throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(156442, "人员不存在或已被删除"));
//            }
//            if (Objects.equals(originEmployeeDeclare.getSuccessfullyDeclared(), 1)
//                    && !Objects.equals(originEmployeeDeclare.getEmployeeName(), employeeDeclare.getEmployeeName())
//                    && !Objects.equals(originEmployeeDeclare.getCardNum(), employeeDeclare.getCardNum())) {
//                throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(156443, "成功报送过的人员，姓名和证件号码只能修改其一，同时需要修改的请前往办税服务厅"));
//            }
//            employeeDeclare.setId(originEmployeeDeclare.getId())
//                    .setEmployeeId(originEmployeeDeclare.getEmployeeId())
//                    .setEmployeeType(originEmployeeDeclare.getEmployeeType())
//                    .setSuccessfullyDeclared(originEmployeeDeclare.getSuccessfullyDeclared())
//                    .setUpdateTime(now);
//            // 判断本次编辑是否有修改人员信息
//            if (!StringUtils.equals(employeeDeclare.toCompareString(), originEmployeeDeclare.toCompareString())) {
//                employeeDeclare.setNewEmployeeInfo(1);
//            }
//            updateById(employeeDeclare);
//            // 记录日志
//            LoggerContext<EmployeeDeclarePO> loggerContext = new LoggerContext<>();
//            loggerContext.setTargetId(Util.null2String(saveParam.getTaxAgentId()));
//            loggerContext.setTargetName(employeeDeclare.getEmployeeName());
//            loggerContext.setOperateType(OperateTypeEnum.UPDATE.getValue());
//            loggerContext.setOperateTypeName(SalaryI18nUtil.getI18nLabel(156444, "编辑报送人员"));
//            loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(156444, "编辑报送人员：") + employeeDeclare.getEmployeeName());
//            loggerContext.setOldValues(originEmployeeDeclare);
//            loggerContext.setNewValues(employeeDeclare);
//            employeeDeclareLoggerTemplate.write(loggerContext);
//        }
//    }
//
//    @Override
//    public void batchUpdate(EmployeeDeclareBatchUpdateParam batchUpdateParam, Long employeeId) {
//        // 查询报送人员
//        List<EmployeeDeclarePO> employeeDeclares;
//        if (CollectionUtils.isNotEmpty(batchUpdateParam.getIds())) {
//            employeeDeclares = listByIds(batchUpdateParam.getIds(), tenantKey);
//        } else {
//            employeeDeclares = listByParam(batchUpdateParam, tenantKey);
//        }
//        // 人员为空时，不允许批量编辑
//        if (CollectionUtils.isEmpty(employeeDeclares)) {
//            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(182693, "当前人员列表为空，请选择要批量编辑的人员"));
//        }
//        LocalDateTime now = LocalDateTime.now();
//        // 校验参数
//        if (Objects.equals(batchUpdateParam.getBatchUpdateItem(), "employmentStatus")) {
//            EmploymentStatusEnum employmentStatusEnum = null;
//            for (EmploymentStatusEnum value : EmploymentStatusEnum.values()) {
//                if (Objects.equals(value.name(), batchUpdateParam.getItemValue())) {
//                    employmentStatusEnum = value;
//                }
//            }
//            if (employmentStatusEnum == null) {
//                throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(84026, "参数错误"));
//            }
//            for (EmployeeDeclarePO employeeDeclare : employeeDeclares) {
//                if (!Objects.equals(employeeDeclare.getEmploymentStatus(), employmentStatusEnum.getValue())) {
//                    employeeDeclare.setEmploymentStatus(employmentStatusEnum.getValue());
//                    employeeDeclare.setNewEmployeeInfo(1);
//                    employeeDeclare.setDeclareStatus(DeclareStatusEnum.NOT_DECLARE.getValue());
//                    employeeDeclare.setDeclareErrorMsg("");
//                    employeeDeclare.setUpdateTime(now);
//                }
//            }
//        } else if (Objects.equals(batchUpdateParam.getBatchUpdateItem(), "employmentType")) {
//            EmploymentTypeEnum employmentTypeEnum = null;
//            for (EmploymentTypeEnum value : EmploymentTypeEnum.values()) {
//                if (Objects.equals(value.name(), batchUpdateParam.getItemValue())) {
//                    employmentTypeEnum = value;
//                }
//            }
//            if (employmentTypeEnum == null) {
//                throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(84026, "参数错误"));
//            }
//            for (EmployeeDeclarePO employeeDeclare : employeeDeclares) {
//                if (!Objects.equals(employeeDeclare.getEmploymentType(), employmentTypeEnum.getValue())) {
//                    employeeDeclare.setEmploymentType(employmentTypeEnum.getValue());
//                    employeeDeclare.setNewEmployeeInfo(1);
//                    employeeDeclare.setDeclareStatus(DeclareStatusEnum.NOT_DECLARE.getValue());
//                    employeeDeclare.setDeclareErrorMsg("");
//                    employeeDeclare.setUpdateTime(now);
//                }
//            }
//        } else if (Objects.equals(batchUpdateParam.getBatchUpdateItem(), "employmentDate")) {
//            if (!SalaryDateUtil.checkDay(batchUpdateParam.getItemValue())) {
//                throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(84026, "参数错误"));
//            }
//            LocalDate employmentDate = LocalDate.parse(batchUpdateParam.getItemValue());
//            for (EmployeeDeclarePO employeeDeclare : employeeDeclares) {
//                if (!Objects.equals(employeeDeclare.getEmploymentDate(), employmentDate)) {
//                    employeeDeclare.setEmploymentDate(employmentDate);
//                    employeeDeclare.setNewEmployeeInfo(1);
//                    employeeDeclare.setDeclareStatus(DeclareStatusEnum.NOT_DECLARE.getValue());
//                    employeeDeclare.setDeclareErrorMsg("");
//                    employeeDeclare.setUpdateTime(now);
//                }
//            }
//        } else if (Objects.equals(batchUpdateParam.getBatchUpdateItem(), "dismissDate")) {
//            if (!SalaryDateUtil.checkDay(batchUpdateParam.getItemValue())) {
//                throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(84026, "参数错误"));
//            }
//            LocalDate dismissDate = LocalDate.parse(batchUpdateParam.getItemValue());
//            for (EmployeeDeclarePO employeeDeclare : employeeDeclares) {
//                if (!Objects.equals(employeeDeclare.getDismissDate(), dismissDate)) {
//                    employeeDeclare.setDismissDate(dismissDate);
//                    employeeDeclare.setNewEmployeeInfo(1);
//                    employeeDeclare.setDeclareStatus(DeclareStatusEnum.NOT_DECLARE.getValue());
//                    employeeDeclare.setDeclareErrorMsg("");
//                    employeeDeclare.setUpdateTime(now);
//                }
//            }
//        } else if (Objects.equals(batchUpdateParam.getBatchUpdateItem(), "deductExpenses")) {
//            SalaryOnOffEnum salaryOnOffEnum = null;
//            for (SalaryOnOffEnum value : SalaryOnOffEnum.values()) {
//                if (Objects.equals(value.name(), batchUpdateParam.getItemValue())) {
//                    salaryOnOffEnum = value;
//                }
//            }
//            if (salaryOnOffEnum == null) {
//                throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(84026, "参数错误"));
//            }
//            for (EmployeeDeclarePO employeeDeclare : employeeDeclares) {
//                if (!Objects.equals(employeeDeclare.getDeductExpenses(), salaryOnOffEnum.getValue())) {
//                    employeeDeclare.setDeductExpenses(salaryOnOffEnum.getValue());
//                    employeeDeclare.setNewEmployeeInfo(1);
//                    employeeDeclare.setDeclareStatus(DeclareStatusEnum.NOT_DECLARE.getValue());
//                    employeeDeclare.setDeclareErrorMsg("");
//                    employeeDeclare.setUpdateTime(now);
//                }
//            }
//        }
//        updateBatchById(employeeDeclares);
//    }

    @Override
    public void deleteByIds(Collection<Long> ids) {
        List<EmployeeDeclarePO> employeeDeclares = listByIds(ids);
        if (CollectionUtils.isEmpty(employeeDeclares)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(156466, "参数错误，人员不存在或已被删除"));
        }
        boolean declareSuccess = employeeDeclares.stream().anyMatch(e -> Objects.equals(e.getSuccessfullyDeclared(), 1));
        if (declareSuccess) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(156467, "报送成功过的人员不允许删除"));
        }
        getEmployeeDeclareMapper().deleteByIds(ids, new Date());
        // 记录日志
//        for (EmployeeDeclarePO employeeDeclare : employeeDeclares) {
//            LoggerContext<EmployeeDeclarePO> loggerContext = new LoggerContext<>();
//            loggerContext.setTargetId(Util.null2String(employeeDeclare.getTaxAgentId()));
//            loggerContext.setTargetName(employeeDeclare.getEmployeeName());
//            loggerContext.setOperateType(OperateTypeEnum.DELETE.getValue());
//            loggerContext.setOperateTypeName(SalaryI18nUtil.getI18nLabel(156445, "删除报送人员"));
//            loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(156445, "删除报送人员：") + employeeDeclare.getEmployeeName());
//            loggerContext.setNewValues(employeeDeclare);
//            employeeDeclareLoggerTemplate.write(loggerContext);
//        }
    }

    @Override
    public List<EmployeeDeclareListDTO> convert(List<EmployeeDeclarePO> employeeDeclares) {
        if (CollectionUtils.isEmpty(employeeDeclares)) {
            return Collections.emptyList();
        }

        // 查询个税扣缴义务人
        Set<Long> taxAgentIds = SalaryEntityUtil.properties(employeeDeclares, EmployeeDeclarePO::getTaxAgentId);
        List<TaxAgentPO> taxAgents = getTaxAgentService(user).listByIds(taxAgentIds);
        List<EmployeeDeclareListDTO> dtoList = EmployeeDeclareList.convert(employeeDeclares, taxAgents);
        // 人员id集合
        List<Long> employeeIds = employeeDeclares.stream().map(EmployeeDeclarePO::getEmployeeId).distinct().collect(Collectors.toList());
        // 获取人员部门、分部详细信息
        Map<String, DataCollectionEmployee> employeeInfoMap = SalaryEntityUtil.convert2Map(getSalaryEmployeeService(user).getEmployeeByIdsAll(employeeIds), emp -> emp.getEmployeeId() + "-" + emp.isExtEmp());
        // 补充分部，部门
        dtoList.forEach(po -> {
            boolean isExtEmp = EmployeeTypeEnum.EXT_EMPLOYEE.getValue().compareTo(po.getEmployeeType().getValue()) == 0;
            DataCollectionEmployee employee = employeeInfoMap.get(po.getEmployeeId() + "-" + isExtEmp);
            if(ObjectUtils.isNotEmpty(employee)){
                po.setSubCompanyName(Optional.ofNullable(employee.getSubcompanyName()).orElse(""));
                po.setDepartmentName(Optional.ofNullable(employee.getDepartmentName()).orElse(""));
            }
        });
        return dtoList;
    }

    @Override
    public List<EmployeeDeclareFailListDTO> convert2FailListDTO(List<EmployeeDeclarePO> employeeDeclares) {
        if (CollectionUtils.isEmpty(employeeDeclares)) {
            return Collections.emptyList();
        }
        // 查询人员信息
        List<Long> employeeIds = SalaryEntityUtil.properties(employeeDeclares, EmployeeDeclarePO::getEmployeeId, Collectors.toList());
        Map<String, DataCollectionEmployee> employeeInfoMap = SalaryEntityUtil.convert2Map(getSalaryEmployeeService(user).getEmployeeByIdsAll(employeeIds), emp -> emp.getEmployeeId() + "-" + emp.isExtEmp());
        return EmployeeDeclareList.convert2FailListDTO(employeeDeclares, employeeInfoMap);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void refresh(EmployeeDeclareRefreshParam refreshParam, Long employeeId) {
        // 查询本月已有的需要报送的人员
        List<EmployeeDeclarePO> employeeDeclares = listByTaxCycleAndTaxAgentId(refreshParam.getTaxCycle(), refreshParam.getTaxAgentId());
        // 查询上月已有的需要报送的人员(只需要正常的)
        List<EmployeeDeclarePO> preTaxCycleEmployeeDeclares = listByTaxCycleAndTaxAgentId(refreshParam.getTaxCycle().plus(-1,ChronoUnit.MONTHS), refreshParam.getTaxAgentId())
                .stream()
                .filter(e -> Objects.equals(e.getEmploymentStatus(), EmploymentStatusEnum.NORMAL.getValue())
                        && Objects.equals(e.getDeclareStatus(), DeclareStatusEnum.DECLARE_SUCCESS.getValue()))
                .collect(Collectors.toList());
        // 查询个税扣缴义务人
        TaxAgentPO taxAgent = getTaxAgentService(user).getById(refreshParam.getTaxAgentId());
        // 根据税款所属期计算出薪资周期
        YearMonth salaryCycle;
        YearMonth taxCycle = refreshParam.getTaxCycle();
        // TODO：先临时写死本月！！！！需先完成个税扣缴义务人的改造
//        SalaryCycleTypeEnum salaryCycleTypeEnum = SalaryEnumUtil.enumMatchByValue(taxAgent.getTaxCycleType(), SalaryCycleTypeEnum.class);
        SalaryCycleTypeEnum salaryCycleTypeEnum = SalaryCycleTypeEnum.THIS_MONTH;
        if (salaryCycleTypeEnum == SalaryCycleTypeEnum.BEFORE_LAST_MONTH) {
            salaryCycle = taxCycle.plus(2, ChronoUnit.MONTHS);
        } else if (salaryCycleTypeEnum == SalaryCycleTypeEnum.LAST_MONTH) {
            salaryCycle = taxCycle.plus(1, ChronoUnit.MONTHS);
        } else if (salaryCycleTypeEnum == SalaryCycleTypeEnum.THIS_MONTH) {
            salaryCycle = taxCycle;
        } else if (salaryCycleTypeEnum == SalaryCycleTypeEnum.NEXT_MONTH) {
            salaryCycle = taxCycle.plus(-1, ChronoUnit.MONTHS);
        } else {
            salaryCycle = taxCycle;
        }
        // 查询薪资档案的发薪人员
        LocalDateRange salaryCycleRange = LocalDateRange.builder().fromDate(SalaryDateUtil.localDateToDate(salaryCycle.atDay(1))).endDate(SalaryDateUtil.localDateToDate(salaryCycle.atEndOfMonth())).build();
        List<SalaryArchiveDataDTO> salaryArchiveDataDTOS = getSalaryArchiveService(user).getSalaryArchiveTaxAgentData(salaryCycleRange, Collections.emptyList(), refreshParam.getTaxAgentId());
        List<Long> employeeIds = salaryArchiveDataDTOS.stream().map(SalaryArchiveDataDTO::getEmployeeId).collect(Collectors.toList());
        List<SalaryArchivePO> salaryArchivePOS = getSalaryArchiveService(user).listSome(SalaryArchivePO.builder().taxAgentId(refreshParam.getTaxAgentId()).employeeIds(employeeIds).build());

        // 本月增加了哪些人员
        Set<Long> orgEmployeeIds = ((List<EmployeeDeclarePO>)CollectionUtils.union(preTaxCycleEmployeeDeclares, employeeDeclares))
                .stream()
                .filter(e -> Objects.equals(e.getEmployeeType(), EmployeeTypeEnum.ORGANIZATION.getValue()))
                .map(EmployeeDeclarePO::getEmployeeId)
                .collect(Collectors.toSet());
        Set<Long> newOrgEmployeeIds = salaryArchiveDataDTOS.stream()
                .map(SalaryArchiveDataDTO::getEmployeeId)
                .filter(e -> !orgEmployeeIds.contains(e))
                .collect(Collectors.toSet());
        // 查询新增加的人员信息
        List<DataCollectionEmployee> employeeInfos = getSalaryEmployeeService(user).getEmployeeByIdsAll(new ArrayList<>(newOrgEmployeeIds));
//        List<SimpleUserInfo> newSimpleUserInfos = salaryEmployeeService.listByEmployeeIds(newOrgEmployeeIds, tenantKey);
//        List<HrmEmployeeComInfo> newHrmEmployeeComInfos = comInfoCache.getCacheList(HrmEmployeeComInfo.class, Lists.newArrayList(newOrgEmployeeIds));
        // 查询本月增加了哪些非系统人员
//        List<ExtEmployeePO> extEmployees = extEmployeeService.listBySalaryCycleAndTaxAgentId(salaryCycleRange, refreshParam.getTaxAgentId(), tenantKey);
//        Set<Long> extEmployeeIds = employeeDeclares.stream()
//                .filter(e -> Objects.equals(e.getEmployeeType(), EmployeeTypeEnum.EXT_EMPLOYEE.getValue()))
//                .map(EmployeeDeclarePO::getEmployeeId)
//                .collect(Collectors.toSet());
//        List<ExtEmployeePO> newExtEmployees = extEmployees.stream()
//                .filter(e -> !extEmployeeIds.contains(e.getId()))
//                .collect(Collectors.toList());

        // 本次新增的需要报送的人员
        EmployeeDeclareRefreshDTO dto = new EmployeeDeclareRefreshDTO()
                .setTaxAgentId(taxAgent.getId())
                .setTaxCycle(taxCycle)
                .setEmployeeDeclares(employeeDeclares)
                .setPreTaxCycleEmployeeDeclare(preTaxCycleEmployeeDeclares)
                .setSalaryArchives(salaryArchivePOS)
                .setEmployeeInfos(employeeInfos);
//                .setHrmEmployeeComInfos(newHrmEmployeeComInfos)
//                .setSimpleUserInfos(newSimpleUserInfos)
//                .setExtEmployees(newExtEmployees)
        EmployeeDeclareRefresh.Result result = EmployeeDeclareRefresh.refresh(dto, employeeId);
//        // 保存新增的人员
//        if (CollectionUtils.isNotEmpty(result.getNewEmployeeDeclares())) {
//            saveBatch(result.getNewEmployeeDeclares());
//        }
//        // 更新已有人员
//        if (CollectionUtils.isNotEmpty(result.getEmployeeDeclares())) {
//            updateBatchById(result.getEmployeeDeclares());
//        }
//        // 记录日志
//        LoggerContext<EmployeeDeclarePO> loggerContext = new LoggerContext<>();
//        loggerContext.setTargetId(refreshParam.getTaxAgentId() + "-" + refreshParam.getTaxCycle().toString());
//        loggerContext.setTargetName(SalaryI18nUtil.getI18nLabel(tenantKey, employeeId, 156468, "个税扣缴义务人:「{0}」税款所属期:「{1}」").replace("{0}", taxAgent.getName()).replace("{1}", refreshParam.getTaxCycle().toString()));
//        loggerContext.setOperator(Util.null2String(employeeId));
//        loggerContext.setOperateType(OperateTypeEnum.UPDATE.getValue());
//        loggerContext.setOperateTypeName(SalaryI18nUtil.getI18nLabel(tenantKey, employeeId, 156447, "刷新数据"));
//        loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(tenantKey, employeeId, 156447, "刷新数据"));
//        employeeDeclareLoggerTemplate.write(loggerContext);
    }

    @Override
    public EmployeeDeclareInfoDTO getDeclareInfo(EmployeeDeclareParam employeeDeclareParam) {
        // 查询本月已有的需要报送的人员
        List<EmployeeDeclarePO> employeeDeclares = listByTaxCycleAndTaxAgentId(employeeDeclareParam.getTaxCycle(), employeeDeclareParam.getTaxAgentId());
        // 本月是否有修改过人员信息
        boolean updateEmployeeInfo = employeeDeclares.stream().anyMatch(e -> Objects.equals(e.getNewEmployeeInfo(), 1) && Objects.equals(e.getDeclareStatus(), DeclareStatusEnum.NOT_DECLARE.getValue()));
        // 本月报送失败的人数
        Integer declareFailSize = (int) employeeDeclares.stream().filter(e -> Objects.equals(e.getDeclareStatus(), DeclareStatusEnum.DECLARE_FAIL.getValue())).count();
        // 本月未报送的人数
        Integer notDeclareSize = (int) employeeDeclares.stream().filter(e -> Objects.equals(e.getDeclareStatus(), DeclareStatusEnum.NOT_DECLARE.getValue())).count();
        // 本月报送成功的人数
        Integer declareSuccessSize = (int) employeeDeclares.stream().filter(e -> Objects.equals(e.getDeclareStatus(), DeclareStatusEnum.DECLARE_SUCCESS.getValue())).count();
        return new EmployeeDeclareInfoDTO()
                .setShowUpdate(updateEmployeeInfo)
                .setDeclareFailSize(declareFailSize)
                .setNotDeclareSize(notDeclareSize)
                .setDeclareSuccessSize(declareSuccessSize);
    }

//    @Override
//    @Transactional(rollbackFor = Exception.class)
//    public void declare(EmployeeDeclareParam param, Long employeeId) {
//        // 获取api配置信息
//        TaxDeclarationApiConfigPO apiConfig = taxDeclarationApiConfigService.getConfig(tenantKey, employeeId, true);
//        // 查询个税扣缴义务人
//        TaxAgentPO taxAgent = taxAgentService.getById(param.getTaxAgentId(), employeeId, tenantKey);
//        // 查询个税扣缴义务人关联的企业信息
//        TaxAgentTaxReturnPO taxAgentTaxReturn = taxAgentTaxReturnService.getByTaxAgentId(param.getTaxAgentId(), tenantKey);
//        if (Objects.isNull(taxAgentTaxReturn) || !Objects.equals(taxAgentTaxReturn.getCheckStatus(), TaxAgentTaxReturnStatusEnum.SUCCESS.getValue())) {
//            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(tenantKey, employeeId, 156469, "个税扣缴义务人的报税信息验证未通过，请先维护好个税扣缴义务人的报税信息"));
//        }
//        // 查询需要报送的人员
//        List<EmployeeDeclarePO> employeeDeclares = listByTaxCycleAndTaxAgentId(param.getTaxCycle(), param.getTaxAgentId(), tenantKey);
//        if (CollectionUtils.isEmpty(employeeDeclares)) {
//            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(tenantKey, employeeId, 156470, "当前报送人员列表暂无数据"));
//        }
//        EmployeeDeclareRecordPO employeeDeclareRecord = employeeDeclareRecordService.getByTaxCycleAndTaxAgentId(param.getTaxCycle(), param.getTaxAgentId(), tenantKey);
//        if (employeeDeclareRecord != null && StringUtils.isNotEmpty(employeeDeclareRecord.getRequestId())) {
//            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(tenantKey, employeeId, 156471, "报送中，稍后请点击【获取报送结果】更新报送状态"));
//        }
//        // 人员列表
//        List<Map<String, Object>> employeeInfoMapList = EmployeeDeclareRequest.convert2RequestParam(employeeDeclares);
//        // 企业信息
//        Map<String, Object> requestParam = TaxAgentTaxReturnBO.convert2RequestMap(taxAgent, taxAgentTaxReturn);
//        // 税款所属期
//        requestParam.put("skssq", param.getTaxCycle().toString().replace("-", ""));
//        // 人员列表
//        requestParam.put("rylb", employeeInfoMapList);
//
//        String reqJson = JsonUtil.toJsonString(requestParam);
//        String url = apiConfig.getHost() + SzyhApiConstant.DECLARE_EMPLOYEE_INFO;
//        Map<String, String> params = new HashMap<>(1);
//        Map<String, String> header = SingnatureData.initHeader(params, apiConfig.getAppKey(), apiConfig.getAppSecret());
//        String res = HttpUtil.doPost(url, header, reqJson, HttpUtil.JSON_TYPE);
//        DeclareEmployeeInfoResponse declareEmployeeInfoResponse = JsonUtil.parseObject(res, DeclareEmployeeInfoResponse.class);
//        if (Objects.isNull(declareEmployeeInfoResponse) || Objects.isNull(declareEmployeeInfoResponse.getHead())) {
//            log.error("服务异常:" + res);
//            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(tenantKey, employeeId, 156449, "服务异常"));
//        }
//        if (!Objects.equals(declareEmployeeInfoResponse.getHead().getCode(), SzyhApiConstant.SUCCESS_CODE)) {
//            throw new SalaryRunTimeException(declareEmployeeInfoResponse.getHead().getMsg());
//        }
//        // 删除原来的人员报送记录
//        employeeDeclareRecordService.deleteByTaxCycleAndTaxAgentId(param.getTaxCycle(), param.getTaxAgentId(), tenantKey);
//        // 保存新的人员报送记录
//        LocalDateTime now = LocalDateTime.now();
//        AsyncRequestIdDTO asyncRequestIdDTO = declareEmployeeInfoResponse.getBody();
//        employeeDeclareRecord = new EmployeeDeclareRecordPO()
//                .setId(IdGenerator.generate())
//                .setTaxAgentId(param.getTaxAgentId())
//                .setTaxCycle(param.getTaxCycle().toString())
//                .setRequestId(asyncRequestIdDTO.getRequestId())
//                .setTenantKey(tenantKey)
//                .setCreator(employeeId)
//                .setDeleteType(DeleteTypeEnum.NOT_DELETED.getValue())
//                .setCreateTime(now)
//                .setUpdateTime(now);
//        employeeDeclareRecordService.save(employeeDeclareRecord);
//        // 记录日志
//        LoggerContext<EmployeeDeclarePO> loggerContext = new LoggerContext<>();
//        loggerContext.setTargetId(param.getTaxAgentId() + "-" + param.getTaxCycle().toString());
//        loggerContext.setTargetName(SalaryI18nUtil.getI18nLabel(tenantKey, employeeId, 156468, "个税扣缴义务人:「{0}」税款所属期:「{1}」").replace("{0}", taxAgent.getName()).replace("{1}", param.getTaxCycle().toString()));
//        loggerContext.setOperator(Util.null2String(employeeId));
//        loggerContext.setOperateType(OperateTypeEnum.UPDATE.getValue());
//        loggerContext.setOperateTypeName(SalaryI18nUtil.getI18nLabel(tenantKey, employeeId, 156450, "全部报送"));
//        loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(tenantKey, employeeId, 156450, "全部报送"));
//        employeeDeclareLoggerTemplate.write(loggerContext);
//    }
//
//    @Override
//    @Transactional(rollbackFor = Exception.class)
//    public void getDeclareFeedback(EmployeeDeclareParam param, EmployeeDeclareRateDTO employeeDeclareRate, Long employeeId) {
//        // 获取api配置信息
//        TaxDeclarationApiConfigPO apiConfig = taxDeclarationApiConfigService.getConfig(tenantKey, employeeId, true);
//        // 查询个税扣缴义务人
//        TaxAgentPO taxAgent = taxAgentService.getById(param.getTaxAgentId(), employeeId, tenantKey);
//        // 查询人员报送记录
//        EmployeeDeclareRecordPO employeeDeclareRecord = employeeDeclareRecordService.getByTaxCycleAndTaxAgentId(param.getTaxCycle(), param.getTaxAgentId(), tenantKey);
//        if (Objects.isNull(employeeDeclareRecord)) {
//            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(tenantKey,employeeId,156451, "请先报送后再获取报送结果"));
//        }
//        if (StringUtils.isEmpty(employeeDeclareRecord.getRequestId())) {
//            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(tenantKey,employeeId,156451, "请先报送后再获取报送结果"));
//        }
//
//        String url = apiConfig.getHost() + SzyhApiConstant.DECLARE_EMPLOYEE_INFO_FEEDBACK;
//        Map<String, String> requestParam = ImmutableMap.of("requestId", employeeDeclareRecord.getRequestId());
//        Map<String, String> header = SingnatureData.initHeader(Collections.emptyMap(), apiConfig.getAppKey(), apiConfig.getAppSecret());
//        String res = HttpUtil.getRequest(url, header, requestParam);
//        DeclareEmployeeFeedbackResponse declareEmployeeFeedbackResponse = JsonUtil.parseObject(res, DeclareEmployeeFeedbackResponse.class);
//        if (Objects.isNull(declareEmployeeFeedbackResponse) || Objects.isNull(declareEmployeeFeedbackResponse.getHead())) {
//            log.error("服务异常:" + res);
//            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(tenantKey,employeeId,156449, "服务异常"));
//        }
//        if (!Objects.equals(declareEmployeeFeedbackResponse.getHead().getCode(), SzyhApiConstant.SUCCESS_CODE)) {
//            throw new SalaryRunTimeException(declareEmployeeFeedbackResponse.getHead().getMsg());
//        }
//        DeclareEmployeeFeedbackResponse.DeclareEmployeeFeedbackResponseBody declareEmployeeFeedbackResponseBody = declareEmployeeFeedbackResponse.getBody();
//        Map<String, Map<String, Object>> employeeFeedbackMap = SalaryEntityUtil.convert2Map(declareEmployeeFeedbackResponseBody.getBsjg(), e -> e.getOrDefault("xm", "")
//                + "-" + e.getOrDefault("zzlx", "")
//                + "-" + e.getOrDefault("zzhm", ""));
//        // 流量使用情况
//        TaxDeclarationApiBillingServiceImpl.ApiFlowUpdateWrapper apiFlowUpdateWrapper =
//                new TaxDeclarationApiBillingServiceImpl.ApiFlowUpdateWrapper(tenantKey
//                        , employeeId, param.getTaxCycle().atDay(1)
//                        , apiConfig, EnumDeclareApiBusinessType.EMPLOYEE_DECLARATION);
//        // 查询申报的人员列表
//        LocalDateTime now = LocalDateTime.now();
//        List<EmployeeDeclarePO> needUpdateEmployeeDeclares = Lists.newArrayList();
//        List<EmployeeDeclarePO> employeeDeclares = listByTaxCycleAndTaxAgentId(param.getTaxCycle(), param.getTaxAgentId(), tenantKey);
//        for (EmployeeDeclarePO employeeDeclare : employeeDeclares) {
//            CardTypeEnum cardTypeEnum = SalaryEnumUtil.enumMatchByValue(employeeDeclare.getCardType(), CardTypeEnum.class);
//            String key = employeeDeclare.getEmployeeName()
//                    + "-" + (cardTypeEnum == null ? CardTypeEnum.RESIDENT_IDENTITY_CARDS.getDefaultLabel() : cardTypeEnum.getDefaultLabel())
//                    + "-" + employeeDeclare.getCardNum();
//            Map<String, Object> employeeInfoMap = employeeFeedbackMap.get(key);
//            if (MapUtil.isEmpty(employeeInfoMap)) {
//                continue;
//            }
//            // 报送状态
//            employeeDeclare.setDeclareStatus(SalaryEntityUtil.getIntValue(employeeInfoMap.get("sbzt"), DeclareStatusEnum.NOT_DECLARE.getValue()));
//            // 失败原因
//            employeeDeclare.setDeclareErrorMsg(SalaryEntityUtil.null2String(employeeInfoMap.get("sbyy")));
//            // 验证状态、银行卡验证状态
//            // 是否报送成功了
//            if (Objects.equals(employeeDeclare.getDeclareStatus(), DeclareStatusEnum.DECLARE_SUCCESS.getValue())) {
//                employeeDeclare.setSuccessfullyDeclared(1);
//            }
//            employeeDeclare.setUpdateTime(now);
//            needUpdateEmployeeDeclares.add(employeeDeclare);
//
//            // 流量使用记录
//            TaxDeclarationApiFlowRecordPO flowDetailPO = TaxApiFlowBO.buildTaxDeclarationApiFlowRecordPO(apiFlowUpdateWrapper, param.getTaxAgentId(), employeeDeclare.getEmployeeId());
//            flowDetailPO.setResultStatus(DeclareStatusEnum.DECLARE_SUCCESS.getValue().equals(employeeDeclare.getDeclareStatus()) ? TaxAgentTaxReturnStatusEnum.SUCCESS.getValue() : TaxAgentTaxReturnStatusEnum.FAIL.getValue());
//            apiFlowUpdateWrapper.getApiFlowDetailPOList().add(flowDetailPO);
//        }
//        // 更新员工的报送状态
//        if (CollectionUtils.isNotEmpty(needUpdateEmployeeDeclares)) {
//            updateBatchById(needUpdateEmployeeDeclares);
//        }
//        // 删除原来的人员报送记录
//        employeeDeclareRecordService.deleteByTaxCycleAndTaxAgentId(param.getTaxCycle(), param.getTaxAgentId(), tenantKey);
//        // 记录日志
//        LoggerContext<EmployeeDeclarePO> loggerContext = new LoggerContext<>();
//        loggerContext.setTargetId(param.getTaxAgentId() + "-" + param.getTaxCycle().toString());
//        loggerContext.setTargetName(SalaryI18nUtil.getI18nLabel(tenantKey,employeeId,156468, "个税扣缴义务人:「{0}」税款所属期:「{1}」").replace("{0}", taxAgent.getName()).replace("{1}", param.getTaxCycle().toString()));
//        loggerContext.setOperator(Util.null2String(employeeId));
//        loggerContext.setOperateType(OperateTypeEnum.UPDATE.getValue());
//        loggerContext.setOperateTypeName(SalaryI18nUtil.getI18nLabel(tenantKey,employeeId,156452, "获取结果反馈"));
//        loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(tenantKey,employeeId,156452, "获取结果反馈"));
//        employeeDeclareLoggerTemplate.write(loggerContext);
//        // 更新流量统计
//        taxDeclarationApiBillingService.updateApiFlowInfo(apiFlowUpdateWrapper);
//        // 报送失败的
//        int declareFailSize = (int) needUpdateEmployeeDeclares.stream()
//                .filter(e -> Objects.equals(e.getDeclareStatus(), DeclareStatusEnum.DECLARE_FAIL.getValue()))
//                .count();
//        employeeDeclareRate.setFinish(true);
//        if (declareFailSize > 0) {
//            employeeDeclareRate.setMsg(SalaryI18nUtil.getI18nLabel(tenantKey,employeeId,156472, "报送成功{0}条，报送失败{1}条")
//                    .replace("{0}", Util.null2String(needUpdateEmployeeDeclares.size() - declareFailSize))
//                    .replace("{1}", Util.null2String(declareFailSize)));
//        } else {
//            employeeDeclareRate.setMsg(SalaryI18nUtil.getI18nLabel(tenantKey,employeeId,187388, "报送成功{0}条").replace("{0}", Util.null2String(needUpdateEmployeeDeclares.size())));
//        }
//    }
}