package cn.estsh.i3plus.ext.mes.apiservice.serviceimpl.excel.jx;

import cn.estsh.i3plus.ext.mes.api.base.IExcelImportExtService;
import cn.estsh.i3plus.ext.mes.apiservice.serviceimpl.base.CommonExtService;
import cn.estsh.i3plus.ext.mes.pojo.bean.MesRepairJudgeType;
import cn.estsh.i3plus.ext.mes.pojo.model.ExcelImportErrorExtModel;
import cn.estsh.i3plus.ext.mes.pojo.model.ExcelImportResultExtModel;
import cn.estsh.i3plus.ext.mes.pojo.repository.MesRepairJudgeTypeRepository;
import cn.estsh.i3plus.ext.mes.pojo.util.MesExtEnumUtil;
import cn.estsh.i3plus.platform.common.convert.ConvertBean;
import cn.estsh.i3plus.platform.common.util.MesConstWords;
import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * @Description : 维修判定类型导入
 * @Reference :
 * @Author : xinwang.yi
 * @CreateDate : 2023-10-23
 * @Modify:
 **/
@Service
public class RepairJudgeTypeExcelService implements IExcelImportExtService {

    @Autowired
    private MesRepairJudgeTypeRepository repairJudgeTypeRepository;

    @Autowired
    private CommonExtService commonExtService;

    /**
     * 维修判定类型配置导入
     *
     * @param workbook
     * @param organizeCode
     * @param userName
     * @return
     */
    @Override
    public ExcelImportResultExtModel insertDataByExcel(Workbook workbook, String organizeCode, String userName) {
        //读取表格
        ExcelImportResultExtModel excelImportResultExtModel = this.sheetExtractMesRepairJudgeType(workbook.getSheetAt(0), organizeCode, userName);
        //数据入库
        this.insertExcelMesRepairJudgeType(excelImportResultExtModel);
        return excelImportResultExtModel;
    }

    /**
     * 维修判定类型配置导入-读取表格
     *
     * @param sheetAt
     * @param organizeCode
     * @param userName
     * @return
     */
    private ExcelImportResultExtModel sheetExtractMesRepairJudgeType(Sheet sheetAt, String organizeCode, String userName) {
        //从0行开始读取
        int totalNumberOfRows = sheetAt.getLastRowNum() + 1;

        //MesRepairJudgeType集合
        List<MesRepairJudgeType> repairJudgeTypeList = new ArrayList<>();

        //成功数量
        Integer successRowNum = 0;
        //失败数量
        Integer failRowNum = 0;
        //错误的行号
        String errorRows = "";

        //错误行信息集合
        List<ExcelImportErrorExtModel> excelImportErrorExtModels = new ArrayList<>();

        //用于EXCEL表中的 维修判定类型 唯一校验
        Map<String, String> repairJudgeTypeByOnlyMap = new HashMap<>();

        //根据维修判定类型 查询替代料中是否存在数据
        List<MesRepairJudgeType> repairJudgeTypeDbList = repairJudgeTypeRepository.findByProperty(
                new String[]{MesConstWords.ORGANIZE_CODE, MesConstWords.IS_DELETED},
                new Object[]{organizeCode, CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()});
        Map<String, MesRepairJudgeType> repairJudgeTypeMapByCode = CollectionUtils.isEmpty(repairJudgeTypeDbList) ? null :
                repairJudgeTypeDbList.stream().filter(o -> null != o).collect(Collectors.toMap(MesRepairJudgeType::getRepairJudgeCode, Function.identity(), (x,y) -> y));

        //从excel表的第5行数据开始导入，getFirstRowNum是从0行开始读取
        for (int i = (sheetAt.getFirstRowNum() + 4); i < totalNumberOfRows; i++) {
            Row row = sheetAt.getRow(i);
            //空行跳过
            if (null == row) {
                continue;
            }
            //获取总列数
            Short lastCellNum = row.getLastCellNum();
            if (lastCellNum > 0) {

                int rowNum = i + 1;    //当前行号
                int errorNum = 0;      //错误数量
                String cellNum = "";   //错误列号
                String errorInfo = ""; //错误信息

                //维修判定类型代码
                try {
                    //第一列必须有值，否则跳过
                    row.getCell(0).setCellType(CellType.STRING);
                } catch (Exception e) {
                    continue;
                }
                String repairJudgeTypeCode = row.getCell(0, Row.MissingCellPolicy.CREATE_NULL_AS_BLANK).getStringCellValue().trim();


                //维修判定类型名称
                String repairJudgeTypeName = null;
                try {
                    row.getCell(1).setCellType(CellType.STRING);
                    repairJudgeTypeName = row.getCell(1, Row.MissingCellPolicy.CREATE_NULL_AS_BLANK).getStringCellValue().trim();
                } catch (Exception e) {
                }

                //序号
                String seq = null;
                try {
                    row.getCell(2).setCellType(CellType.STRING);
                    seq = row.getCell(2, Row.MissingCellPolicy.CREATE_NULL_AS_BLANK).getStringCellValue().trim();
                } catch (Exception e) {
                }

                String key = repairJudgeTypeCode;

                Boolean isExist = false;

                //校验唯一性 不重复
                if (!repairJudgeTypeByOnlyMap.containsKey(key)) {
                    repairJudgeTypeByOnlyMap.put(key, String.valueOf(rowNum));
                    //根据维修判定类型查询替代信息中是否存在数据

                    if (StringUtils.isEmpty(errorInfo) && !CollectionUtils.isEmpty(repairJudgeTypeMapByCode) && repairJudgeTypeMapByCode.containsKey(key)) {
                        errorNum++;
                        cellNum += "A;";
                        errorInfo += "第A列数据已经存在数据库;";
                    }

                    //校验是否已经存在数据库
                    if (!CollectionUtils.isEmpty(repairJudgeTypeMapByCode) && repairJudgeTypeMapByCode.containsKey(key)) isExist = true;
                } else {
                    errorNum++;
                    cellNum += "A;";
                    errorInfo += "第A列数据跟第" + repairJudgeTypeByOnlyMap.get(key) +
                            "行的第A列数据重复;";
                }

                //没有错误的时候，封装MesRepairJudgeType
                if (errorNum == 0) {
                    MesRepairJudgeType repairJudgeType;
                    if (isExist) {
                        repairJudgeType = repairJudgeTypeMapByCode.get(key);
                        ConvertBean.serviceModelUpdate(repairJudgeType, userName);

                    } else {
                        repairJudgeType = new MesRepairJudgeType();
                        ConvertBean.serviceModelInitialize(repairJudgeType, userName);
                        repairJudgeType.setRepairJudgeCode(repairJudgeTypeCode);

                    }

                    repairJudgeType.setRepairJudgeName(repairJudgeTypeName);
                    repairJudgeType.setSeq(seq);
                    repairJudgeType.setSystemSyncStatus(MesExtEnumUtil.IF_SYNC_STATUS.NO_SYNC.getValue());

                    repairJudgeTypeList.add(repairJudgeType);

                    successRowNum++;
                } else {
                    //封装错误行信息ExcelImportErrorExtModel
                    excelImportErrorExtModels = commonExtService.getExcelImportErrorModels(excelImportErrorExtModels, rowNum, errorNum, cellNum, errorInfo);

                    errorRows += rowNum + ";";
                    failRowNum++;
                }
            }
        }

        //校验EXCEL数据
        commonExtService.checkExcelData(failRowNum, successRowNum, errorRows);

        //封装返回结果
        ExcelImportResultExtModel excelImportResultExtModel = commonExtService.getExcelImportResultModel(failRowNum, successRowNum, excelImportErrorExtModels, errorRows);
        excelImportResultExtModel.setExcelList((failRowNum > 0) ? null : repairJudgeTypeList);
        return excelImportResultExtModel;
    }

    /**
     * 维修判定类型导入-数据入库
     *
     * @param excelImportResultExtModel
     */
    private void insertExcelMesRepairJudgeType(ExcelImportResultExtModel excelImportResultExtModel) {
        //导入数据
        if (null != excelImportResultExtModel) {
            List<MesRepairJudgeType> repairJudgeTypeList = excelImportResultExtModel.getExcelList();
            if (!CollectionUtils.isEmpty(repairJudgeTypeList)) repairJudgeTypeRepository.saveAll(repairJudgeTypeList);
        }
    }
}
