package org.jeecg.modules.eam.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.jeecg.common.util.UUIDGenerator;
import org.jeecg.modules.eam.entity.*;
import org.jeecg.modules.eam.mapper.PredictiveWorkPlanWarnMapper;
import org.jeecg.modules.eam.model.MdcEquipmentAlarmVo;
import org.jeecg.modules.eam.service.IPredictiveWorkOrderService;
import org.jeecg.modules.eam.service.IPredictiveWorkPlanService;
import org.jeecg.modules.eam.service.IPredictiveWorkPlanWarnHistoryService;
import org.jeecg.modules.eam.service.IPredictiveWorkPlanWarnService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;

@Service
public class PredictiveWorkPlanWarnServiceImpl extends ServiceImpl<PredictiveWorkPlanWarnMapper, PredictiveWorkPlanWarn> implements IPredictiveWorkPlanWarnService {

    @Autowired
    private IPredictiveWorkPlanService predictiveWorkPlanService;

    @Autowired
    private IPredictiveWorkOrderService predictiveWorkOrderService;

    @Autowired
    private IPredictiveWorkPlanWarnHistoryService predictiveWorkPlanWarnHistoryService;

    @Override
    public List<PredictiveWorkPlanWarn> listPredictiveWorkPlanWarn(Map<String, Object> params) {
        return super.baseMapper.listPredictiveWorkPlanWarn(params);
    }

    @Override
    public IPage<Map<String, Object>> pagePredictiveWorkPlanWarn(Integer pageNo, Integer pageSize, Map<String, Object> params) {
        IPage<Map> pageData = new Page<Map>(pageNo, pageSize);
        return super.baseMapper.pagePredictiveWorkPlanWarn(pageData, params);
    }

    //    1.通过预测性方案 查询配置的 报警触发条件
    //    2.倒序取N条数据，判断首尾两条数据是否在报警条件周期内
    //    3.判断是否生产维护工单，并生成维护工单
    @Override
    public void createWarnWorkPlan() {
        List<PredictiveWorkPlan> predictiveWorkPlanList = predictiveWorkPlanService.listWorkPlan("bjkz");
        for (PredictiveWorkPlan predictiveWorkPlan : predictiveWorkPlanList) {
            List<PredictiveWorkPlanWarn> predictiveWorkPlanWarnList = listPredictiveWorkPlanWarn(predictiveWorkPlan.getId());
            //方案对应的告警信息
            boolean needWarnFlag = false;
            int needWarnFlagTimes = 0;
            List<MdcEquipmentAlarmVo> insertList = new ArrayList<>();
            for (PredictiveWorkPlanWarn predictiveWorkPlanWarn : predictiveWorkPlanWarnList) {
                List<MdcEquipmentAlarmVo> mdcEquipmentAlarmVoList = this.findWarnInfo(predictiveWorkPlanWarn.getMdcEquipmentId(),
                        predictiveWorkPlanWarn.getTimes(), predictiveWorkPlanWarn.getWarnCode());
                if (mdcEquipmentAlarmVoList.size() >= predictiveWorkPlanWarn.getTimes() &&
                        isTimeInWarnCycle(predictiveWorkPlanWarn.getWarnCycle(), predictiveWorkPlanWarn.getCycleUnit(),
                                mdcEquipmentAlarmVoList.get(0).getCollectTime(), mdcEquipmentAlarmVoList.get(mdcEquipmentAlarmVoList.size() - 1).getCollectTime())) {
                    insertList.addAll(mdcEquipmentAlarmVoList);
                    needWarnFlagTimes++;
                }
            }
            if ("and".equals(predictiveWorkPlanWarnList.get(0).getParameterCondition())) {
                if (needWarnFlagTimes == predictiveWorkPlanWarnList.size()) {
                    needWarnFlag = true;
                }
            } else if ("or".equals(predictiveWorkPlanWarnList.get(0).getParameterCondition())) {
                if (needWarnFlagTimes > 0) {
                    needWarnFlag = true;
                }
            }
            if (needWarnFlag) {
                //判断是否生成工单 ,将报警信息备份
                boolean flag = this.createOrder(predictiveWorkPlan.getId(), predictiveWorkPlan.getEquipmentId());
                if (flag) {
                    this.backInfo(predictiveWorkPlan.getId(), insertList);
                }
            }
        }
    }

    @Override
    public void removeByWorkPlanId(String predictiveWorkPlanId) {
        LambdaUpdateChainWrapper<PredictiveWorkPlanWarn> lambdaUpdate = this.lambdaUpdate();
        lambdaUpdate.eq(PredictiveWorkPlanWarn::getWorkPlanId, predictiveWorkPlanId);
        lambdaUpdate.remove();
    }

    @Override
    public void revise(String oldWorkPlanId, String workPlanId) {
        LambdaQueryChainWrapper<PredictiveWorkPlanWarn> lambdaQuery = this.lambdaQuery();
        lambdaQuery.eq(PredictiveWorkPlanWarn::getWorkPlanId,oldWorkPlanId).eq(PredictiveWorkPlanWarn::getDelFlag,0);
        List<PredictiveWorkPlanWarn> insertList = lambdaQuery.list();
        for(PredictiveWorkPlanWarn predictiveWorkPlanWarn:insertList){
            predictiveWorkPlanWarn.setWorkPlanId(workPlanId);
            predictiveWorkPlanWarn.setId(UUIDGenerator.generate());
        }
        this.saveBatch(insertList);
    }

    private void backInfo(String workPlanId, List<MdcEquipmentAlarmVo> predictiveWorkPlanWarnList) {
        List<PredictiveWorkPlanWarnHistory> list = new ArrayList<>();
        for (MdcEquipmentAlarmVo mdcEquipmentAlarmVo : predictiveWorkPlanWarnList) {
            PredictiveWorkPlanWarnHistory predictiveWorkPlanWarnHistory = new PredictiveWorkPlanWarnHistory();
            predictiveWorkPlanWarnHistory.setWorkPlanId(workPlanId);
            predictiveWorkPlanWarnHistory.setWarnId(mdcEquipmentAlarmVo.getAlarmNo());
            predictiveWorkPlanWarnHistory.setWarnCode(mdcEquipmentAlarmVo.getAlarmNo());
            predictiveWorkPlanWarnHistory.setWarnName(mdcEquipmentAlarmVo.getAlarmContent());
            predictiveWorkPlanWarnHistory.setCollectTime(mdcEquipmentAlarmVo.getCollectTime());
            list.add(predictiveWorkPlanWarnHistory);
        }
        predictiveWorkPlanWarnHistoryService.saveBatch(list);
    }

    private boolean createOrder(String workPlanId, String equipmentId) {
        LambdaQueryChainWrapper<PredictiveWorkOrder> lambdaQuery = predictiveWorkOrderService.lambdaQuery();
        lambdaQuery.eq(PredictiveWorkOrder::getWorkPlanId, workPlanId).eq(PredictiveWorkOrder::getEquipmentId, equipmentId);
        //已创建 0     已下发	1	 未开始	2	 执行中	3
        lambdaQuery.in(PredictiveWorkOrder::getStatus, Arrays.asList(new String[]{"0", "1", "2", "3"}));
        lambdaQuery.eq(PredictiveWorkOrder::getDelFlag, 0);
        List<PredictiveWorkOrder> list = lambdaQuery.list();
        if (list == null || list.size() == 0) {
            PredictiveWorkOrder predictiveWorkOrder = new PredictiveWorkOrder();
            predictiveWorkOrder.setEquipmentId(equipmentId);
            predictiveWorkOrder.setWorkPlanId(workPlanId);
            predictiveWorkOrderService.add(predictiveWorkOrder);
            return true;
        }
        return false;
    }

    //单位统一换算为秒
    private boolean isTimeInWarnCycle(int warnCycle, String cycleUnit, Date endCollectTime, Date startCollectTime) {
        long warnCycleSecond = 0l;
        if ("minute".equals(cycleUnit)) {
            warnCycleSecond = warnCycle * 60;
        } else if ("hour".equals(cycleUnit)) {
            warnCycleSecond = warnCycle * 60 * 60;
        } else if ("day".equals(cycleUnit)) {
            warnCycleSecond = warnCycle * 60 * 60 * 24;
        }
        long startCollectTimeLong = startCollectTime.getTime();
        long endCollectTimeLong = endCollectTime.getTime();
        if ((endCollectTimeLong - startCollectTimeLong) <= warnCycleSecond) {
            return true;
        }
        return false;
    }

    private List<MdcEquipmentAlarmVo> findWarnInfo(String mdcEquipmentId, int times, String warnCode) {
        return this.getBaseMapper().findWarnInfo(mdcEquipmentId, times, warnCode);
    }

    //方案对应的告警条件配置
    private List<PredictiveWorkPlanWarn> listPredictiveWorkPlanWarn(String predictiveWorkPlanId) {
        return this.getBaseMapper().listWarn(predictiveWorkPlanId);
    }

}