package org.dromara.eims.listener;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.excel.exception.ExcelDataConvertException;
import org.dromara.common.core.constant.CacheConstants;
import org.dromara.common.core.constant.Constants;
import org.dromara.common.core.constant.DictConstants;
import org.dromara.common.core.exception.ServiceException;
import org.dromara.common.core.service.DictService;
import org.dromara.common.core.utils.DateUtils;
import org.dromara.common.core.utils.SpringUtils;
import org.dromara.common.core.utils.StringUtils;
import org.dromara.common.excel.core.ExcelListener;
import org.dromara.common.excel.core.ExcelResult;
import org.dromara.common.satoken.utils.LoginHelper;
import lombok.extern.slf4j.Slf4j;
import org.dromara.eims.domain.bo.EimsEquBo;
import org.dromara.eims.domain.vo.EimsEquImportVo;
import org.dromara.eims.domain.vo.EimsEquVo;
import org.dromara.eims.service.IEimsEquService;
import org.dromara.system.domain.bo.SysUserBo;
import org.dromara.system.service.ISysUserService;

import java.util.List;
import java.util.Map;

/**
 * 设备自定义导入
 *
 * @author zhuguifei
 */
@Slf4j
public class EimsEquImportListener extends AnalysisEventListener<EimsEquImportVo> implements ExcelListener<EimsEquImportVo> {

    private final IEimsEquService equService;

    private final ISysUserService userService;

    private final DictService dictService;
    // 当前导入用户
    private final Long operUserId;

    private final Boolean isUpdateSupport;

    //unit字典
    private final Map<String, String> unitDictMap;


    private int successNum = 0;
    private int failureNum = 0;
    private final StringBuilder successMsg = new StringBuilder();
    private final StringBuilder failureMsg = new StringBuilder();

    public EimsEquImportListener(Boolean isUpdateSupport) {
        this.equService = SpringUtils.getBean(IEimsEquService.class);
        ;
        this.userService = SpringUtils.getBean(ISysUserService.class);
        this.dictService = SpringUtils.getBean(DictService.class);
        this.isUpdateSupport = isUpdateSupport;
        this.operUserId = LoginHelper.getUserId();
        this.unitDictMap = dictService.getAllDictByDictType(DictConstants.EIMS_EQU_UNIT);
    }

    @Override
    public void invoke(EimsEquImportVo equVo, AnalysisContext context) {
        try {
            // 根据资产编号查询设备是否已存在
            EimsEquVo eimsEquVo = equService.queryByAssetNo(equVo.getAssetNo());
            // 处理不规则数据
            //1.单位unit-excel导入数据中单位字段不规则，特殊处理
            normalizeUnit(equVo, unitDictMap);
            //2.购买日期、验收日期 特殊处理
            if (StringUtils.isNotEmpty(equVo.getPurchaseDateStr())) {
                try {
                    equVo.setPurchaseDate(DateUtils.parseDate(equVo.getPurchaseDateStr()));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if (StringUtils.isNotEmpty(equVo.getActualAcceptDateStr())) {
                try {
                    equVo.setActualAcceptDate(DateUtils.parseDate(equVo.getActualAcceptDateStr()));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            // 如果资产编号为空则跳过此条数据
            if (StringUtils.isEmpty(equVo.getAssetNo())) {
                return;
            }


            EimsEquBo equ = BeanUtil.toBean(equVo, EimsEquBo.class);
            equ.setStatus(dictService.getDictValue(DictConstants.EIMS_EQU_STATUS,"正常"));
            // 验证是否存在这个用户
            if (ObjectUtil.isNull(eimsEquVo)) {

                // TODO 校验
                //ValidatorUtils.validate(equ);

                //添加字段默认属性
                equ.setImportStatus(dictService.getDictValue(DictConstants.EIMS_IMPORT_STATUS,"新导入"));
                equ.setCreateBy(operUserId);
                equService.insertByBo(equ);
                successNum++;
                successMsg.append("<br/>").append(successNum).append("、设备 ").append(equ.getEquName()).append(" 导入成功");
            } else if (isUpdateSupport) {
                equ.setEquId(eimsEquVo.getEquId());
                equService.updateByBo(equ);
                equ.setImportStatus(dictService.getDictValue(DictConstants.EIMS_IMPORT_STATUS,"更新"));
                // TODO 执行覆盖逻辑
                successNum++;
                successMsg.append("<br/>").append(successNum).append("、设备 ").append(equ.getEquName()).append(" 更新成功");
            } else {
                failureNum++;
                failureMsg.append("<br/>").append(failureNum).append("、设备 ").append(eimsEquVo.getEquName()).append(eimsEquVo.getAssetNo()).append(" 已存在");
            }
        } catch (Exception e) {
            failureNum++;
            String msg = "<br/>" + failureNum + "、设备 " + equVo.getEquName() + " 导入失败：";
            failureMsg.append(msg).append(e.getMessage());
            log.error(msg, e);
        }
    }

    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {

    }

    @Override
    public ExcelResult<EimsEquImportVo> getExcelResult() {
        return new ExcelResult<>() {

            @Override
            public String getAnalysis() {
                if (failureNum > 0) {
                    failureMsg.insert(0, "很抱歉，导入失败！共 " + failureNum + " 条数据格式不正确，错误如下：");
                    throw new ServiceException(failureMsg.toString());
                } else {
                    successMsg.insert(0, "恭喜您，数据已全部导入成功！共 " + successNum + " 条，数据如下：");
                }
                return successMsg.toString();
            }

            @Override
            public List<EimsEquImportVo> getList() {
                return null;
            }

            @Override
            public List<String> getErrorList() {
                return null;
            }
        };
    }

    @Override
    public void onException(Exception exception, AnalysisContext context) throws Exception {
        log.error("解析失败，但是继续解析下一行:{}", exception.getMessage());
        // 如果是某一个单元格的转换异常 能获取到具体行号
        // 如果要获取头的信息 配合invokeHeadMap使用
        if (exception instanceof ExcelDataConvertException) {
            ExcelDataConvertException excelDataConvertException = (ExcelDataConvertException) exception;
            log.error("第{}行，第{}列解析异常，数据为:{}", excelDataConvertException.getRowIndex(),
                excelDataConvertException.getColumnIndex(), excelDataConvertException.getCellData().getData());
        }
    }


    /**
     * 为导入设备匹配单位
     *
     * @param equVo
     * @param unitDictMap
     */
    private void normalizeUnit(EimsEquImportVo equVo, Map<String, String> unitDictMap) {
        if (equVo == null || StringUtils.isEmpty(equVo.getUnit()) || unitDictMap == null || unitDictMap.isEmpty()) {
            return;
        }
        String originalUnit = equVo.getUnit();
        //避免错误单位
        equVo.setUnit(null);
        for (Map.Entry<String, String> entry : unitDictMap.entrySet()) {
            if (originalUnit.contains(entry.getValue())) {
                equVo.setUnit(entry.getValue());
                break;
            }
        }
    }

}