package com.engine.salary.service.impl;

import com.engine.common.util.ServiceUtil;
import com.engine.core.impl.Service;
import com.engine.salary.biz.*;
import com.engine.salary.common.LocalDateRange;
import com.engine.salary.constant.SalaryDefaultTenantConstant;
import com.engine.salary.entity.datacollection.dto.*;
import com.engine.salary.entity.datacollection.param.AttendQuoteDataExportTemplateParam;
import com.engine.salary.entity.datacollection.param.AttendQuoteDataQueryParam;
import com.engine.salary.entity.datacollection.param.AttendQuoteDataSyncParam;
import com.engine.salary.entity.datacollection.param.AttendQuoteFieldSettingQueryParam;
import com.engine.salary.entity.datacollection.po.AttendQuoteDataPO;
import com.engine.salary.entity.datacollection.po.AttendQuoteDataValuePO;
import com.engine.salary.entity.datacollection.po.AttendQuoteFieldPO;
import com.engine.salary.entity.datacollection.po.AttendQuotePO;
import com.engine.salary.entity.salarysob.bo.SalarySobRangeBO;
import com.engine.salary.entity.salarysob.dto.SalarySobCycleDTO;
import com.engine.salary.entity.salarysob.param.SalarySobRangeEmpQueryParam;
import com.engine.salary.entity.salarysob.po.SalarySobRangePO;
import com.engine.salary.enums.datacollection.AttendQuoteSourceTypeEnum;
import com.engine.salary.exception.SalaryRunTimeException;
import com.engine.salary.mapper.datacollection.AttendQuoteDataMapper;
import com.engine.salary.mapper.salarysob.SalarySobMapper;
import com.engine.salary.mapper.salarysob.SalarySobRangeMapper;
import com.engine.salary.service.AttendQuoteDataService;
import com.engine.salary.service.AttendQuoteFieldSettingService;
import com.engine.salary.service.SalarySobService;
import com.engine.salary.util.SalaryDateUtil;
import com.engine.salary.util.SalaryI18nUtil;
import com.engine.salary.util.db.MapperProxyFactory;
import com.engine.salary.util.excel.ExcelUtil;
import com.engine.salary.util.page.PageInfo;
import com.engine.salary.util.page.PageUtil;
import dm.jdbc.util.IdGenerator;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import weaver.hrm.User;

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

/**
 * 数据采集-考勤引用数据
 * <p>Copyright: Copyright (c) 2022</p>
 * <p>Company: 泛微软件</p>
 *
 * @author qiantao
 * @version 1.0
 **/
public class AttendQuoteDataServiceImpl extends Service implements AttendQuoteDataService {

    private AttendQuoteBiz quoteBiz = new AttendQuoteBiz();
    private AttendQuoteDataBiz dataBiz = new AttendQuoteDataBiz();
    private AttendQuoteDataValueBiz dataValueBiz = new AttendQuoteDataValueBiz();
    private AttendQuoteFieldBiz fieldBiz = new AttendQuoteFieldBiz();
    private EmployBiz employeeBiz = new EmployBiz();

    private AttendQuoteFieldSettingService getFieldSettingService(User user) {
        return (AttendQuoteFieldSettingService) ServiceUtil.getService(AttendQuoteFieldSettingServiceImpl.class, user);
    }
    private SalarySobService getSalarySobService(User user) {
        return (SalarySobService) ServiceUtil.getService(SalarySobServiceImpl.class, user);
    }

    private AttendQuoteDataMapper getAttendQuoteDataMapper() {
        return MapperProxyFactory.getProxy(AttendQuoteDataMapper.class);
    }
    
    private SalarySobMapper getSalarySobMapper() {
        return MapperProxyFactory.getProxy(SalarySobMapper.class);
    }
    private SalarySobRangeMapper getSalarySobRangeMapper() {
        return MapperProxyFactory.getProxy(SalarySobRangeMapper.class);
    }
    
    
//    private HrmCommonEmployeeService employeeService;

//    private AttendQuoteFieldSettingService attendQuoteFieldSettingService;
//    private RemoteAttend4SalaryService remoteAttend4SalaryService;
//    private ExecutorService taskExecutor;
//    private LoggerTemplate attendQuoteLoggerTemplate;
//

    @Override
    public PageInfo<AttendQuoteDataBaseDTO> listPage(AttendQuoteDataQueryParam queryParam) {
        PageUtil.start(queryParam.getCurrent(), queryParam.getPageSize());
        List<AttendQuoteDataBaseDTO> list = getAttendQuoteDataMapper().list(queryParam);
        PageInfo<AttendQuoteDataBaseDTO> page = new PageInfo<AttendQuoteDataBaseDTO>(list);
        return page;
    }

    /**
     * 获取所有考勤字段
     *
     * @return
     */
    private List<AttendQuoteFieldPO> getAllAttendQuoteFields() {
        return fieldBiz.listSome(AttendQuoteFieldPO.builder().build());
    }

    /**
     * 获取考勤数据结果
     *
     * @param attendQuoteDataBases
     * @return
     */
    public List<Map<String, Object>> getListMaps(List<AttendQuoteDataBaseDTO> attendQuoteDataBases) {
        if (CollectionUtils.isEmpty(attendQuoteDataBases)) {
            return new ArrayList<>();
        }

        // 考核数据值
        List<AttendQuoteDataValuePO> attendQuoteDataValues = dataValueBiz.listSome(AttendQuoteDataValuePO.builder().attendQuoteId(attendQuoteDataBases.get(0).getAttendQuoteId()).build());

        return attendQuoteDataBases.stream().map(m -> {
            Map<String, Object> map = new LinkedHashMap<>();
            map.put("id", m.getId());
            map.put("username", m.getUsername());
            map.put("departmentName", m.getDepartmentName());
            map.put("mobile", m.getMobile());
            map.put("jobNum", m.getJobNum());
            // 考勤数据
            attendQuoteDataValues.stream().filter(a -> a.getAttendQuoteDataId().equals(m.getId())).collect(Collectors.toList()).forEach(e -> {
                map.put(e.getAttendQuoteFieldId() + "_attendQuoteData", e.getDataValue());
            });
            return map;
        }).collect(Collectors.toList());
    }


    @Override
    public List<AttendQuoteDataDTO> getAttendQuoteData(YearMonth salaryYearMonth, Long salarySobId, List<Long> employeeIds) {
        if (salaryYearMonth == null || salarySobId == null) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100358, "参数有误：薪资所属月、薪资账套id"));
        }
        List<AttendQuoteDataDTO> list = new ArrayList<>();
        Date salaryYearMonthDay = SalaryDateUtil.localDateToDate(salaryYearMonth.atDay(1));
        //查询引用主表
        List<AttendQuotePO> attendQuotes = quoteBiz.listSome(AttendQuotePO.builder().salaryYearMonth(salaryYearMonthDay).salarySobId(salarySobId).build());

        if (CollectionUtils.isEmpty(attendQuotes)) {
            return Collections.emptyList();
        }
        AttendQuotePO attendQuote = attendQuotes.get(0);

        //查询考勤数据值
        List<AttendQuoteDataValuePO> attendQuoteDataValues = dataValueBiz.listSome(AttendQuoteDataValuePO.builder().attendQuoteId(attendQuote.getId()).employeeIds(employeeIds).build());


        if (CollectionUtils.isEmpty(employeeIds)) {
            employeeIds = attendQuoteDataValues.stream().map(AttendQuoteDataValuePO::getEmployeeId)
                    .distinct().collect(Collectors.toList());
        }

        employeeIds.forEach(e -> {
            AttendQuoteDataDTO attendQuoteData = new AttendQuoteDataDTO();
            attendQuoteData.setEmployeeId(e);
            List<AttendQuoteDataValueDTO> dataValues = attendQuoteDataValues.stream().filter(v -> v.getEmployeeId().equals(e)).map(m ->
                    AttendQuoteDataValueDTO.builder()
                            .attendQuoteFieldId(m.getAttendQuoteFieldId())
                            .dataValue(m.getDataValue())
                            .build()).collect(Collectors.toList());
            attendQuoteData.setDataValues(dataValues);
            list.add(attendQuoteData);
        });
        return list;
    }

    @Override
    public XSSFWorkbook export(AttendQuoteDataQueryParam queryParam) {
        if (queryParam.getAttendQuoteId() == null) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100253, "考勤引用id不能为空"));
        }

        // 考勤数据分页主数据
        List<AttendQuoteDataBaseDTO> attendQuoteDataBases = dataBiz.list(queryParam);
        // 所有考勤字段
        List<AttendQuoteFieldPO> attendQuoteFields = getAllAttendQuoteFields();
        // 获取最终结果
        List<Map<String, Object>> listMaps = getListMaps(attendQuoteDataBases);

        // 1.工作簿名称
        String sheetName = SalaryI18nUtil.getI18nLabel(93931, "考勤数据");
        List<Object> header = new ArrayList<>();
        header.add(SalaryI18nUtil.getI18nLabel(85429, "姓名"));
        header.add(SalaryI18nUtil.getI18nLabel(86185, "部门"));
        header.add(SalaryI18nUtil.getI18nLabel(86186, "手机号"));
        header.add(SalaryI18nUtil.getI18nLabel(86317, "工号"));
        // 动态列
        if (CollectionUtils.isNotEmpty(listMaps)) {
            Map<String, Object> mapColumn = listMaps.get(0);
            for (AttendQuoteFieldPO attendQuoteField : attendQuoteFields) {
                if (mapColumn.containsKey(attendQuoteField.getId() + "_attendQuoteData")) {
                    header.add(attendQuoteField.getFieldName());
                }
            }
        }

        List<List<Object>> rows = new ArrayList<>();
        // 2.表头
        rows.add(header);
        // 3.表数据
        for (Map<String, Object> dto : listMaps) {
            List<Object> row = new ArrayList<>();
            row.add(dto.get("username"));
            row.add(dto.get("departmentName"));
            row.add(dto.get("mobile"));
            row.add(dto.get("jobNum"));

            // 动态列
            Map<String, Object> mapColumn = listMaps.get(0);
            for (AttendQuoteFieldPO attendQuoteField : attendQuoteFields) {
                if (mapColumn.containsKey(attendQuoteField.getId() + "_attendQuoteData")) {
                    row.add(dto.get(attendQuoteField.getId().toString() + "_attendQuoteData"));
                }
            }
            rows.add(row);
        }
        return ExcelUtil.genWorkbookV2(rows, sheetName);

    }


    /**
     * 获取表头设置字段
     *
     * @param sourceType
     * @return
     */
    private List<AttendQuoteFieldPO> getAttendQuoteSetFields(AttendQuoteSourceTypeEnum sourceType) {
        List<AttendQuoteFieldPO> allAttendQuoteFields = getAllAttendQuoteFields();
        List<AttendQuoteFieldSettingListDTO> attendQuoteFieldSettingList = getFieldSettingService(user).listNoSync(AttendQuoteFieldSettingQueryParam.builder().sourceType(sourceType).isViewChecked(Boolean.TRUE).build());
        List<AttendQuoteFieldPO> attendQuoteFields = new ArrayList<>();
        attendQuoteFieldSettingList.forEach(s -> {
            List<AttendQuoteFieldSettingFieldListDTO> items = s.getItems();
            if (CollectionUtils.isNotEmpty(items)) {
                items.forEach(i -> {
                    Optional<AttendQuoteFieldPO> optional = allAttendQuoteFields.stream().filter(f -> f.getId().equals(i.getId())).findFirst();
                    optional.ifPresent(attendQuoteFields::add);
                });
            }
        });
        return attendQuoteFields;
    }

    @Override
    public String syncAttendQuoteData(AttendQuoteDataSyncParam syncParam) {
        AttendQuoteDataSyncParam.checkParam(syncParam);

        String salaryYearMonth = syncParam.getSalaryYearMonth();
        int year = Integer.parseInt(salaryYearMonth.split("-")[0]);
        int month = Integer.parseInt(salaryYearMonth.split("-")[1]);
        if (!SalaryDateUtil.checkYearMonth(salaryYearMonth)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100365, "薪资所属月格式有误，正确格式示例为'2021-01'"));
        }
        // 1.获取已设置的可同步的考勤字段
        List<AttendQuoteFieldPO> attendQuoteFields = getAttendQuoteSetFields(AttendQuoteSourceTypeEnum.QUOTE);
        if (CollectionUtils.isEmpty(attendQuoteFields)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100366, "请先设置同步字段"));
        }
        // 获取薪资账套
        SalarySobCycleDTO salarySobCycle = getSalarySobService(user).getSalarySobCycle(syncParam.getSalarySobId(), YearMonth.of(year, month));
        // 2.薪资账套人员
        List<Long> employeeIds = new ArrayList<>();
        // 获取薪资账套人员
        List<SalarySobRangePO> salarySobRanges = getSalarySobRangeMapper().listSome(SalarySobRangePO.builder().includeType(1).salarySobId(salarySobCycle.getSalarySobId()).build());
        List<SalarySobRangeEmpQueryParam> salarySobRangeEmpQueryParams = SalarySobRangeBO.convert2EmployeeQueryParam(salarySobRanges);
        List<Long> employeeSalarySobIds = getSalarySobRangeMapper().listEmployeeIds(salarySobRangeEmpQueryParams);
        if (CollectionUtils.isEmpty(employeeSalarySobIds) || CollectionUtils.isEmpty(salarySobRangeEmpQueryParams)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100367, "薪资账套还没有人员"));
        }
        // 账套外人员
        List<Long> employeeOtherIds = (List<Long>) syncParam.getEmployeeIds();
        employeeIds.addAll(employeeSalarySobIds);
        employeeIds.addAll(CollectionUtils.emptyIfNull(employeeOtherIds));
        // 3.考勤引用
        AttendQuotePO attendQuote = getAttendQuote(AttendQuoteSourceTypeEnum.QUOTE, syncParam.getSalarySobId(), year, month, syncParam.getDescription());

        // 4.获取考勤模块数据
        List<Map<String, Object>> attendQuoteSyncData = getAttendQuoteDataFromRemoteAttend(salarySobCycle.getAttendCycle(), employeeIds, attendQuoteFields);
        List<AttendQuoteDataPO> pos = new ArrayList<>();
        List<AttendQuoteDataValuePO> values = new ArrayList<>();
        // 5.考勤引用数据处理
        Date now = new Date();
        if (CollectionUtils.isNotEmpty(attendQuoteSyncData)) {
            for (Long employeeId : employeeIds) {
                AttendQuoteDataPO po = new AttendQuoteDataPO();
                po.setId(IdGenerator.generate());
                po.setCreateTime(now);
                po.setUpdateTime(now);
                po.setCreator((long) user.getUID());
                po.setTenantKey(SalaryDefaultTenantConstant.DEFAULT_TENANT_KEY);
                // 考勤引用表的主键id
                po.setAttendQuoteId(attendQuote.getId());
                po.setEmployeeId(employeeId);
                pos.add(po);
                for (Map<String, Object> attendQuoteData : attendQuoteSyncData) {
                    if (attendQuoteData.get("employeeId").toString().equals(employeeId.toString())) {
                        values.add(AttendQuoteDataValuePO.builder()
//                                .id(IdGenerator.generate())
                                .createTime(now)
                                .updateTime(now)
                                .creator((long) user.getUID())
                                .tenantKey(SalaryDefaultTenantConstant.DEFAULT_TENANT_KEY)
                                .employeeId(employeeId)
                                .attendQuoteId(attendQuote.getId())
                                .attendQuoteDataId(po.getId())
                                .attendQuoteFieldId(Long.valueOf(attendQuoteData.get("attendQuoteFieldId").toString()))
                                .dataValue(attendQuoteData.get("dataValue") == null ? "" : attendQuoteData.get("dataValue").toString())
                                .build());
                    }
                }
            }
        } else {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100368, "暂无考勤数据可以同步"));
        }
        // 6.数据落库处理
        handleDataToDB(attendQuote.getId(), pos, values);
        // todo 记录日志
//        recordLog(attendQuote, currentEmployeeId, currentTenantKey, null);
        return null;
    }

    /**
     * 获取考勤引用
     *
     * @param salarySobId
     * @param year
     * @param month
     * @return
     */
    private AttendQuotePO getAttendQuote(AttendQuoteSourceTypeEnum sourceType, Long salarySobId, int year, int month, String description) {
        SalarySobCycleDTO salarySobCycle = getSalarySobService(user).getSalarySobCycle(salarySobId, YearMonth.of(year, month));

        Date salaryYearMonthDayDate = SalaryDateUtil.localDateToDate(YearMonth.of(year, month).atDay(1));
        List<AttendQuotePO> attendQuotes = quoteBiz.listSome(AttendQuotePO.builder().salarySobId(salarySobId).salaryYearMonth(salaryYearMonthDayDate).build());
        // 考勤引用
        AttendQuotePO attendQuote = new AttendQuotePO();
        if (CollectionUtils.isNotEmpty(attendQuotes)) {
            attendQuote = attendQuotes.get(0);
        }
        attendQuote.setSalarySobId(salarySobCycle.getSalarySobId());
        LocalDateRange salaryCycleRange = salarySobCycle.getSalaryCycle();
        LocalDateRange attendCycleRange = salarySobCycle.getAttendCycle();
        // 考勤周期
        attendQuote.setAttendCycle(attendCycleRange.getFromDate() + " ~ " + attendCycleRange.getEndDate());
        // 薪资周期
        attendQuote.setSalaryCycle(salaryCycleRange.getFromDate() + " ~ " + salaryCycleRange.getEndDate());
        attendQuote.setSalaryYearMonth(salaryYearMonthDayDate);
        // 来源：导入
        attendQuote.setSourceType(sourceType.getValue());
        attendQuote.setDescription(description);
        Date now = new Date();
        attendQuote.setCreateTime(now);
        attendQuote.setUpdateTime(now);
        attendQuote.setCreator((long) user.getUID());
        attendQuote.setTenantKey(SalaryDefaultTenantConstant.DEFAULT_TENANT_KEY);
        // 新增或修改考勤引用
        if (attendQuote.getId() != null) {
            quoteBiz.updateById(attendQuote);
        } else {
            attendQuote.setId(IdGenerator.generate());
            quoteBiz.insert(attendQuote);
        }
        return attendQuote;
    }

    /**
     * 获取考勤模块数据 todo
     *
     * @param attendCycleRange
     * @param employeeIds
     * @param attendQuoteFields
     * @return
     */
    private List<Map<String, Object>> getAttendQuoteDataFromRemoteAttend(LocalDateRange attendCycleRange, List<Long> employeeIds, List<AttendQuoteFieldPO> attendQuoteFields) {
        List<Map<String, Object>> attendQuoteSyncData = new ArrayList<>();
//        Attend4Salary attend4Salary = new Attend4Salary();
//        try {
//            int partSize = 500;
//            List<List<Long>> partition = Lists.partition(employeeIds, partSize);
//            for (List<Long> part : partition) {
//                attend4Salary.setBeginDate(attendCycleRange.getFromDate());
//                attend4Salary.setEndDate(attendCycleRange.getEndDate());
//                attend4Salary.setOnlyEmpIds(part);
//                attend4Salary.setUnit("hour");
//                WeaResult<Map<String, Object>> attendResult = remoteAttend4SalaryService.getWorkTimeSummary(attend4Salary, AttendQuoteDataBO.getCurrentUser4Remote());
//                log.info("考勤数据[按小时]:{}", JSONUtils.toJSONString(attendResult.getData()));
//                AttendQuoteDataBO.buildAttendDataFromRemote("hour", attendResult.getData(), attendQuoteFields, attendQuoteSyncData);
//                attend4Salary.setUnit("day");
//                attendResult = remoteAttend4SalaryService.getWorkTimeSummary(attend4Salary, AttendQuoteDataBO.getCurrentUser4Remote());
//                log.info("考勤数据[按天]:{}", JSONUtils.toJSONString(attendResult.getData()));
//                AttendQuoteDataBO.buildAttendDataFromRemote("day", attendResult.getData(), attendQuoteFields, attendQuoteSyncData);
//            }
//        } catch (Exception e) {
//            log.error("获取考勤数据错误失败:{}", String.format("参数:%s,错误信息:%s", JSONObject.toJSONString(attend4Salary), e.getMessage()));
//            return attendQuoteSyncData;
//        }
        return attendQuoteSyncData;
    }

    /**
     * 引用同步或导入落库处理
     *
     * @param attendQuoteId
     * @param pos
     * @param values
     */
    private void handleDataToDB(Long attendQuoteId, List<AttendQuoteDataPO> pos, List<AttendQuoteDataValuePO> values) {
        // 数据落库处理
        if (CollectionUtils.isEmpty(pos)) {
            return;
        }
        // 多条相同人的则以第一条为准，如果逆序排列（用于重复的则以最后一条为准）Collections.reverse(pos);
        pos = pos.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(f -> f.getEmployeeId()))), ArrayList::new));
        // 删除考勤数据
        ArrayList<Long> quoteIds = new ArrayList<>();
        quoteIds.add(attendQuoteId);
        dataBiz.deleteByAttendQuoteIds(quoteIds);
        // 新增考勤数据
        dataBiz.insertData(pos);
        // 删除考勤值数据
        dataValueBiz.deleteByAttendQuoteDataIds(pos.stream().map(AttendQuoteDataPO::getId).collect(Collectors.toList()));
        // 新增考勤值数据
        if (CollectionUtils.isNotEmpty(values)) {
            dataValueBiz.insertData(values);
        }
    }

    @Override
    public XSSFWorkbook downloadTemplate(AttendQuoteDataExportTemplateParam exportParam) {
        // 考勤主数据
        Date salaryYearMonth = SalaryDateUtil.localDateToDate(exportParam.getSalaryYearMonth().atDay(1));
        List<AttendQuotePO> attendQuotePOS = quoteBiz.listSome(AttendQuotePO.builder()
                .salarySobId(exportParam.getSalarySobId())
                .salaryYearMonth(salaryYearMonth)
                .ids(exportParam.getIds()).build());
        AttendQuotePO po = CollectionUtils.isNotEmpty(attendQuotePOS) ? attendQuotePOS.get(0) : null;
        AttendQuoteDataQueryParam queryParam = AttendQuoteDataQueryParam.builder().attendQuoteId(po == null ? 0L : po.getId()).build();
        List<AttendQuoteDataBaseDTO> attendQuoteDataBases = dataBiz.list(queryParam);

        // 获取已设置的可同步的字段
        List<AttendQuoteFieldPO> attendQuoteFields = getAttendQuoteSetFields(AttendQuoteSourceTypeEnum.IMPORT);
        // 获取最终结果
        List<Map<String, Object>> listMaps = getListMaps(attendQuoteDataBases);

        // 1.工作簿名称
        String sheetName = SalaryI18nUtil.getI18nLabel(101606, "考勤引用导入模板");
        List<Object> header = new ArrayList<>();
        header.add(SalaryI18nUtil.getI18nLabel(85429, "姓名"));
        header.add(SalaryI18nUtil.getI18nLabel(86185, "部门"));
        header.add(SalaryI18nUtil.getI18nLabel(86186, "手机号"));
        header.add(SalaryI18nUtil.getI18nLabel(86317, "工号"));
        // 动态列
        for (AttendQuoteFieldPO attendQuoteField : attendQuoteFields) {
            header.add(attendQuoteField.getFieldName());
        }
//        // 2.表头
//        excelSheetData.setHeaders(Collections.singletonList(header.toArray(new String[]{})));

        List<List<Object>> rows = new ArrayList<>();
        rows.add(header);
        for (Map<String, Object> dto : listMaps) {
            List<Object> row = new ArrayList<>();
            row.add(dto.get("username"));
            row.add(dto.get("departmentName"));
            row.add(dto.get("mobile"));
            row.add(dto.get("jobNum"));

            // 动态列
            Map<String, Object> map = listMaps.get(0);
            for (AttendQuoteFieldPO attendQuoteField : attendQuoteFields) {
                row.add(map.containsKey(attendQuoteField.getId() + "_attendQuoteData") ? dto.get(attendQuoteField.getId() + "_attendQuoteData") : "");
            }
            // 2.表头
            rows.add(row);
        }

        return ExcelUtil.genWorkbookV2(rows, sheetName);

    }
//
//    /**
//     * 导入考核数据
//     */
//    @BatchImportHandler("importAttendQuoteData")
//    public void importAttendQuoteData() {
//        BatchDocumentMessage message = BatchImportContext.getBatchDocumentMessage();
//        log.info("【考勤引用数据】接收到上传的数据：{}", JSONObject.toJSONString(message));
//        // 租户key
//        String tenantKey = message.getTenantKey().toLowerCase();
//        try {
//            // 加密用
//            DSTenantKeyThreadVar.tenantKey.set(tenantKey);
//            // 接收到解析的数据
//            batchImportEbatch(message);
//        } catch (Exception e) {
//            log.error("【考勤引用数据】导入失败：{}", String.format("BatchTaskId=%s,错误信息=%s", message.getBatchTaskId(), e.getMessage()));
//        } finally {
//            // 加密用
//            DSTenantKeyThreadVar.tenantKey.remove();
//        }
//    }
//
//    /**
//     * 导入的数据插入到数据库中
//     * @param message
//     * @throws ParseException
//     */
//    @Transactional(rollbackFor = Exception.class)
//    public void batchImportEbatch(BatchDocumentMessage message) {
//        List<ExcelSheet> excelSheets = message.getBatchFile().getExcelSheets();
//
//        // 租户key
//        String tenantKey = message.getTenantKey().toLowerCase();
//        Long currentEmployeeId = message.getUserId();
//        // 加密用
//        DSTenantKeyThreadVar.tenantKey.set(tenantKey);
//        String paramsData = message.getUploadSet().getCustomData();
//        Map<String, Object> params = JSONObject.parseObject(paramsData, Map.class);
//
//        // 参数校验
//        boolean isValid = checkParams(message, params);
//        if (!isValid) {
//            return;
//        }
//
//        String salaryYearMonth = params.get("salaryYearMonth").toString();
//        int year = Integer.parseInt(salaryYearMonth.split("-")[0]);
//        int month = Integer.parseInt(salaryYearMonth.split("-")[1]);
//
//        // 获取租户下所有的人员
//        List<DataCollectionEmployeePO> employees = attendQuoteMapper.listEmployee(tenantKey);
//        // 获取已设置的可同步的考勤字段
//        List<AttendQuoteFieldPO> attendQuoteFields = getAttendQuoteSetFields(AttendQuoteSourceTypeEnum.IMPORT, currentEmployeeId, tenantKey);
//        // 获取考勤引用
//        AttendQuotePO attendQuote = getAttendQuote(AttendQuoteSourceTypeEnum.IMPORT, Long.valueOf(params.get("salarySobId").toString()), year, month, StringUtils.EMPTY, message.getUserId(), tenantKey);
//
//        int total = 0;
//        for (ExcelSheet excelSheet : excelSheets) {
//            List<Map<String, Object>> data = excelSheet.getData();
//            if (data != null) {
//                total += data.size();
//            }
//        }
//        int index = 0;
//        int successCount = 0;
//        int errorCount = 0;
//        // 错误excel内容
//        List<ExcelSheet> errorExcelSheets = new ArrayList<>();
//        // 待导入数据
//        List<AttendQuoteDataPO> pos = new ArrayList<>();
//        List<AttendQuoteDataValuePO> values = new ArrayList<>();
//        String valI18n = SalaryI18nUtil.getI18nLabel(tenantKey, currentEmployeeId, 100581, "请输入数字");
//        for (ExcelSheet excelSheet : excelSheets) {
//            if (excelSheet.getHeader().size() == 0) {
//                continue;
//            }
//            List<Map> headers = excelSheet.getHeader();
//            boolean isValidHeader = checkHeaders(message, headers, attendQuoteFields);
//            if (!isValidHeader) {
//                return;
//            }
//            // 错误sheet数据
//            List<Map<String,Object>> errorData = new ArrayList<>();
//            // 错误提示
//            List<ExcelComment> excelComments = new ArrayList<>();
//
//            List<Map<String, Object>> data = excelSheet.getData();
//            Map<String, Object> map;
//            if (data == null) {
//                continue;
//            }
//            AttendQuoteDataPO po;
//            for (int i = 0; i < data.size(); i++) {
//                index += 1;
//                map = data.get(i);
//
//                po = new AttendQuoteDataPO();
//                po.setId(IdGenerator.generate());
//                po.setCreateTime(LocalDateTime.now());
//                po.setUpdateTime(LocalDateTime.now());
//                po.setCreator(message.getUserId());
//                po.setTenantKey(tenantKey);
//                // 考勤引用表的主键id
//                po.setAttendQuoteId(attendQuote.getId());
//
//                int errorSum = 0;
//
//                String userName = Optional.ofNullable(map.get(SalaryI18nUtil.getI18nLabel(tenantKey, currentEmployeeId, 85429, "姓名"))).orElse("").toString();
//                String deparmentName = Optional.ofNullable(map.get(SalaryI18nUtil.getI18nLabel(tenantKey, currentEmployeeId, 86185, "部门"))).orElse("").toString();
//                List<Long> employeeSameIds = employees.stream().filter(e -> (com.weaver.teams.util.StringUtils.isBlank(userName) || Objects.equals(e.getUsername(), userName))
//                                && (com.weaver.teams.util.StringUtils.isBlank(deparmentName) || Objects.equals(e.getDeparmentName(), deparmentName))).map(DataCollectionEmployeePO::getEmployeeId)
//                        .collect(Collectors.toList());
//
//                for (int j = 0; j < headers.size(); j++) {
//                    Map header = headers.get(j);
//                    Object key = header.get("key");
//                    if (key == null) {
//                        continue;
//                    }
//                    String cellVal = Optional.ofNullable(map.get(key.toString())).orElse("").toString();
//                    if (SalaryI18nUtil.getI18nLabel(tenantKey, currentEmployeeId, 85429, "姓名").equals(key.toString())) {
//                        if (com.weaver.teams.util.StringUtils.isEmpty(cellVal)) {
//                            salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(tenantKey, currentEmployeeId, 100577, "不能为空"), errorCount+1, errorCount+1, j, j);
//                            errorSum += 1;
//                        } else if (CollectionUtils.isEmpty(employeeSameIds) || employeeSameIds.size() > 1) {
//                            salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(tenantKey, currentEmployeeId, 100578, "员工信息不能为空且不可重复(姓名与部门同时确认唯一)"), errorCount+1, errorCount+1, j, j);
//                            errorSum += 1;
//                        } else {
//                            Long employeeId = CollectionUtils.isNotEmpty(employeeSameIds) && employeeSameIds.size() == 1?employeeSameIds.get(0):null;
//                            if (employeeId!=null && employeeId>0) {
//                                po.setEmployeeId(employeeId);
//                            } else {
//                                salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(tenantKey, currentEmployeeId, 100579, "姓名错误，系统内不存在该姓名"), errorCount+1, errorCount+1, j, j);
//                                errorSum += 1;
//                            }
//                        }
//                    }
//                    String bigDecimalValue;
//                    for (AttendQuoteFieldPO attendQuoteField : attendQuoteFields) {
//                        if (attendQuoteField.getFieldName().equals(key.toString())) {
//                            bigDecimalValue = bigDecimalVal(cellVal, excelComments, valI18n, errorCount+1, j);
//                            errorSum += StringUtils.isEmpty(bigDecimalValue)?1:0;
//                            if (StringUtils.isNotEmpty(bigDecimalValue)) {
//                                values.add(AttendQuoteDataValuePO.builder()
//                                        .id(IdGenerator.generate())
//                                        .createTime(LocalDateTime.now())
//                                        .updateTime(LocalDateTime.now())
//                                        .creator(message.getUserId())
//                                        .tenantKey(tenantKey)
//                                        .employeeId(po.getEmployeeId())
//                                        .attendQuoteId(attendQuote.getId())
//                                        .attendQuoteDataId(po.getId())
//                                        .attendQuoteFieldId(attendQuoteField.getId())
//                                        .dataValue(cellVal)
//                                        .build());
//                            }
//                            break;
//                        }
//                    }
//                }
//
//                if (errorSum>0) {
//                    errorCount += 1;
//                    // 添加错误数据
//                    errorData.add(map);
//                } else {
//                    successCount += 1;
//                    // 成功一条就添加一条记录
//                    pos.add(po);
//                }
//                // 导入进度
//                salaryBatchService.sendImportRate(message.getBizId(), total, index);
//            }
//
//            // 如果sheet包含错误数据
//            if (CollectionUtils.isNotEmpty(errorData)) {
//                salaryBatchService.createErrorExcelSheet(headers, errorData, excelSheet.getName(), excelComments, errorExcelSheets);
//            }
//        }
//        // 数据入库处理
//        log.info("【考勤引用数据】导入记录：{}", JsonUtil.toJsonString(pos));
//        handleDataToDB(attendQuote.getId(), pos, values, tenantKey);
//        // 记录日志
//        recordLog(attendQuote, message.getUserId(), message.getTenantKey(), message.getClientIp());
//        // 发送导入回调信息
//        salaryBatchService.sendImportCallBackInfo(message, successCount, errorCount, errorExcelSheets);
//    }
//
//    /**
//     * 获取金额数字值
//     * @param bigDecimalValStr
//     * @param excelComments
//     * @param i
//     * @param j
//     * @return
//     */
//    private String bigDecimalVal(String bigDecimalValStr, List<ExcelComment> excelComments, String valI18n, int i, int j) {
//        BigDecimal bigDecimalVal = null;
//        try {
//            bigDecimalVal = new BigDecimal(bigDecimalValStr);
//        } catch (Exception e) {
//            salaryBatchService.createExcelComment(excelComments, valI18n, i, i, j, j);
//        }
//        return bigDecimalVal == null? "" : bigDecimalVal.toString();
//    }
//
//    /**
//     * 记录日志
//     * @param attendQuote
//     * @param currentEmployeeId
//     * @param currentTenantKey
//     * @param clientIp
//     */
//    private void recordLog(AttendQuotePO attendQuote, Long currentEmployeeId, String currentTenantKey, String clientIp) {
//        List<SalarySobPO> salarySobs = new LambdaQueryChainWrapper<>(getSalarySobMapper())
//                .eq(SalarySobPO::getTenantKey, TenantContext.getCurrentTenantKey())
//                .eq(SalarySobPO::getDeleteType, 0)
//                .eq(SalarySobPO::getId, attendQuote.getSalarySobId())
//                .list();
//        String sourceType = AttendQuoteSourceTypeEnum.getDefaultLabelByValue(attendQuote.getSourceType(), currentEmployeeId, currentTenantKey);
//
//        LoggerContext loggerContext = new LoggerContext();
//        loggerContext.setTargetId(String.valueOf(attendQuote.getId()));
//        loggerContext.setTargetName(SalaryDateUtil.getFormatYearMonth(attendQuote.getSalaryYearMonth())+" "+(CollectionUtils.isNotEmpty(salarySobs)?salarySobs.get(0).getName():""));
//        loggerContext.setOperateType(OperateTypeEnum.ADD.getValue());
//        loggerContext.setOperateTypeName(sourceType+SalaryI18nUtil.getI18nLabel(currentTenantKey, currentEmployeeId, 93931, "考勤数据"));
//        loggerContext.setOperatedesc(sourceType+SalaryI18nUtil.getI18nLabel(currentTenantKey, currentEmployeeId, 93931, "考勤数据"));
//        loggerContext.setNewValues(attendQuote);
//        loggerContext.setTenant_key(currentTenantKey);
//        loggerContext.setOperator(currentEmployeeId.toString());
//        if (StringUtils.isNotEmpty(clientIp)) {
//            loggerContext.setClientIp(clientIp);
//        }
//        attendQuoteLoggerTemplate.write(loggerContext);
//    }
//
//    /**
//     * 检查参数
//     * @param message
//     * @param params
//     * @return
//     */
//    private boolean checkParams(BatchDocumentMessage message, Map<String, Object> params) {
//        boolean isValid = true;
//        String errorMsg = "";
//        if (params == null) {
//            errorMsg = SalaryI18nUtil.getI18nLabel(message.getTenantKey(), message.getUserId(), 100582, "参数必传");
//        } else {
//            if (!params.containsKey("salaryYearMonth")
//                    || !params.containsKey("salarySobId")
//                    || params.get("salaryYearMonth") == null
//                    || params.get("salarySobId") == null) {
//                errorMsg = SalaryI18nUtil.getI18nLabel(message.getTenantKey(), message.getUserId(), 100588, "薪资所属月和薪资账套必传");
//            } else {
//                String salaryYearMonth = params.get("salaryYearMonth").toString();
//                if (!SalaryDateUtil.checkYearMonth(salaryYearMonth)) {
//                    errorMsg = SalaryI18nUtil.getI18nLabel(message.getTenantKey(), message.getUserId(), 100365, "薪资所属月格式有误，正确格式示例为'2021-01'");
//                } else {
//                    List<SalarySobPO> salarySobs = new LambdaQueryChainWrapper<>(getSalarySobMapper())
//                            .eq(SalarySobPO::getTenantKey, message.getTenantKey())
//                            .eq(SalarySobPO::getDeleteType, 0)
//                            .eq(SalarySobPO::getId, Long.valueOf(params.get("salarySobId").toString()))
//                            .list();
//                    if (CollectionUtils.isEmpty(salarySobs)) {
//                        errorMsg = SalaryI18nUtil.getI18nLabel(message.getTenantKey(), message.getUserId(), 100537, "薪资账套不存在");
//                    }
//                }
//            }
//        }
//        // 有错误信息发送
//        if (StringUtils.isNotEmpty(errorMsg)) {
//            // 发送导入回调信息
//            salaryBatchService.sendImportCallBackInfo(message, errorMsg);
//            isValid = false;
//        }
//        return isValid;
//    }
//
//    /**
//     * 检查列头
//     * @param message
//     * @param headers
//     * @param attendQuoteFields
//     * @return
//     */
//    private boolean checkHeaders(BatchDocumentMessage message, List<Map> headers, List<AttendQuoteFieldPO> attendQuoteFields) {
//        boolean isValid = true;
//
//        String tenantKey = message.getTenantKey();
//        Long currentEmployeeId = message.getUserId();
//        String userNameI18n = SalaryI18nUtil.getI18nLabel(tenantKey, currentEmployeeId, 85429, "姓名");
//
//        List<String> headerList = headers.stream().map(m->m.getOrDefault("key", "").toString()).collect(Collectors.toList());
//
//        List<String> mustHeaders = CollectionUtils.emptyIfNull(attendQuoteFields).stream().map(AttendQuoteFieldPO::getFieldName).collect(Collectors.toList());
//        mustHeaders.add(userNameI18n);
//
//        // 缺少的必须列
//        List<String> lackHeaders = mustHeaders.stream().filter(item -> !headerList.contains(item)).collect(Collectors.toList());
//
//        String errorMsg = "";
//        String checkHeaderI18n = SalaryI18nUtil.getI18nLabel(tenantKey, currentEmployeeId, 101850, "缺少如下列，请检查：");
//        if (CollectionUtils.isEmpty(attendQuoteFields)) {
//            errorMsg = SalaryI18nUtil.getI18nLabel(tenantKey, currentEmployeeId, 101849, "考勤字段列缺失，请补充");
//        } else if (CollectionUtils.isNotEmpty(lackHeaders)) {
//            errorMsg = checkHeaderI18n + Joiner.on(",").join(lackHeaders);
//        }
//        // 有错误信息发送
//        if (com.weaver.teams.util.StringUtils.isNotEmpty(errorMsg)) {
//            // 发送导入回调信息
//            salaryBatchService.sendImportCallBackInfo(message, errorMsg);
//            isValid = false;
//        }
//        return isValid;
//    }
}