package com.engine.salary.service.impl;

import com.engine.common.util.ServiceUtil;
import com.engine.core.impl.Service;
import com.engine.salary.constant.SalaryDefaultTenantConstant;
import com.engine.salary.entity.datacollection.DataCollectionEmployee;
import com.engine.salary.entity.employeedeclare.bo.EmployeeDeclareBO;
import com.engine.salary.entity.employeedeclare.dto.EmployeeDeclareExcelDTO;
import com.engine.salary.entity.employeedeclare.dto.EmployeeDeclareListDTO;
import com.engine.salary.entity.employeedeclare.param.EmployeeDeclareImportParam;
import com.engine.salary.entity.employeedeclare.param.EmployeeDeclareListQueryParam;
import com.engine.salary.entity.employeedeclare.po.EmployeeDeclarePO;
import com.engine.salary.entity.taxagent.po.TaxAgentPO;
import com.engine.salary.enums.SalaryOnOffEnum;
import com.engine.salary.enums.datacollection.UseEmployeeTypeEnum;
import com.engine.salary.enums.employeedeclare.CardTypeEnum;
import com.engine.salary.enums.employeedeclare.DeclareStatusEnum;
import com.engine.salary.enums.employeedeclare.EmploymentStatusEnum;
import com.engine.salary.enums.employeedeclare.EmploymentTypeEnum;
import com.engine.salary.enums.salaryaccounting.EmployeeTypeEnum;
import com.engine.salary.enums.sicategory.DeleteTypeEnum;
import com.engine.salary.exception.SalaryRunTimeException;
import com.engine.salary.mapper.employeedeclare.EmployeeDeclareMapper;
import com.engine.salary.service.EmployeeDeclareExcelService;
import com.engine.salary.service.EmployeeDeclareService;
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.SalaryEnumUtil;
import com.engine.salary.util.SalaryI18nUtil;
import com.engine.salary.util.db.MapperProxyFactory;
import com.engine.salary.util.excel.*;
import com.engine.salary.util.valid.SalaryCardUtil;
import com.google.common.base.Joiner;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import dm.jdbc.util.IdGenerator;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.util.IOUtils;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.BeanWrapperImpl;
import weaver.file.ExcelSheet;
import weaver.file.ImageFileManager;
import weaver.general.Util;
import weaver.hrm.User;

import java.beans.PropertyDescriptor;
import java.io.InputStream;
import java.time.LocalDate;
import java.util.*;
import java.util.stream.Collectors;

import static com.engine.salary.util.excel.ExcelSupport.EXCEL_TYPE_XLSX;

/**
 * 人员报送（人员）导入导出
 * <p>Copyright: Copyright (c) 2023</p>
 * <p>Company: 泛微软件</p>
 *
 * @author qiantao
 * @version 1.0
 **/
@Slf4j
public class EmployeeDeclareExcelServiceImpl extends Service implements EmployeeDeclareExcelService {

    private EmployeeDeclareService getEmployeeDeclareService(User user) {
        return ServiceUtil.getService(EmployeeDeclareServiceImpl.class, user);
    }

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

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

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

    @Override
    public XSSFWorkbook exportTemplate(EmployeeDeclareImportParam importParam) {
        // 查询人员
        List<EmployeeDeclarePO> employeeDeclares = Collections.emptyList();
        if (StringUtils.equalsIgnoreCase(importParam.getExportData(), "true")) {
            employeeDeclares = getEmployeeDeclareService(user).listByParam(importParam);
        }
        String yesI18 = SalaryI18nUtil.getI18nLabel(111111, "是");
        String noI18 = SalaryI18nUtil.getI18nLabel(111111, "否");
        List<List<Object>> rows = Lists.newArrayList();
        for (EmployeeDeclarePO employeeDeclare : employeeDeclares) {
            EmploymentStatusEnum employmentStatusEnum = SalaryEnumUtil.enumMatchByValue(employeeDeclare.getEmploymentStatus(), EmploymentStatusEnum.class);
            EmploymentTypeEnum employmentTypeEnum = SalaryEnumUtil.enumMatchByValue(employeeDeclare.getEmploymentType(), EmploymentTypeEnum.class);
            List<Object> row = Lists.newArrayList();
            row.add(employeeDeclare.getJobNum());
            row.add(employeeDeclare.getEmployeeName());
            row.add(CardTypeEnum.RESIDENT_IDENTITY_CARDS.getDefaultLabel());
            row.add(employeeDeclare.getCardNum());
            row.add(employmentStatusEnum == null ? "" : employmentStatusEnum.getDefaultLabel());
            row.add(employmentTypeEnum == null ? "" : employmentTypeEnum.getDefaultLabel());
            row.add(employeeDeclare.getEmploymentFirstYear());
            row.add(employeeDeclare.getMobile());
            row.add(SalaryDateUtil.getFormatDate(employeeDeclare.getEmploymentDate()));
            row.add(SalaryDateUtil.getFormatDate(employeeDeclare.getDismissDate()));
            row.add(Objects.equals(employeeDeclare.getDisability(), 1) ? yesI18 : noI18);
            row.add(employeeDeclare.getDisabilityCardNo());
            row.add(Objects.equals(employeeDeclare.getMartyrDependents(), 1) ? yesI18 : noI18);
            row.add(employeeDeclare.getMartyrDependentsCardNo());
            row.add(Objects.equals(employeeDeclare.getLonelyOld(), 1) ? yesI18 : noI18);
            row.add(Objects.equals(employeeDeclare.getDeductExpenses(), 1) ? yesI18 : noI18);
            rows.add(row);
        }
        // 组装excel导出数据
        ExcelSheetData excelSheetData = new ExcelSheetData();
        excelSheetData.setSheetName(SalaryI18nUtil.getI18nLabel(111111, "人员信息采集"));
        excelSheetData.setHeaders(getImportHeader());
        excelSheetData.setRows(rows);
        return ExcelUtil.genWorkbook(excelSheetData);
    }

    @Override
    public Map<String, Object> preview(EmployeeDeclareImportParam param) {
        //1、参数校验
        String imageId = param.getImageId();
        if (StringUtils.isBlank(imageId)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(0, "文件id为空"));
        }
        Map<String, Object> map = new HashMap<>();

        InputStream fileInputStream = null;
        try {

            fileInputStream = ImageFileManager.getInputStreamById(Integer.parseInt(param.getImageId()));

            Sheet sheet = ExcelSupport.parseFile(fileInputStream, 0, EXCEL_TYPE_XLSX);
            List<String> headers = ExcelSupport.getSheetHeader(sheet, 0);

            map.put("headers", headers);
            map.put("list", ExcelParseHelper.parse2List(sheet, 1));

            return map;

        } finally {
            IOUtils.closeQuietly(fileInputStream);
        }
    }

    @Override
    public Map<String, Object> importData(EmployeeDeclareImportParam param) {
        Map<String, Object> apidatas = new HashMap<>();
        InputStream fileInputStream = null;
        try {
            Date now = new Date();
            // 个税扣缴义务人id
            Long taxAgentId = param.getTaxAgentId();
            TaxAgentPO taxAgent = getTaxAgentService(user).getById(taxAgentId);
            if (taxAgent == null) {
                throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(0, "参数错误，无法找到个税扣缴义务人"));
            }
            // 税款所属期
            String taxCycle = SalaryDateUtil.getFormatDate(param.getTaxCycle());
            Date taxCycleDate = param.getTaxCycle();

            // 导出模板中的表头
            List<String> headerList = getImportHeader().stream().map(header -> header.toString()).collect(Collectors.toList());
            // 查询所有的人员
            List<DataCollectionEmployee> simpleEmployees = getSalaryEmployeeService(user).listAll(UseEmployeeTypeEnum.ORG);
            // 查询所有的外部人员
            List<DataCollectionEmployee> extEmployees = getSalaryEmployeeService(user).listAll(UseEmployeeTypeEnum.EXT);
            // 查询人员报送表的人员
            List<EmployeeDeclarePO> employeeDeclares = getEmployeeDeclareService(user).listByTaxCycleAndTaxAgentId(SalaryDateUtil.dateStrToLocalDate(taxCycle), taxAgentId);
            // 校验字段
            String checkType = param.getCheckType();
            Map<String, DataCollectionEmployee> extEmployeeMap = Maps.newHashMap();
            Map<String, DataCollectionEmployee> simpleEmployeeMap = Maps.newHashMap();
            Map<String, EmployeeDeclarePO> employeeDeclareMap = Maps.newHashMapWithExpectedSize(employeeDeclares.size());
            if (Objects.equals(checkType, "jobNum")) {
                extEmployeeMap = Collections.emptyMap();
                simpleEmployeeMap = SalaryEntityUtil.convert2Map(simpleEmployees, DataCollectionEmployee::getWorkcode);
                employeeDeclareMap = SalaryEntityUtil.convert2Map(employeeDeclares, EmployeeDeclarePO::getJobNum);
            } else {
                // 查询所有人员的个人信息
                simpleEmployeeMap = SalaryEntityUtil.convert2Map(simpleEmployees, DataCollectionEmployee::getIdNo);
                extEmployeeMap = SalaryEntityUtil.convert2Map(extEmployees, DataCollectionEmployee::getIdNo);
                employeeDeclareMap = SalaryEntityUtil.convert2Map(employeeDeclares, EmployeeDeclarePO::getCardNum);
            }
            // 需要新增的报送人员
            List<EmployeeDeclarePO> needAddEmployeeDeclares = Lists.newArrayList();
            // 需要更新的报送人员
            List<EmployeeDeclarePO> needUpdateEmployeeDeclares = Lists.newArrayList();
            // 索引(用于计算进度)
            int index = 0;
            // 失败的数量
            int failCount = 0;
            // 成功的数量
            int successCount = 0;
            // 错误行的索引
            int failRowIndex = 1;
            // 包含错误提示信息的sheet页
            List<ExcelSheet> errorExcelSheets = Lists.newArrayList();

            String imageId = Util.null2String(param.getImageId());
            fileInputStream = ImageFileManager.getInputStreamById(Integer.parseInt(imageId));
            Sheet sheet = ExcelSupport.parseFile(fileInputStream, 0, EXCEL_TYPE_XLSX);
            // 表头
            List<String> headers = ExcelSupport.getSheetHeader(sheet, 0);
            
            // 检查表头
            String isCorrectHeader = checkHeader(headers, headerList);
            if (isCorrectHeader != null) {
                throw new SalaryRunTimeException(isCorrectHeader);
            }
            // 数据
            List<Map<String, Object>> data = ExcelParseHelper.parse2Map(sheet, 1);
            if (CollectionUtils.isEmpty(data)) {
                throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(0, "导入数据不能为空"));
            }
            // 错误提示信息
            List<ExcelComment> excelComments = Lists.newArrayList();
            List<Map> errorData = new ArrayList<>();
            for (int i = 0; i < data.size(); i++) {
                //行号
                String rowIndex = String.format("第%s行", i + 2);

                Map<String, Object> map = data.get(i);
                // 数据是否存在错误
                boolean isError = false;
                EmployeeDeclareExcelDTO employeeDeclareExcel = new EmployeeDeclareExcelDTO();
                for (String dataKey : headerList) {
                    String dataValue = Util.null2String(map.get(dataKey));
                    if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel( 0, "工号"))) {
                        if (StringUtils.equals(checkType, "jobNum") && StringUtils.isEmpty(dataValue)) {
                            isError = true;
                            Map<String, String> errorMessageMap = Maps.newHashMap();
                            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "工号不能为空"));
                            errorData.add(errorMessageMap);
                        }
                        employeeDeclareExcel.setJobNum(dataValue);
                    } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "姓名"))) {
                        if (StringUtils.isEmpty(dataValue)) {
                            isError = true;
                            Map<String, String> errorMessageMap = Maps.newHashMap();
                            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "姓名不能为空"));
                            errorData.add(errorMessageMap);
                        } else {
                            employeeDeclareExcel.setEmployeeName(dataValue);
                        }
                    } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "证件类型"))) {
                        employeeDeclareExcel.setCardType(CardTypeEnum.RESIDENT_IDENTITY_CARDS.getValue().toString());
                    } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "证件号码"))) {
                        if (StringUtils.isEmpty(dataValue)) {
                            isError = true;
                            Map<String, String> errorMessageMap = Maps.newHashMap();
                            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "证件号码不能为空"));
                            errorData.add(errorMessageMap);
                        } else if (!SalaryCardUtil.checkIdNum(dataValue)) {
                            isError = true;
                            Map<String, String> errorMessageMap = Maps.newHashMap();
                            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "证件号码格式不正确"));
                            errorData.add(errorMessageMap);
                        } else {
                            employeeDeclareExcel.setCardNum(dataValue);
                            employeeDeclareExcel.setGender(SalaryCardUtil.judgeGender(dataValue).getValue().toString());
                            employeeDeclareExcel.setBirthday(SalaryCardUtil.judgeBirthday(dataValue).toString());
                        }
                    } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "人员状态"))) {
                        boolean legalDataValue = false;
                        for (EmploymentStatusEnum employmentStatusEnum : EmploymentStatusEnum.values()) {
                            if (StringUtils.equals(dataValue, employmentStatusEnum.getDefaultLabel())) {
                                legalDataValue = true;
                                employeeDeclareExcel.setEmploymentStatus(employmentStatusEnum.getValue().toString());
                                break;
                            }
                        }
                        if (!legalDataValue) {
                            isError = true;
                            Map<String, String> errorMessageMap = Maps.newHashMap();
                            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "人员状态只能填写正常或非正常"));
                            errorData.add(errorMessageMap);
                        }
                    } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "任职受雇从业类型"))) {
                        boolean legalDataValue = false;
                        for (EmploymentTypeEnum employmentTypeEnum : EmploymentTypeEnum.values()) {
                            if (StringUtils.equals(dataValue, employmentTypeEnum.getDefaultLabel())) {
                                legalDataValue = true;
                                employeeDeclareExcel.setEmploymentType(employmentTypeEnum.getValue().toString());
                                break;
                            }
                        }
                        if (!legalDataValue) {
                            isError = true;
                            Map<String, String> errorMessageMap = Maps.newHashMap();
                            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "任职受雇从业类型填写错误"));
                            errorData.add(errorMessageMap);
                        }
                    } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "入职年度就业情形"))) {
                        employeeDeclareExcel.setEmploymentFirstYear(dataValue);
                    } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "手机号码"))) {
                        if (StringUtils.isEmpty(dataValue)) {
                            isError = true;
                            Map<String, String> errorMessageMap = Maps.newHashMap();
                            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "手机号码不能为空"));
                            errorData.add(errorMessageMap);
                        } else if (!SalaryCardUtil.checkMobile(dataValue)) {
                            isError = true;
                            Map<String, String> errorMessageMap = Maps.newHashMap();
                            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "手机号码格式不正确"));
                            errorData.add(errorMessageMap);
                        } else {
                            employeeDeclareExcel.setMobile(dataValue);
                        }
                    } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "任职受雇从业日期"))) {
                        if (StringUtils.isEmpty(dataValue)) {
                            if (!Objects.equals(employeeDeclareExcel.getEmploymentType(), EmploymentTypeEnum.OTHER.getValue())) {
                                isError = true;
                                Map<String, String> errorMessageMap = Maps.newHashMap();
                                errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "任职受雇从业类型不为「其他」时，任职受雇从业日期为必填"));
                                errorData.add(errorMessageMap);
                            }
                        } else {
                            if (!SalaryDateUtil.checkDay(dataValue)) {
                                isError = true;
                                Map<String, String> errorMessageMap = Maps.newHashMap();
                                errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "日期格式不正确"));
                                errorData.add(errorMessageMap);
                            } else {
                                employeeDeclareExcel.setEmploymentDate(LocalDate.parse(dataValue).toString());
                            }
                        }
                    } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "离职日期"))) {
                        if (StringUtils.isEmpty(dataValue)) {
                            if (Objects.equals(employeeDeclareExcel.getEmploymentStatus(), EmploymentStatusEnum.ABNORMAL.getValue())) {
                                isError = true;
                                Map<String, String> errorMessageMap = Maps.newHashMap();
                                errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "人员状态为非正常时，离职日期必填"));
                                errorData.add(errorMessageMap);
                            }
                        } else {
                            if (!SalaryDateUtil.checkDay(dataValue)) {
                                isError = true;
                                Map<String, String> errorMessageMap = Maps.newHashMap();
                                errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "日期格式不正确"));
                                errorData.add(errorMessageMap);
                            } else {
                                employeeDeclareExcel.setDismissDate(LocalDate.parse(dataValue).toString());
                            }
                        }
                    } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "是否残疾"))) {
                        if (StringUtils.equals(dataValue, SalaryOnOffEnum.ON.getDefaultLabel())) {
                            employeeDeclareExcel.setDisability(SalaryOnOffEnum.ON.getValue());
                        } else if (StringUtils.equals(dataValue, SalaryOnOffEnum.OFF.getDefaultLabel())) {
                            employeeDeclareExcel.setDisability(SalaryOnOffEnum.OFF.getValue());
                        } else {
                            isError = true;
                            Map<String, String> errorMessageMap = Maps.newHashMap();
                            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "是否残疾只能填写是与否"));
                            errorData.add(errorMessageMap);
                        }
                    } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "残疾证号"))) {
                        if (StringUtils.isEmpty(dataValue)) {
                            if (Objects.equals(employeeDeclareExcel.getDisability(), SalaryOnOffEnum.ON.getValue())) {
                                isError = true;
                                Map<String, String> errorMessageMap = Maps.newHashMap();
                                errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "「是否残疾」填「是」时，残疾证号必填"));
                                errorData.add(errorMessageMap);
                            }
                        } else {
                            employeeDeclareExcel.setDisabilityCardNo(dataValue);
                        }
                    } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "是否烈属"))) {
                        if (StringUtils.equals(dataValue, SalaryOnOffEnum.ON.getDefaultLabel())) {
                            employeeDeclareExcel.setMartyrDependents(SalaryOnOffEnum.ON.getValue());
                        } else if (StringUtils.equals(dataValue, SalaryOnOffEnum.OFF.getDefaultLabel())) {
                            employeeDeclareExcel.setMartyrDependents(SalaryOnOffEnum.OFF.getValue());
                        } else {
                            isError = true;
                            Map<String, String> errorMessageMap = Maps.newHashMap();
                            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "是否烈属只能填写是与否"));
                            errorData.add(errorMessageMap);
                        }
                    } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "烈属证号"))) {
                        if (StringUtils.isEmpty(dataValue)) {
                            if (Objects.equals(employeeDeclareExcel.getMartyrDependents(), SalaryOnOffEnum.ON.getValue())) {
                                isError = true;
                                Map<String, String> errorMessageMap = Maps.newHashMap();
                                errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "「是否烈属」填「是」时，烈属证号必填"));
                                errorData.add(errorMessageMap);
                            }
                        } else {
                            employeeDeclareExcel.setMartyrDependentsCardNo(dataValue);
                        }
                    } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "是否孤老"))) {
                        if (StringUtils.equals(dataValue, SalaryOnOffEnum.ON.getDefaultLabel())) {
                            employeeDeclareExcel.setLonelyOld(SalaryOnOffEnum.ON.getValue());
                        } else if (StringUtils.equals(dataValue, SalaryOnOffEnum.OFF.getDefaultLabel())) {
                            employeeDeclareExcel.setLonelyOld(SalaryOnOffEnum.OFF.getValue());
                        } else {
                            isError = true;
                            Map<String, String> errorMessageMap = Maps.newHashMap();
                            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "是否孤老只能填写是与否"));
                            errorData.add(errorMessageMap);
                        }
                    } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "是否扣除减除费用"))) {
                        if (StringUtils.equals(dataValue, SalaryOnOffEnum.ON.getDefaultLabel())) {
                            employeeDeclareExcel.setDeductExpenses(SalaryOnOffEnum.ON.getValue());
                        } else if (StringUtils.equals(dataValue, SalaryOnOffEnum.OFF.getDefaultLabel())) {
                            employeeDeclareExcel.setDeductExpenses(SalaryOnOffEnum.OFF.getValue());
                        } else {
                            isError = true;
                            Map<String, String> errorMessageMap = Maps.newHashMap();
                            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "是否扣除减除费用只能填写是与否"));
                            errorData.add(errorMessageMap);
                        }
                    }
                }
                if (!isError) {
                    if (StringUtils.equals(checkType, "jobNum")) {
                        EmployeeDeclarePO employeeDeclare = employeeDeclareMap.get(employeeDeclareExcel.getJobNum());
                        if (employeeDeclare == null) {
                            DataCollectionEmployee extEmployee = extEmployeeMap.get(employeeDeclareExcel.getJobNum());
                            DataCollectionEmployee simpleEmployee = simpleEmployeeMap.get(employeeDeclareExcel.getJobNum());
                            if (extEmployee == null && simpleEmployee == null) {
                                isError = true;
                                Map<String, String> errorMessageMap = Maps.newHashMap();
                                errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "系统内的人员不存在该工号"));
                                errorData.add(errorMessageMap);
                            } else {
                                needAddEmployeeDeclares.add(buildEmployeeDeclare(extEmployee, simpleEmployee,
                                        employeeDeclareExcel, taxAgentId, taxCycleDate, now));
                            }
                        } else {
                            EmployeeDeclarePO newEmployeeDeclare = new EmployeeDeclarePO();
                            BeanUtils.copyProperties(employeeDeclare, newEmployeeDeclare);
                            BeanUtils.copyProperties(employeeDeclareExcel, newEmployeeDeclare);
                            newEmployeeDeclare.setNewEmployeeInfo(StringUtils.equals(employeeDeclare.toCompareString(), newEmployeeDeclare.toCompareString()) ? 0 : 1);
                            newEmployeeDeclare.setUpdateTime(now);
                            needUpdateEmployeeDeclares.add(newEmployeeDeclare);
                            if (Objects.equals(newEmployeeDeclare.getNewEmployeeInfo(), 1)) {
                                newEmployeeDeclare.setDeclareStatus(DeclareStatusEnum.NOT_DECLARE.getValue());
                                newEmployeeDeclare.setDeclareErrorMsg("");
                            }
                        }
                    } else {
                        EmployeeDeclarePO employeeDeclare = employeeDeclareMap.get(employeeDeclareExcel.getCardNum());
                        if (employeeDeclare == null) {
                            DataCollectionEmployee extEmployee = extEmployeeMap.get(employeeDeclareExcel.getCardNum());
                            DataCollectionEmployee simpleEmployee = simpleEmployeeMap.get(employeeDeclareExcel.getCardNum());
                            if (extEmployee == null && simpleEmployee == null) {
                                isError = true;
                                Map<String, String> errorMessageMap = Maps.newHashMap();
                                errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "系统内的人员不存在该证件号码"));
                                errorData.add(errorMessageMap);
                            } else {
                                needAddEmployeeDeclares.add(buildEmployeeDeclare(extEmployee, simpleEmployee,
                                        employeeDeclareExcel, taxAgentId, taxCycleDate, now));
                            }
                        } else {
                            EmployeeDeclarePO newEmployeeDeclare = new EmployeeDeclarePO();
                            BeanUtils.copyProperties(employeeDeclare, newEmployeeDeclare);
                            EmployeeDeclarePO employeeDeclarePO = EmployeeDeclareBO.convert2PO(employeeDeclareExcel);
                            BeanUtils.copyProperties(employeeDeclarePO, newEmployeeDeclare, getNullPropertyNames(employeeDeclarePO));
                            newEmployeeDeclare.setNewEmployeeInfo(StringUtils.equals(employeeDeclare.toCompareString(), newEmployeeDeclare.toCompareString()) ? 0 : 1);
                            newEmployeeDeclare.setUpdateTime(now);
                            if (Objects.equals(newEmployeeDeclare.getNewEmployeeInfo(), 1)) {
                                newEmployeeDeclare.setDeclareStatus(DeclareStatusEnum.NOT_DECLARE.getValue());
                                newEmployeeDeclare.setDeclareErrorMsg("");
                            }
                            needUpdateEmployeeDeclares.add(newEmployeeDeclare);
                        }
                    }
                }
                if (isError) {
                    failCount++;
                    failRowIndex++;
                    errorData.add(map);
                    continue;
                }
                successCount++;
            }

            if (CollectionUtils.isNotEmpty(needAddEmployeeDeclares)) {
                getEmployeeDeclareService(user).batchInsert(needAddEmployeeDeclares);
            }
            if (CollectionUtils.isNotEmpty(needUpdateEmployeeDeclares)) {
                needUpdateEmployeeDeclares.stream().forEach(getEmployeeDeclareMapper()::update);
            }

            apidatas.put("successCount", successCount);
            apidatas.put("errorCount", failCount);
            apidatas.put("errorNotice", errorData);
            // 发送导入回调信息
//            salaryBatchService.sendImportCallBackInfo(message, successCount, errorCount, errorExcelSheets);

        } catch (Exception e) {
            log.error("人员报送信息导入失败：{}", e.getMessage(), e);
        } finally {
            IOUtils.closeQuietly(fileInputStream);
        }
        return apidatas;
    }


    public static String[] getNullPropertyNames (Object source) {
        final BeanWrapper src = new BeanWrapperImpl(source);
        PropertyDescriptor[] pds = src.getPropertyDescriptors();

        Set<String> emptyNames = new HashSet<>();
        for(PropertyDescriptor pd : pds) {
            Object srcValue = src.getPropertyValue(pd.getName());
            // 此处判断可根据需求修改
            if (srcValue == null) {
                emptyNames.add(pd.getName());
            }
        }
        String[] result = new String[emptyNames.size()];
        return emptyNames.toArray(result);
    }



    private EmployeeDeclarePO buildEmployeeDeclare(DataCollectionEmployee extEmployee, DataCollectionEmployee simpleEmployee,
                                                   EmployeeDeclareExcelDTO employeeDeclareExcel, Long taxAgentId,
                                                   Date taxCycle, Date now) {
        EmployeeDeclarePO employeeDeclare = EmployeeDeclarePO.builder()
                .id(IdGenerator.generate())
                .taxAgentId(taxAgentId)
                .taxCycle(taxCycle)
                .tenantKey(SalaryDefaultTenantConstant.DEFAULT_TENANT_KEY)
                .creator(Long.valueOf(user.getUID()))
                .deleteType(DeleteTypeEnum.NOT_DELETED.getValue())
                .createTime(now)
                .updateTime(now).build();
        EmployeeDeclarePO employeeDeclarePO = EmployeeDeclareBO.convert2PO(employeeDeclareExcel);

        BeanUtils.copyProperties(employeeDeclarePO, employeeDeclare, getNullPropertyNames(employeeDeclarePO));
        if (extEmployee != null) {
            employeeDeclare.setEmployeeId(extEmployee.getEmployeeId());
            employeeDeclare.setEmployeeType(EmployeeTypeEnum.EXT_EMPLOYEE.getValue());
        }
        if (simpleEmployee != null) {
            employeeDeclare.setEmployeeId(simpleEmployee.getEmployeeId());
            employeeDeclare.setEmployeeType(EmployeeTypeEnum.ORGANIZATION.getValue());
        }
        return employeeDeclare;
    }

    @Override
    public XSSFWorkbook export(EmployeeDeclareListQueryParam queryParam) {
        // 查询需要报送的人员
        List<EmployeeDeclarePO> employeeDeclares = getEmployeeDeclareService(user).listByParam(queryParam);
        // 转换成dto
        List<EmployeeDeclareListDTO> dtoList = getEmployeeDeclareService(user).convert(employeeDeclares);
        // 需要导出的数据
        List<List<Object>> excelSheetData = ExcelUtil.getExcelSheetData(EmployeeDeclareListDTO.class, dtoList);

        return ExcelUtil.genWorkbookV2(excelSheetData, "人员信息采集");
    }

//    @Override
//    public XSSFWorkbook export4Add(EmployeeDeclareAddListQueryParam queryParam) {
//        String tenantKey = simpleEmployee.getTenantKey();
//        Long currentEmployeeId = simpleEmployee.getEmployeeId();
//        // 查询需要报送的人员
//        List<EmployeeDeclarePO> employeeDeclares = getEmployeeDeclareService(user).list4AddByParam(queryParam);
//        // 转换成dto
//        List<EmployeeDeclareListDTO> dtoList = getEmployeeDeclareService(user).convert(employeeDeclares);
//        // 需要导出的数据
//        ExcelSheetData excelSheetData = getExcelSheetData(EmployeeDeclareListDTO.class, dtoList);
//        CustomExportUtil.customColumnsBuild(false, queryParam.getCustomColumns(), excelSheetData);
//        ExportExcelInfo exportExcelInfo = ExportExcelInfo.builder()
//                .fileName(SalaryI18nUtil.getI18nLabel(156426, "人员信息采集本月新增") + "-" + SalaryDateUtil.getFormatLocalDate(LocalDateTime.now()))
//                .dataType(SalaryI18nUtil.getI18nLabel(156426, "人员信息采集本月新增"))
//                .function(excelExportParam.getFunction())
//                .handlerName("exportEmployeeDeclare4Add")
//                .flag(true)
//                .bizId(excelExportParam.getBiz())
//                .module(excelExportParam.getModule())
//                .userId(simpleEmployee.getEmployeeId())
//                .tenantKey(simpleEmployee.getTenantKey())
//                .operator(simpleEmployee.getUsername())
//                .eteamsId(TenantRpcContext.getEteamsId())
//                .build();
//        return salaryBatchService.simpleExportExcel(exportExcelInfo, Collections.singletonList(excelSheetData));
//    }
//
//    @BatchExportHandler("exportEmployeeDeclare4Add")
//    private void exportEmployeeDeclare4Add() {
//        BatchCallbackMessage message = BatchExportContext.getBatchCallbackMessage();
//        log.info("导出结束：{}", JsonUtil.toJsonString(message));
//    }
//
//    @Override
//    public XSSFWorkbook export4Update(EmployeeDeclareListQueryParam queryParam) {
//        String tenantKey = simpleEmployee.getTenantKey();
//        Long currentEmployeeId = simpleEmployee.getEmployeeId();
//        // 查询需要报送的人员
//        List<EmployeeDeclarePO> employeeDeclares = getEmployeeDeclareService(user).list4UpdateByParam(queryParam);
//        // 转换成dto
//        List<EmployeeDeclareListDTO> dtoList = getEmployeeDeclareService(user).convert(employeeDeclares);
//        // 需要导出的数据
//        ExcelSheetData excelSheetData = getExcelSheetData(EmployeeDeclareListDTO.class, dtoList);
//        CustomExportUtil.customColumnsBuild(false, queryParam.getCustomColumns(), excelSheetData);
//        ExportExcelInfo exportExcelInfo = ExportExcelInfo.builder()
//                .fileName(SalaryI18nUtil.getI18nLabel(156427, "人员信息采集本月信息变动") + "-" + SalaryDateUtil.getFormatLocalDate(LocalDateTime.now()))
//                .dataType(SalaryI18nUtil.getI18nLabel(156427, "人员信息采集本月信息变动"))
//                .function(excelExportParam.getFunction())
//                .handlerName("exportEmployeeDeclare4Update")
//                .flag(true)
//                .bizId(excelExportParam.getBiz())
//                .module(excelExportParam.getModule())
//                .userId(simpleEmployee.getEmployeeId())
//                .tenantKey(simpleEmployee.getTenantKey())
//                .operator(simpleEmployee.getUsername())
//                .eteamsId(TenantRpcContext.getEteamsId())
//                .build();
//        return salaryBatchService.simpleExportExcel(exportExcelInfo, Collections.singletonList(excelSheetData));
//    }
//
//    @BatchExportHandler("exportEmployeeDeclare4Update")
//    private void exportEmployeeDeclare4Update() {
//        BatchCallbackMessage message = BatchExportContext.getBatchCallbackMessage();
//        log.info("导出结束：{}", JsonUtil.toJsonString(message));
//    }
//
//    @Override
//    public XSSFWorkbook export4Fail(EmployeeDeclareFailListQueryParam queryParam) {
//        String tenantKey = simpleEmployee.getTenantKey();
//        Long currentEmployeeId = simpleEmployee.getEmployeeId();
//        // 查询需要报送的人员
//        List<EmployeeDeclarePO> employeeDeclares = getEmployeeDeclareService(user).list4FailByParam(queryParam);
//        // 转换成dto
//        List<EmployeeDeclareFailListDTO> dtos = getEmployeeDeclareService(user).convert2FailListDTO(employeeDeclares);
//        // 需要导出的数据
//        ExcelSheetData excelSheetData = getExcelSheetData(EmployeeDeclareFailListDTO.class, dtos);
//        ExportExcelInfo exportExcelInfo = ExportExcelInfo.builder()
//                .fileName(SalaryI18nUtil.getI18nLabel(156428, "人员信息采集本月报送失败") + "-" + SalaryDateUtil.getFormatLocalDate(LocalDateTime.now()))
//                .dataType(SalaryI18nUtil.getI18nLabel(156428, "人员信息采集本月报送失败"))
//                .function(excelExportParam.getFunction())
//                .handlerName("exportEmployeeDeclare4Fail")
//                .flag(true)
//                .bizId(excelExportParam.getBiz())
//                .module(excelExportParam.getModule())
//                .userId(simpleEmployee.getEmployeeId())
//                .tenantKey(simpleEmployee.getTenantKey())
//                .operator(simpleEmployee.getUsername())
//                .eteamsId(TenantRpcContext.getEteamsId())
//                .build();
//        return salaryBatchService.simpleExportExcel(exportExcelInfo, Collections.singletonList(excelSheetData));
//    }


//    public Map<String, Object> importEmployeeDeclare(EmployeeDeclareImportEmployeeParam param) {
//        try {
//            Date now = new Date();
//            // 个税扣缴义务人id
//            Long taxAgentId = param.getTaxAgentId();
//            TaxAgentPO taxAgent = getTaxAgentService(user).getById(taxAgentId);
//            if (taxAgent == null) {
//                throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(111111, "参数错误，无法找到个税扣缴义务人"));
//            }
//            // 税款所属期
//            Date taxCycle = param.getTaxCycle();
//            if (taxCycle == null) {
//                throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(111111, "参数错误，税款所属期参数格式错误"));
//            }
//
//            InputStream fileInputStream = null;
//            fileInputStream = ImageFileManager.getInputStreamById(Integer.parseInt(param.getImageId()));
//
//            // 导出模板中的表头
//            List<String> headerList = getImportHeader();
//            // 查询所有的人员
//            List<DataCollectionEmployee> simpleEmployees = getSalaryEmployeeService(user).listAll(UseEmployeeTypeEnum.ALL);
//            // 查询人员报送表的人员
//            List<EmployeeDeclarePO> employeeDeclares = getEmployeeDeclareService(user).listByTaxCycleAndTaxAgentId(taxCycle, taxAgentId);
//            // 校验字段
//            String checkType = Util.null2String(paramMap.getOrDefault("checkType", "jobNum"));
//            Map<String, DataCollectionEmployee> simpleEmployeeMap = Maps.newHashMap();
//            Map<String, EmployeeDeclarePO> employeeDeclareMap = Maps.newHashMapWithExpectedSize(employeeDeclares.size());
//            if (Objects.equals(checkType, "jobNum")) {
//                simpleEmployeeMap = SalaryEntityUtil.convert2Map(simpleEmployees, SimpleEmployee::getJobNum);
//                employeeDeclareMap = SalaryEntityUtil.convert2Map(employeeDeclares, EmployeeDeclarePO::getJobNum);
//            } else {
//                // 查询所有人员的个人信息
//                List<EmployeeDeclarePO> simpleUserInfos = getSalaryEmployeeService(user).listByEmployeeIds(orgEmployeeIds);
//                Map<Long, EmployeeDeclarePO> idKeySimpleEmployeeMap = SalaryEntityUtil.convert2Map(simpleEmployees, SimpleEmployee::getId);
//                for (SimpleUserInfo simpleUserInfo : simpleUserInfos) {
//                    if (idKeySimpleEmployeeMap.containsKey(simpleUserInfo.getEmployeeId())) {
//                        simpleEmployeeMap.put(simpleUserInfo.getIdNo(), idKeySimpleEmployeeMap.get(simpleUserInfo.getEmployeeId()));
//                    }
//                }
//                employeeDeclareMap = SalaryEntityUtil.convert2Map(employeeDeclares, EmployeeDeclarePO::getCardNum);
//
//            }
//            // 需要新增的报送人员
//            List<EmployeeDeclarePO> needAddEmployeeDeclares = Lists.newArrayList();
//            // 需要更新的报送人员
//            List<EmployeeDeclarePO> needUpdateEmployeeDeclares = Lists.newArrayList();
//            // 索引(用于计算进度)
//            int index = 0;
//            // 失败的数量
//            int errorCount = 0;
//            // 成功的数量
//            int successCount = 0;
//            // 错误行的索引
//            int failRowIndex = 1;
//            // 错误提示
//            List<Map<String, String>> excelComments = new ArrayList<>();
//            // 错误excel内容
//            List<Map> errorData = new ArrayList<>();
//
//            Sheet sheet = ExcelSupport.parseFile(fileInputStream, 0, EXCEL_TYPE_XLSX);
//            // 表头
//            List<String> headers = ExcelSupport.getSheetHeader(sheet, 0);
//
//            // 检查表头
//            String isValidHeader = checkHeader(headers, headerList);
//            if (StringUtils.isNotBlank(isValidHeader)) {
//                Map<String, Object> apidatas = new HashMap<String, Object>();
//                apidatas.put("successCount", successCount);
//                apidatas.put("errorCount", errorCount);
//
//                Map<String, String> errorMessageMap = Maps.newHashMap();
//                errorMessageMap.put("message", isValidHeader);
//                excelComments.add(errorMessageMap);
//                apidatas.put("errorData", excelComments);
//                return apidatas;
//            }
//
//            // 数据
//            List<EmployeeDeclareExcelDTO> data = ExcelParseHelper.parse2Map(fileInputStream, EmployeeDeclareExcelDTO.class, 0, 1, 14, "1.xlsx");
//            if (CollectionUtils.isEmpty(data)) {
//                Map<String, Object> apidatas = new HashMap<String, Object>();
//                apidatas.put("successCount", successCount);
//                apidatas.put("errorCount", errorCount);
//                return apidatas;
//            }
//
//            for (int i = 0; i < data.size(); i++) {
//                EmployeeDeclareExcelDTO employeeDeclareExcelDTO = data.get(i);
//
//                employeeDeclareExcelDTO.getEmployeeName()
//
//                //筛选导入人员信息可以在人力资源池中匹配到的人员信息
//                List<DataCollectionEmployee> employeeSameIds = getSalaryEmployeeService(user).matchImportEmployee(simpleEmployees, userName, deparmentName, mobile, workcode, null);
//
//                if (StringUtils.isBlank(userName) && "0".equals(confValue)) {
//                    //姓名 不能为空
//                    //错误消息对象
//                    Map<String, String> errorMessageMap = Maps.newHashMap();
//                    errorMessageMap.put("message", rowIndex + "姓名不能为空");
//                    errorData.add(errorMessageMap);
//                    errorSum += 1;
//                } else if (CollectionUtils.isEmpty(employeeSameIds)) {
//                    Map<String, String> errorMessageMap = Maps.newHashMap();
//                    errorMessageMap.put("message", rowIndex + "员工信息不存在");
//                    errorData.add(errorMessageMap);
//                    errorSum += 1;
//                } else if (employeeSameIds.size() > 1) {
//                    //存在离职和在职状态取在职状态
//                    employeeSameIds = employeeSameIds.stream()
//                            .filter(e -> UserStatusEnum.getNormalStatus().contains(e.getStatus()))
//                            .collect(Collectors.toList());
//                    if (employeeSameIds.size() != 1) {
//                        Map<String, String> errorMessageMap = Maps.newHashMap();
//                        errorMessageMap.put("message", rowIndex + "员工信息不存在或者存在多个员工");
//                        errorData.add(errorMessageMap);
//                        errorSum += 1;
//                    } else {
//                        Long employeeId = CollectionUtils.isNotEmpty(employeeSameIds) && employeeSameIds.size() == 1 ? employeeSameIds.get(0).getEmployeeId() : null;
//                        addUpDeduction.setEmployeeId(employeeId);
//                    }
//                } else {
//                    Long employeeId = CollectionUtils.isNotEmpty(employeeSameIds) && employeeSameIds.size() == 1 ? employeeSameIds.get(0).getEmployeeId() : null;
//                    if (employeeId != null && employeeId > 0) {
//                        addUpDeduction.setEmployeeId(employeeId);
//                    } else {
//                        //姓名错误，系统内不存在该姓名
//                        Map<String, String> errorMessageMap = Maps.newHashMap();
//                        errorMessageMap.put("message", rowIndex + "姓名错误，系统内不存在该姓名");
//                        errorData.add(errorMessageMap);
//                        errorSum += 1;
//                    }
//                }
//
//
//                // 数据是否存在错误
//                boolean isError = false;
//                if (StringUtils.equals(employeeDeclareExcelDTO.getJobNum(), SalaryI18nUtil.getI18nLabel(86317, "工号"))) {
//                    if (StringUtils.isEmpty(employeeDeclareExcelDTO.getJobNum()) ) {
//                        isError = true;
//
//                        salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(136250, "工号不能为空"), failRowIndex, failRowIndex, j, j);
//                    }
//                    employeeDeclareExcel.setJobNum(dataValue);
//                } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(85429, "姓名"))) {
//                    if (StringUtils.isEmpty(dataValue)) {
//                        isError = true;
//                        salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(102838, "姓名不能为空"), failRowIndex, failRowIndex, j, j);
//                    } else {
//                        employeeDeclareExcel.setEmployeeName(dataValue);
//                    }
//                } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(105139, "证件类型"))) {
//                    employeeDeclareExcel.setCardType(CardTypeEnum.RESIDENT_IDENTITY_CARDS.getValue());
//                } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(86318, "证件号码"))) {
//                    if (StringUtils.isEmpty(dataValue)) {
//                        isError = true;
//                        salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156386, "证件号码不能为空"), failRowIndex, failRowIndex, j, j);
//                    } else if (!SalaryCardUtil.checkIdNum(dataValue)) {
//                        isError = true;
//                        salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156429, "证件号码格式不正确"), failRowIndex, failRowIndex, j, j);
//                    } else {
//                        employeeDeclareExcel.setCardNum(dataValue);
//                        employeeDeclareExcel.setGender(SalaryCardUtil.judgeGender(dataValue).getValue());
//                        employeeDeclareExcel.setBirthday(SalaryCardUtil.judgeBirthday(dataValue));
//                    }
//                } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(156394, "人员状态"))) {
//                    boolean legalDataValue = false;
//                    for (EmploymentStatusEnum employmentStatusEnum : EmploymentStatusEnum.values()) {
//                        if (StringUtils.equals(dataValue, employmentStatusEnum.getDefaultLabel())) {
//                            legalDataValue = true;
//                            employeeDeclareExcel.setEmploymentStatus(employmentStatusEnum.getValue());
//                            break;
//                        }
//                    }
//                    if (!legalDataValue) {
//                        isError = true;
//                        salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156430, "人员状态只能填写正常或非正常"), failRowIndex, failRowIndex, j, j);
//                    }
//                } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(156396, "任职受雇从业类型"))) {
//                    boolean legalDataValue = false;
//                    for (EmploymentTypeEnum employmentTypeEnum : EmploymentTypeEnum.values()) {
//                        if (StringUtils.equals(dataValue, employmentTypeEnum.getDefaultLabel())) {
//                            legalDataValue = true;
//                            employeeDeclareExcel.setEmploymentType(employmentTypeEnum.getValue());
//                            break;
//                        }
//                    }
//                    if (!legalDataValue) {
//                        isError = true;
//                        salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156431, "任职受雇从业类型填写错误"), failRowIndex, failRowIndex, j, j);
//                    }
//                } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(187374, "入职年度就业情形"))) {
//                    employeeDeclareExcel.setEmploymentFirstYear(dataValue);
//                } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(98621, "手机号码"))) {
//                    if (StringUtils.isEmpty(dataValue)) {
//                        isError = true;
//                        salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(106429, "手机号码不能为空"), failRowIndex, failRowIndex, j, j);
//                    } else if (!SalaryCardUtil.checkMobile(dataValue)) {
//                        isError = true;
//                        salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(160510, "手机号码格式不正确"), failRowIndex, failRowIndex, j, j);
//                    } else {
//                        employeeDeclareExcel.setMobile(dataValue);
//                    }
//                } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(156409, "任职受雇从业日期"))) {
//                    if (StringUtils.isEmpty(dataValue)) {
//                        if (!Objects.equals(employeeDeclareExcel.getEmploymentType(), EmploymentTypeEnum.OTHER.getValue())) {
//                            isError = true;
//                            salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(160511, "任职受雇从业类型不为「其他」时，任职受雇从业日期为必填"), failRowIndex, failRowIndex, j, j);
//                        }
//                    } else {
//                        if (!SalaryDateUtil.checkDay(dataValue)) {
//                            isError = true;
//                            salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156432, "日期格式不正确"), failRowIndex, failRowIndex, j, j);
//                        } else {
//                            employeeDeclareExcel.setEmploymentDate(LocalDate.parse(dataValue));
//                        }
//                    }
//                } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(95228, "离职日期"))) {
//                    if (StringUtils.isEmpty(dataValue)) {
//                        if (Objects.equals(employeeDeclareExcel.getEmploymentStatus(), EmploymentStatusEnum.ABNORMAL.getValue())) {
//                            isError = true;
//                            salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(160512, "人员状态为非正常时，离职日期必填"), failRowIndex, failRowIndex, j, j);
//                        }
//                    } else {
//                        if (!SalaryDateUtil.checkDay(dataValue)) {
//                            isError = true;
//                            salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156432, "日期格式不正确"), failRowIndex, failRowIndex, j, j);
//                        } else {
//                            employeeDeclareExcel.setDismissDate(LocalDate.parse(dataValue));
//                        }
//                    }
//                } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(156399, "是否残疾"))) {
//                    if (StringUtils.equals(dataValue, SalaryOnOffEnum.ON.getDefaultLabel())) {
//                        employeeDeclareExcel.setDisability(SalaryOnOffEnum.ON.getValue());
//                    } else if (StringUtils.equals(dataValue, SalaryOnOffEnum.OFF.getDefaultLabel())) {
//                        employeeDeclareExcel.setDisability(SalaryOnOffEnum.OFF.getValue());
//                    } else {
//                        isError = true;
//                        salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156433, "是否残疾只能填写是与否"), failRowIndex, failRowIndex, j, j);
//                    }
//                } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(156412, "残疾证号"))) {
//                    if (StringUtils.isEmpty(dataValue)) {
//                        if (Objects.equals(employeeDeclareExcel.getDisability(), SalaryOnOffEnum.ON.getValue())) {
//                            isError = true;
//                            salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(160513, "「是否残疾」填「是」时，残疾证号必填"), failRowIndex, failRowIndex, j, j);
//                        }
//                    } else {
//                        employeeDeclareExcel.setDisabilityCardNo(dataValue);
//                    }
//                } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(187385, "是否烈属"))) {
//                    if (StringUtils.equals(dataValue, SalaryOnOffEnum.ON.getDefaultLabel())) {
//                        employeeDeclareExcel.setMartyrDependents(SalaryOnOffEnum.ON.getValue());
//                    } else if (StringUtils.equals(dataValue, SalaryOnOffEnum.OFF.getDefaultLabel())) {
//                        employeeDeclareExcel.setMartyrDependents(SalaryOnOffEnum.OFF.getValue());
//                    } else {
//                        isError = true;
//                        salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156433, "是否烈属只能填写是与否"), failRowIndex, failRowIndex, j, j);
//                    }
//                } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(156413, "烈属证号"))) {
//                    if (StringUtils.isEmpty(dataValue)) {
//                        if (Objects.equals(employeeDeclareExcel.getMartyrDependents(), SalaryOnOffEnum.ON.getValue())) {
//                            isError = true;
//                            salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(160514, "「是否烈属」填「是」时，烈属证号必填"), failRowIndex, failRowIndex, j, j);
//                        }
//                    } else {
//                        employeeDeclareExcel.setMartyrDependentsCardNo(dataValue);
//                    }
//                } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(156400, "是否孤老"))) {
//                    if (StringUtils.equals(dataValue, SalaryOnOffEnum.ON.getDefaultLabel())) {
//                        employeeDeclareExcel.setLonelyOld(SalaryOnOffEnum.ON.getValue());
//                    } else if (StringUtils.equals(dataValue, SalaryOnOffEnum.OFF.getDefaultLabel())) {
//                        employeeDeclareExcel.setLonelyOld(SalaryOnOffEnum.OFF.getValue());
//                    } else {
//                        isError = true;
//                        salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156434, "是否孤老只能填写是与否"), failRowIndex, failRowIndex, j, j);
//                    }
//                } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(156402, "是否扣除减除费用"))) {
//                    if (StringUtils.equals(dataValue, SalaryOnOffEnum.ON.getDefaultLabel())) {
//                        employeeDeclareExcel.setDeductExpenses(SalaryOnOffEnum.ON.getValue());
//                    } else if (StringUtils.equals(dataValue, SalaryOnOffEnum.OFF.getDefaultLabel())) {
//                        employeeDeclareExcel.setDeductExpenses(SalaryOnOffEnum.OFF.getValue());
//                    } else {
//                        isError = true;
//                        salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156435, "是否扣除减除费用只能填写是与否"), failRowIndex, failRowIndex, j, j);
//                    }
//                }
//                if (!isError) {
//                    if (StringUtils.equals(checkType, "jobNum")) {
//                        EmployeeDeclarePO employeeDeclare = employeeDeclareMap.get(employeeDeclareExcel.getJobNum());
//                        if (employeeDeclare == null) {
//                            ExtEmployeePO extEmployee = extEmployeeMap.get(employeeDeclareExcel.getJobNum());
//                            SimpleEmployee simpleEmployee = simpleEmployeeMap.get(employeeDeclareExcel.getJobNum());
//                            if (extEmployee == null && simpleEmployee == null) {
//                                isError = true;
//                                String jobNumI18 = SalaryI18nUtil.getI18nLabel(86317, "工号");
//                                salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156436, "系统内的人员不存在该工号"), failRowIndex, failRowIndex, headers.indexOf(jobNumI18), headers.indexOf(jobNumI18));
//                            } else {
//                                needAddEmployeeDeclares.add(buildEmployeeDeclare(extEmployee, simpleEmployee,
//                                        employeeDeclareExcel, taxAgentId, taxCycle, now, employeeId));
//                            }
//                        } else {
//                            EmployeeDeclarePO newEmployeeDeclare = new EmployeeDeclarePO();
//                            BeanUtils.copyProperties(employeeDeclare, newEmployeeDeclare);
//                            BeanUtils.copyProperties(employeeDeclareExcel, newEmployeeDeclare);
//                            newEmployeeDeclare.setNewEmployeeInfo(StringUtils.equals(employeeDeclare.toCompareString(), newEmployeeDeclare.toCompareString()) ? 0 : 1)
//                                    .setUpdateTime(now);
//                            needUpdateEmployeeDeclares.add(newEmployeeDeclare);
//                            if (Objects.equals(newEmployeeDeclare.getNewEmployeeInfo(), 1)) {
//                                newEmployeeDeclare.setDeclareStatus(DeclareStatusEnum.NOT_DECLARE.getValue());
//                                newEmployeeDeclare.setDeclareErrorMsg("");
//                            }
//                        }
//                    } else {
//                        EmployeeDeclarePO employeeDeclare = employeeDeclareMap.get(employeeDeclareExcel.getCardNum());
//                        if (employeeDeclare == null) {
//                            ExtEmployeePO extEmployee = extEmployeeMap.get(employeeDeclareExcel.getCardNum());
//                            SimpleEmployee simpleEmployee = simpleEmployeeMap.get(employeeDeclareExcel.getCardNum());
//                            if (extEmployee == null && simpleEmployee == null) {
//                                isError = true;
//                                String cardNoI18 = SalaryI18nUtil.getI18nLabel(86318, "证件号码");
//                                salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156437, "系统内的人员不存在该证件号码"), failRowIndex, failRowIndex, headers.indexOf(cardNoI18), headers.indexOf(cardNoI18));
//                            } else {
//                                needAddEmployeeDeclares.add(buildEmployeeDeclare(extEmployee, simpleEmployee,
//                                        employeeDeclareExcel, taxAgentId, taxCycle, now, employeeId));
//                            }
//                        } else {
//                            EmployeeDeclarePO newEmployeeDeclare = new EmployeeDeclarePO();
//                            BeanUtils.copyProperties(employeeDeclare, newEmployeeDeclare);
//                            BeanUtils.copyProperties(employeeDeclareExcel, newEmployeeDeclare);
//                            newEmployeeDeclare.setNewEmployeeInfo(StringUtils.equals(employeeDeclare.toCompareString(), newEmployeeDeclare.toCompareString()) ? 0 : 1)
//                                    .setUpdateTime(now);
//                            if (Objects.equals(newEmployeeDeclare.getNewEmployeeInfo(), 1)) {
//                                newEmployeeDeclare.setDeclareStatus(DeclareStatusEnum.NOT_DECLARE.getValue());
//                                newEmployeeDeclare.setDeclareErrorMsg("");
//                            }
//                            needUpdateEmployeeDeclares.add(newEmployeeDeclare);
//                        }
//                    }
//                }
//                if (isError) {
//                    errorCount++;
//                    failRowIndex++;
//                    errorData.add(map);
//                    continue;
//                }
//                successCount++;
//            }
//            // 如果sheet包含错误数据
//            if (CollectionUtils.isNotEmpty(errorData)) {
//                salaryBatchService.createErrorExcelSheet(excelSheet.getHeader(), errorData, excelSheet.getName(), excelComments, errorExcelSheets);
//            }
//
//            if (CollectionUtils.isNotEmpty(needAddEmployeeDeclares)) {
//                getEmployeeDeclareService(user).saveBatch(needAddEmployeeDeclares);
//            }
//            if (CollectionUtils.isNotEmpty(needUpdateEmployeeDeclares)) {
//                getEmployeeDeclareService(user).updateBatchById(needUpdateEmployeeDeclares);
//            }
//            // 发送导入回调信息
//            salaryBatchService.sendImportCallBackInfo(message, successCount, errorCount, errorExcelSheets);
//        } catch (Exception e) {
//            log.error("人员报送信息导入失败：{}", e.getMessage(), e);
//            salaryBatchService.sendImportCallBackInfo(message, SalaryI18nUtil.getI18nLabel(156438, "人员报送信息导入失败：") + e.getMessage());
//        }
//    }
//
//    private EmployeeDeclarePO buildEmployeeDeclare(ExtEmployeePO extEmployee,
//                                                   EmployeeDeclareExcelDTO employeeDeclareExcel, Long taxAgentId,
//                                                   String taxCycle, LocalDateTime now, Long String tenantKey) {
//        EmployeeDeclarePO employeeDeclare = new EmployeeDeclarePO()
//                .setId(IdGenerator.generate())
//                .setTaxAgentId(taxAgentId)
//                .setTaxCycle(taxCycle)
//                .setTenantKey(tenantKey)
//                .setCreator(employeeId)
//                .setDeleteType(DeleteTypeEnum.NOT_DELETED.getValue())
//                .setCreateTime(now)
//                .setUpdateTime(now);
//        BeanUtils.copyProperties(employeeDeclareExcel, employeeDeclare);
//        if (extEmployee != null) {
//            employeeDeclare.setEmployeeId(extEmployee.getId())
//                    .setEmployeeType(EmployeeTypeEnum.EXT_EMPLOYEE.getValue());
//        }
//        if (simpleEmployee != null) {
//            employeeDeclare.setEmployeeId(simpleEmployee.getEmployeeId())
//                    .setEmployeeType(EmployeeTypeEnum.ORGANIZATION.getValue());
//        }
//        return employeeDeclare;
//    }

    private List<Object> getImportHeader() {
        List<Object> headers = new ArrayList<>();

        headers.add(SalaryI18nUtil.getI18nLabel(111111, "工号"));
        headers.add(SalaryI18nUtil.getI18nLabel(111111, "姓名"));
        headers.add(SalaryI18nUtil.getI18nLabel(111111, "证件类型"));
        headers.add(SalaryI18nUtil.getI18nLabel(111111, "证件号码"));
        headers.add(SalaryI18nUtil.getI18nLabel(111111, "人员状态"));
        headers.add(SalaryI18nUtil.getI18nLabel(111111, "任职受雇从业类型"));
        headers.add(SalaryI18nUtil.getI18nLabel(111111, "入职年度就业情形"));
        headers.add(SalaryI18nUtil.getI18nLabel(111111, "手机号码"));
        headers.add(SalaryI18nUtil.getI18nLabel(111111, "任职受雇从业日期"));
        headers.add(SalaryI18nUtil.getI18nLabel(111111, "离职日期"));
        headers.add(SalaryI18nUtil.getI18nLabel(111111, "是否残疾"));
        headers.add(SalaryI18nUtil.getI18nLabel(111111, "残疾证号"));
        headers.add(SalaryI18nUtil.getI18nLabel(111111, "是否烈属"));
        headers.add(SalaryI18nUtil.getI18nLabel(111111, "烈属证号"));
        headers.add(SalaryI18nUtil.getI18nLabel(111111, "是否孤老"));
        headers.add(SalaryI18nUtil.getI18nLabel(111111, "是否扣除减除费用"));

        return headers;

    }


    /**
     * 检查表头
     *
     * @param headers
     * @return
     */
    private String checkHeader(List<String> headers, List<String> headerList) {
        // 缺少的列
        List<String> lackHeaders = headerList.stream()
                .filter(header -> !headers.contains(header))
                .collect(Collectors.toList());
        if (CollectionUtils.isNotEmpty(lackHeaders)) {
            // 发送导入回调信息
            return SalaryI18nUtil.getI18nLabel(111111, "缺少如下列，请检查：") + Joiner.on(",").join((Iterable<?>) lackHeaders);
        }
        return null;
    }
}