package com.engine.salary.service.impl;

import com.engine.common.util.ServiceUtil;
import com.engine.core.impl.Service;
import com.engine.salary.entity.employeedeclare.dto.EmployeeDeclareListDTO;
import com.engine.salary.entity.employeedeclare.param.EmployeeDeclareListQueryParam;
import com.engine.salary.entity.employeedeclare.po.EmployeeDeclarePO;
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.excel.ExcelUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import weaver.hrm.User;

import java.util.List;

/**
 * @description: 人员报送（人员）导入导出
 * @author: xiajun
 * @modified By: xiajun
 * @date: Created in 9/7/22 5:39 PM
 * @version:v1.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);
    }

//    @Override
//    public Map<String, Object> exportTemplate( EmployeeDeclareImportParam importParam) {
//        String tenantKey = simpleEmployee.getTenantKey();
//        Long currentEmployeeId = simpleEmployee.getEmployeeId();
//        // 查询人员
//        List<EmployeeDeclarePO> employeeDeclares = Collections.emptyList();
//        if (StringUtils.equalsIgnoreCase(importParam.getExportData(), "true")) {
//            employeeDeclares = getEmployeeDeclareService(user).listByParam(importParam);
//        }
//        String yesI18 = SalaryI18nUtil.getI18nLabel( 84967, "是");
//        String noI18 = SalaryI18nUtil.getI18nLabel( 84968, "否");
//        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(Util.null2String(employeeDeclare.getEmploymentDate()));
//            row.add(Util.null2String(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导出数据
//        String[] headers = getImportHeader(currentEmployeeId, tenantKey).toArray(new String[0]);
//        ExcelSheetData excelSheetData = new ExcelSheetData();
//        excelSheetData.setSheetName(SalaryI18nUtil.getI18nLabel( 156425, "人员信息采集"));
//        excelSheetData.setHeaders(Collections.singletonList(headers));
//        excelSheetData.setRows(rows);
//        ExportExcelInfo exportExcelInfo = ExportExcelInfo.builder()
//                .fileName(SalaryI18nUtil.getI18nLabel( 156424, "人员信息采集导入模板") + "-" + SalaryDateUtil.getFormatLocalDate(LocalDateTime.now()))
//                .dataType(SalaryI18nUtil.getI18nLabel( 156424, "人员信息采集导入模板"))
//                .function(excelExportParam.getFunction())
//                .handlerName("exportEmployeeDeclareTemplate")
//                .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("exportEmployeeDeclareTemplate")
//    private void exportEmployeeDeclareTemplate() {
//        BatchCallbackMessage message = BatchExportContext.getBatchCallbackMessage();
//        log.info("导出结束：{}", JsonUtil.toJsonString(message));
//    }

    @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));
//    }


//
//    @Transactional(rollbackFor = Exception.class)
//    @BatchImportHandler("importEmployeeDeclare")
//    public void importEmployeeDeclare() {
//        BatchDocumentMessage message = BatchImportContext.getBatchDocumentMessage();
//        Long employeeId = message.getUserId();
//        String tenantKey = message.getTenantKey();
//        try {
//            LocalDateTime now = LocalDateTime.now();
//            Map<String, Object> paramMap = JsonUtil.parseMap(message.getUploadSet().getCustomData(), Object.class);
//            // 个税扣缴义务人id
//            Long taxAgentId = Util.getLongValue(Util.null2String(paramMap.get("taxAgentId")));
//            TaxAgentPO taxAgent = getTaxAgentService(user).getById(taxAgentId, employeeId, tenantKey);
//            if (taxAgent == null) {
//                salaryBatchService.sendImportCallBackInfo(message, SalaryI18nUtil.getI18nLabel(employeeId, 187469, "参数错误，无法找到个税扣缴义务人"));
//                return;
//            }
//            // 税款所属期
//            String taxCycle = Util.null2String(paramMap.get("taxCycle"));
//            if (!SalaryDateUtil.checkYearMonth(taxCycle)) {
//                salaryBatchService.sendImportCallBackInfo(message, SalaryI18nUtil.getI18nLabel(employeeId, 156384, "参数错误，税款所属期参数格式错误"));
//                return;
//            }
//
//            // 导出模板中的表头
//            List<String> headerList = getImportHeader(employeeId, tenantKey);
//            // 查询所有的人员
//            List<Long> orgEmployeeIds = hrmCommonEmployeeService.getAllEmployee(tenantKey);
//            List<SimpleEmployee> simpleEmployees = hrmCommonEmployeeService.getEmployeeByIds(orgEmployeeIds, tenantKey);
//            // 查询所有的外部人员
//            List<ExtEmployeePO> extEmployees = extEmployeeService.listAll(tenantKey);
//            // 查询人员报送表的人员
//            List<EmployeeDeclarePO> employeeDeclares = getEmployeeDeclareService(user).listByTaxCycleAndTaxAgentId(YearMonth.parse(taxCycle),
//                    taxAgentId, tenantKey);
//            // 校验字段
//            String checkType = Util.null2String(paramMap.getOrDefault("checkType", "jobNum"));
//            Map<String, ExtEmployeePO> extEmployeeMap = Maps.newHashMap();
//            Map<String, SimpleEmployee> simpleEmployeeMap = Maps.newHashMap();
//            Map<String, EmployeeDeclarePO> employeeDeclareMap = Maps.newHashMapWithExpectedSize(employeeDeclares.size());
//            if (Objects.equals(checkType, "jobNum")) {
//                extEmployeeMap = Collections.emptyMap();
//                simpleEmployeeMap = SalaryEntityUtil.convert2Map(simpleEmployees, SimpleEmployee::getJobNum);
//                employeeDeclareMap = SalaryEntityUtil.convert2Map(employeeDeclares, EmployeeDeclarePO::getJobNum);
//            } else {
//                // 查询所有人员的个人信息
//                List<SimpleUserInfo> simpleUserInfos = getSalaryEmployeeService(user).listByEmployeeIds(orgEmployeeIds, tenantKey);
//                Map<Long, SimpleEmployee> idKeySimpleEmployeeMap = SalaryEntityUtil.convert2Map(simpleEmployees, SimpleEmployee::getId);
//                for (SimpleUserInfo simpleUserInfo : simpleUserInfos) {
//                    if (idKeySimpleEmployeeMap.containsKey(simpleUserInfo.getEmployeeId())) {
//                        simpleEmployeeMap.put(simpleUserInfo.getIdNo(), idKeySimpleEmployeeMap.get(simpleUserInfo.getEmployeeId()));
//                    }
//                }
//                extEmployeeMap = SalaryEntityUtil.convert2Map(extEmployees, ExtEmployeePO::getCardNum);
//                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();
//            for (ExcelSheet excelSheet : message.getBatchFile().getExcelSheets()) {
//                if (CollectionUtils.isEmpty(excelSheet.getHeader())) {
//                    continue;
//                }
//                // 表头
//                List<String> headers = excelSheet.getHeader().stream()
//                        .map(m -> Util.null2String(m.get("key")))
//                        .collect(Collectors.toList());
//                // 检查表头
//                boolean isCorrectHeader = checkHeader(message, headers, headerList);
//                if (!isCorrectHeader) {
//                    return;
//                }
//                // 表头每一列的位置
//                Map<String, Integer> columnIndexMap = Maps.newHashMap();
//                for (int i = 0; i < headers.size(); i++) {
//                    columnIndexMap.put(headers.get(i), i);
//                }
//                // 数据
//                List<Map<String, Object>> data = excelSheet.getData();
//                if (CollectionUtils.isEmpty(data)) {
//                    continue;
//                }
//                // 错误提示信息
//                List<ExcelComment> excelComments = Lists.newArrayList();
//                // 存在错误的那行数据
//                List<Map<String, Object>> errorData = Lists.newArrayList();
//                for (int i = 0; i < data.size(); i++) {
//                    Map<String, Object> map = data.get(i);
//                    // 数据是否存在错误
//                    boolean isError = false;
//                    EmployeeDeclareExcelDTO employeeDeclareExcel = new EmployeeDeclareExcelDTO();
//                    for (String dataKey : getImportHeader(employeeId, tenantKey)) {
//                        Integer j = columnIndexMap.get(dataKey);
//                        String dataValue = Util.null2String(map.get(dataKey));
//                        if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 86317, "工号"))) {
//                            if (StringUtils.equals(checkType, "jobNum") && StringUtils.isEmpty(dataValue)) {
//                                isError = true;
//                                salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 136250, "工号不能为空"), failRowIndex, failRowIndex, j, j);
//                            }
//                            employeeDeclareExcel.setJobNum(dataValue);
//                        } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 85429, "姓名"))) {
//                            if (StringUtils.isEmpty(dataValue)) {
//                                isError = true;
//                                salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 102838, "姓名不能为空"), failRowIndex, failRowIndex, j, j);
//                            } else {
//                                employeeDeclareExcel.setEmployeeName(dataValue);
//                            }
//                        } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 105139, "证件类型"))) {
//                            employeeDeclareExcel.setCardType(CardTypeEnum.RESIDENT_IDENTITY_CARDS.getValue());
//                        } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 86318, "证件号码"))) {
//                            if (StringUtils.isEmpty(dataValue)) {
//                                isError = true;
//                                salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 156386, "证件号码不能为空"), failRowIndex, failRowIndex, j, j);
//                            } else if (!SalaryCardUtil.checkIdNum(dataValue)) {
//                                isError = true;
//                                salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 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(employeeId, 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(employeeId, 156430, "人员状态只能填写正常或非正常"), failRowIndex, failRowIndex, j, j);
//                            }
//                        } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 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(employeeId, 156431, "任职受雇从业类型填写错误"), failRowIndex, failRowIndex, j, j);
//                            }
//                        } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 187374, "入职年度就业情形"))) {
//                            employeeDeclareExcel.setEmploymentFirstYear(dataValue);
//                        } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 98621, "手机号码"))) {
//                            if (StringUtils.isEmpty(dataValue)) {
//                                isError = true;
//                                salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 106429, "手机号码不能为空"), failRowIndex, failRowIndex, j, j);
//                            } else if (!SalaryCardUtil.checkMobile(dataValue)) {
//                                isError = true;
//                                salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 160510, "手机号码格式不正确"), failRowIndex, failRowIndex, j, j);
//                            } else {
//                                employeeDeclareExcel.setMobile(dataValue);
//                            }
//                        } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 156409, "任职受雇从业日期"))) {
//                            if (StringUtils.isEmpty(dataValue)) {
//                                if (!Objects.equals(employeeDeclareExcel.getEmploymentType(), EmploymentTypeEnum.OTHER.getValue())) {
//                                    isError = true;
//                                    salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 160511, "任职受雇从业类型不为「其他」时，任职受雇从业日期为必填"), failRowIndex, failRowIndex, j, j);
//                                }
//                            } else {
//                                if (!SalaryDateUtil.checkDay(dataValue)) {
//                                    isError = true;
//                                    salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 156432, "日期格式不正确"), failRowIndex, failRowIndex, j, j);
//                                } else {
//                                    employeeDeclareExcel.setEmploymentDate(LocalDate.parse(dataValue));
//                                }
//                            }
//                        } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 95228, "离职日期"))) {
//                            if (StringUtils.isEmpty(dataValue)) {
//                                if (Objects.equals(employeeDeclareExcel.getEmploymentStatus(), EmploymentStatusEnum.ABNORMAL.getValue())) {
//                                    isError = true;
//                                    salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 160512, "人员状态为非正常时，离职日期必填"), failRowIndex, failRowIndex, j, j);
//                                }
//                            } else {
//                                if (!SalaryDateUtil.checkDay(dataValue)) {
//                                    isError = true;
//                                    salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 156432, "日期格式不正确"), failRowIndex, failRowIndex, j, j);
//                                } else {
//                                    employeeDeclareExcel.setDismissDate(LocalDate.parse(dataValue));
//                                }
//                            }
//                        } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 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(employeeId, 156433, "是否残疾只能填写是与否"), failRowIndex, failRowIndex, j, j);
//                            }
//                        } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 156412, "残疾证号"))) {
//                            if (StringUtils.isEmpty(dataValue)) {
//                                if (Objects.equals(employeeDeclareExcel.getDisability(), SalaryOnOffEnum.ON.getValue())) {
//                                    isError = true;
//                                    salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 160513, "「是否残疾」填「是」时，残疾证号必填"), failRowIndex, failRowIndex, j, j);
//                                }
//                            } else {
//                                employeeDeclareExcel.setDisabilityCardNo(dataValue);
//                            }
//                        } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 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(employeeId, 156433, "是否烈属只能填写是与否"), failRowIndex, failRowIndex, j, j);
//                            }
//                        } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 156413, "烈属证号"))) {
//                            if (StringUtils.isEmpty(dataValue)) {
//                                if (Objects.equals(employeeDeclareExcel.getMartyrDependents(), SalaryOnOffEnum.ON.getValue())) {
//                                    isError = true;
//                                    salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 160514, "「是否烈属」填「是」时，烈属证号必填"), failRowIndex, failRowIndex, j, j);
//                                }
//                            } else {
//                                employeeDeclareExcel.setMartyrDependentsCardNo(dataValue);
//                            }
//                        } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 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(employeeId, 156434, "是否孤老只能填写是与否"), failRowIndex, failRowIndex, j, j);
//                            }
//                        } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 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(employeeId, 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(employeeId, 86317, "工号");
//                                    salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 156436, "系统内的人员不存在该工号"), failRowIndex, failRowIndex, headers.indexOf(jobNumI18), headers.indexOf(jobNumI18));
//                                } else {
//                                    needAddEmployeeDeclares.add(buildEmployeeDeclare(extEmployee, simpleEmployee,
//                                            employeeDeclareExcel, taxAgentId, taxCycle, now, employeeId, tenantKey));
//                                }
//                            } 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(employeeId, 86318, "证件号码");
//                                    salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 156437, "系统内的人员不存在该证件号码"), failRowIndex, failRowIndex, headers.indexOf(cardNoI18), headers.indexOf(cardNoI18));
//                                } else {
//                                    needAddEmployeeDeclares.add(buildEmployeeDeclare(extEmployee, simpleEmployee,
//                                            employeeDeclareExcel, taxAgentId, taxCycle, now, employeeId, tenantKey));
//                                }
//                            } 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) {
//                        failCount++;
//                        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, failCount, errorExcelSheets);
//        } catch (Exception e) {
//            log.error("人员报送信息导入失败：{}", e.getMessage(), e);
//            salaryBatchService.sendImportCallBackInfo(message, SalaryI18nUtil.getI18nLabel(employeeId, 156438, "人员报送信息导入失败：") + e.getMessage());
//        }
//    }
//
//    private EmployeeDeclarePO buildEmployeeDeclare(ExtEmployeePO extEmployee,
//                                                   EmployeeDeclareExcelDTO employeeDeclareExcel, Long taxAgentId,
//                                                   String taxCycle, LocalDateTime now, Long employeeId, 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<String> getImportHeader(Long employeeId, String tenantKey) {
//        return Lists.newArrayList(
//                SalaryI18nUtil.getI18nLabel(employeeId, 86317, "工号"),
//                SalaryI18nUtil.getI18nLabel(employeeId, 85429, "姓名"),
//                SalaryI18nUtil.getI18nLabel(employeeId, 105139, "证件类型"),
//                SalaryI18nUtil.getI18nLabel(employeeId, 86318, "证件号码"),
//                SalaryI18nUtil.getI18nLabel(employeeId, 156394, "人员状态"),
//                SalaryI18nUtil.getI18nLabel(employeeId, 156396, "任职受雇从业类型"),
//                SalaryI18nUtil.getI18nLabel(employeeId, 187374, "入职年度就业情形"),
//                SalaryI18nUtil.getI18nLabel(employeeId, 98621, "手机号码"),
//                SalaryI18nUtil.getI18nLabel(employeeId, 156409, "任职受雇从业日期"),
//                SalaryI18nUtil.getI18nLabel(employeeId, 95228, "离职日期"),
//                SalaryI18nUtil.getI18nLabel(employeeId, 156399, "是否残疾"),
//                SalaryI18nUtil.getI18nLabel(employeeId, 156412, "残疾证号"),
//                SalaryI18nUtil.getI18nLabel(employeeId, 187385, "是否烈属"),
//                SalaryI18nUtil.getI18nLabel(employeeId, 156413, "烈属证号"),
//                SalaryI18nUtil.getI18nLabel(employeeId, 156400, "是否孤老"),
//                SalaryI18nUtil.getI18nLabel(employeeId, 156402, "是否扣除减除费用"));
//    }



//    /**
//     * 检查表头
//     *
//     * @param message
//     * @param headers
//     * @return
//     */
//    private boolean checkHeader(BatchDocumentMessage message, List<String> headers, List<String> headerList) {
//        Long employeeId = message.getUserId();
//        String tenantKey = message.getTenantKey();
//        // 缺少的列
//        List<String> lackHeaders = headerList.stream()
//                .filter(header -> !headers.contains(header))
//                .collect(Collectors.toList());
//        if (CollectionUtils.isNotEmpty(lackHeaders)) {
//            // 发送导入回调信息
//            String errorMsg = SalaryI18nUtil.getI18nLabel(employeeId, 101850, "缺少如下列，请检查：") + Joiner.on(",").join(lackHeaders);
//            salaryBatchService.sendImportCallBackInfo(message, errorMsg);
//            return false;
//        }
//        return true;
//    }
}