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 com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.hpsf.Decimal;
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 org.dromara.eims.domain.EimsFixture;
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.domain.vo.EimsFixtureImportVo;
import org.dromara.eims.domain.vo.EimsFixtureVo;
import org.dromara.eims.mapper.EimsFixtureMapper;
import org.dromara.eims.service.IEimsEquService;
import org.dromara.eims.service.IEimsFixtureService;
import org.dromara.system.domain.SysDept;
import org.dromara.system.domain.SysUser;
import org.dromara.system.domain.vo.SysDeptVo;
import org.dromara.system.domain.vo.SysUserVo;
import org.dromara.system.mapper.SysDeptMapper;
import org.dromara.system.mapper.SysUserMapper;
import org.dromara.system.service.ISysUserService;

import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 工具自定义导入
 *
 * @author zhuguifei
 */
@Slf4j
public class EimsFixtureImportListener extends AnalysisEventListener<EimsFixtureImportVo> implements ExcelListener<EimsFixtureImportVo> {

    private final EimsFixtureMapper fixtureMapper;
    private final SysUserMapper sysUserMapper;
    private final SysDeptMapper sysDeptMapper;

    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 coverNum = 0;
    private int failureNum = 0;
    private final StringBuilder successMsg = new StringBuilder();
    private final StringBuilder failureMsg = new StringBuilder();

    public EimsFixtureImportListener(Boolean isUpdateSupport) {
        this.fixtureMapper = SpringUtils.getBean(EimsFixtureMapper.class);
        this.sysUserMapper = SpringUtils.getBean(SysUserMapper.class);
        this.sysDeptMapper = SpringUtils.getBean(SysDeptMapper.class);
        this.dictService = SpringUtils.getBean(DictService.class);
        this.isUpdateSupport = isUpdateSupport;
        this.operUserId = LoginHelper.getUserId();
        this.unitDictMap = dictService.getAllDictByDictType(DictConstants.EIMS_FIXTURE_UNIT);
    }

    @Override
    public void invoke(EimsFixtureImportVo fixtureVo, AnalysisContext context) {
        try {
            fixtureVo.setStatus("0");
            // 根据资产编号查询工具是否已存在
            LambdaQueryWrapper<EimsFixture> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(EimsFixture::getAssetNo,fixtureVo.getAssetNo());
            EimsFixtureVo eimsFixtureVo = fixtureMapper.selectVoOne(queryWrapper);
            // 处理不规则数据
            //1.单位unit-excel导入数据中单位字段不规则，特殊处理
            // normalizeUnit(fixtureVo, unitDictMap);
            //2.购买日期、验收日期 特殊处理
            if (StringUtils.isNotEmpty(fixtureVo.getPurchaseDateStr())) {
                try {
                    fixtureVo.setPurchaseDate(DateUtils.parseDate(fixtureVo.getPurchaseDateStr()));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if (StringUtils.isNotEmpty(fixtureVo.getDeployDateStr())) {
                try {
                    fixtureVo.setDeployDate(DateUtils.parseDate(fixtureVo.getDeployDateStr()));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            // 管理人处理
            if (StringUtils.isNotEmpty(fixtureVo.getManageUserStr())) {
                try {
                    LambdaQueryWrapper<SysUser> usrQueryWrapper = new LambdaQueryWrapper<>();
                    usrQueryWrapper.eq(SysUser::getNickName,fixtureVo.getManageUserStr());
                    SysUserVo sysUserVo = sysUserMapper.selectVoOne(usrQueryWrapper);
                    if(sysUserVo!=null){
                        fixtureVo.setManageUser(sysUserVo.getUserId());
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            // 部门处理
            if (StringUtils.isNotEmpty(fixtureVo.getUseDeptStr())) {
                try {
                    LambdaQueryWrapper<SysDept> dptQueryWrapper = new LambdaQueryWrapper<>();
                    dptQueryWrapper.eq(SysDept::getDeptName,fixtureVo.getUseDeptStr());
                    SysDeptVo deptVo = sysDeptMapper.selectVoOne(dptQueryWrapper);
                    if(deptVo!=null){
                        fixtureVo.setUseDept(deptVo.getDeptId());
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }


            if (StringUtils.isNotEmpty(fixtureVo.getUnitPriceStr())) {
                try {
                    String priceStr = extractNumber(fixtureVo.getUnitPriceStr());
                    int price = 0;
                    if (priceStr != null) {
                        price = Integer.parseInt(priceStr);
                    }
                    if(price>0){
                        fixtureVo.setUnitPrice(new BigDecimal(price));
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }



            // 验证是否存在
            if (ObjectUtil.isNull(eimsFixtureVo)) {
                EimsFixture fixture = BeanUtil.toBean(fixtureVo, EimsFixture.class);
                // TODO 校验
                //ValidatorUtils.validate(equ);

                //添加字段默认属性
                fixture.setCreateBy(operUserId);
                fixtureMapper.insert(fixture);
                successNum++;
                successMsg.append("<br/>").append(successNum).append("、工具 ").append(fixture.getFixtureName()).append(" 导入成功");
            } else if (isUpdateSupport) {
                EimsFixture fixture = BeanUtil.toBean(fixtureVo, EimsFixture.class);
                fixture.setId(eimsFixtureVo.getId());
                fixture.setUpdateBy(operUserId);
                fixture.setUpdateTime(new Date());
                fixtureMapper.updateById(fixture);
                coverNum++;
                successMsg.append("<br/>").append(successNum).append("、工具 ").append(fixture.getFixtureName()).append(" 更新成功");
            } else {
                failureNum++;
                failureMsg.append("<br/>").append(failureNum).append("、工具 ").append(eimsFixtureVo.getFixtureName()).append(eimsFixtureVo.getAssetNo()).append(" 已存在");
            }
        } catch (Exception e) {
            failureNum++;
            String msg = "<br/>" + failureNum + "、工具 " + fixtureVo.getFixtureName() + " 导入失败：";
            failureMsg.append(msg).append(e.getMessage());
            log.error(msg, e);
        }
    }

    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {

    }

    @Override
    public ExcelResult<EimsFixtureImportVo> 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 + coverNum )+ " 条，数据如下：");
                }
                return successMsg.toString();
            }

            @Override
            public List<EimsFixtureImportVo> 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());
        }
    }

    /**
     * 提取数字
      * @param input
     * @return
     */
    private static String extractNumber(String input) {
        Pattern NUMBER_PATTERN = Pattern.compile("(\\d+(\\.\\d+)?)");
        Matcher matcher = NUMBER_PATTERN.matcher(input);
        if (matcher.find()) {
            return matcher.group(1); // 返回第一个捕获组，即数字部分
        }
        return null;
    }


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

}