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.PredictiveWorkPlanSparePartMapper;
import org.jeecg.modules.eam.model.MdcEquipmentRunningSectionVo;
import org.jeecg.modules.eam.service.IPredictiveWorkOrderService;
import org.jeecg.modules.eam.service.IPredictiveWorkPlanService;
import org.jeecg.modules.eam.service.IPredictiveWorkPlanSparePartService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;

@Service
public class PredictiveWorkPlanSparePartServiceImpl extends ServiceImpl<PredictiveWorkPlanSparePartMapper, PredictiveWorkPlanSparePart> implements IPredictiveWorkPlanSparePartService {

    @Autowired
    private IPredictiveWorkPlanService predictiveWorkPlanService;

    @Autowired
    private IPredictiveWorkOrderService predictiveWorkOrderService;

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

    //    1.查询配置的 备件触发条件
    //    2.获取备件的的实际寿命    设备开机时间 - 换件时间 （设备开机时间信息截止到昨日）
    //    3.判断实际寿命是否大于控制寿命，并生成维护工单
    @Override
    public void createSparePartWorkPlan() {
        List<PredictiveWorkPlan> predictiveWorkPlanList = predictiveWorkPlanService.listWorkPlan("bjkz");
        for (PredictiveWorkPlan predictiveWorkPlan : predictiveWorkPlanList) {
            List<PredictiveWorkPlanSparePart> predictiveWorkPlanSparePartList = listPredictiveWorkPlanSparePart(predictiveWorkPlan.getId());
            for (PredictiveWorkPlanSparePart predictiveWorkPlanSparePart : predictiveWorkPlanSparePartList) {
                Date replacementTime = findReplacementTime(predictiveWorkPlanSparePart.getEquipmentId(), predictiveWorkPlanSparePart.getSparePartId());
                predictiveWorkPlanSparePart.setReplacementTime(replacementTime);
                long actualLife = findActualLife(predictiveWorkPlanSparePart.getMdcEquipmentId(), replacementTime);
                predictiveWorkPlanSparePart.setActualLife(actualLife);
                if (actualLife > predictiveWorkPlanSparePart.getLifeWarning()) {
                    //1.判断是否生成维护工单， 2.生成维护工单
                    this.createOrder(predictiveWorkPlan.getId(), predictiveWorkPlan.getEquipmentId(), predictiveWorkPlanSparePart.getId());
                }
            }
        }
    }

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

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

    //没有对应的维护工单就生成工单
    private void createOrder(String workPlanId, String equipmentId, String itemId) {
        LambdaQueryChainWrapper<PredictiveWorkOrder> lambdaQuery = predictiveWorkOrderService.lambdaQuery();
        lambdaQuery.eq(PredictiveWorkOrder::getEquipmentId, equipmentId).eq(PredictiveWorkOrder::getItemId, itemId).eq(PredictiveWorkOrder::getWorkPlanId, workPlanId);
        //已创建 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.setItemId(itemId);
            predictiveWorkOrder.setEquipmentId(equipmentId);
            predictiveWorkOrder.setWorkPlanId(workPlanId);
            predictiveWorkOrderService.add(predictiveWorkOrder);
        }
    }

    //查询配置的 备件触发条件
    public List<PredictiveWorkPlanSparePart> listPredictiveWorkPlanSparePart(String predictiveWorkPlanId) {
        return super.getBaseMapper().listPredictiveWorkPlanSparePart(predictiveWorkPlanId);
    }

    //最后换件时间
    public Date findReplacementTime(String equipmentId, String sparePartId) {
        List<MaintenanceOrderActualMaterial> maintenanceOrderActualMaterialList = super.getBaseMapper().listMaintenanceOrderActualMaterial(equipmentId, sparePartId);
        if (maintenanceOrderActualMaterialList.size() > 0) {
            return maintenanceOrderActualMaterialList.get(0).getCreateTime();
        }
        return new Date();
    }

    //实际寿命
    //1.倒序设备状态
    //2.累加设备非关机的时间 当设备状态的开始时间小于换件时间 或者 换件时间介于设备状态的开始时间和结束时间之间的数据后，停止累加
    //3.换算单位为小时
    public long findActualLife(String mdcEquipmentId, Date replacementTime) {
        long actualLife = 0l;
        long replacementTimeLong = replacementTime.getTime();
        List<MdcEquipmentRunningSectionVo> mdcEquipmentRunningSectionVoList = super.getBaseMapper().listMdcEquipmentRunningSectionVo(mdcEquipmentId);
        for (MdcEquipmentRunningSectionVo temp : mdcEquipmentRunningSectionVoList) {
            if (replacementTimeLong < temp.getStartLong()) {
                actualLife = actualLife + temp.getDuration();
            } else if (replacementTimeLong >= temp.getStartLong() && replacementTimeLong <= temp.getEndLong()) {
                actualLife = actualLife + (temp.getEndLong() - replacementTimeLong);
            } else {
                continue;
            }
        }
        return actualLife / 60 / 60;
    }

}