package com.skua.modules.quartz;

import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.stream.Collectors;

import org.apache.commons.lang3.StringUtils;
import org.flowable.engine.ProcessEngine;
import org.flowable.engine.ProcessEngines;
import org.flowable.engine.TaskService;
import org.flowable.identitylink.api.IdentityLink;
import org.flowable.identitylink.api.IdentityLinkType;
import org.flowable.task.service.impl.persistence.entity.TaskEntity;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.skua.core.context.SpringContextUtils;
import com.skua.core.util.ConvertUtils;
import com.skua.core.util.DateUtils;
import com.skua.core.util.chuanglan.HttpSenderMsg;
import com.skua.core.util.push.IPushService;
import com.skua.core.util.push.MessageEntity;
import com.skua.core.util.push.PushMessageFactory;
import com.skua.modules.alarmtmp.entity.AlarmCustomRuleRepository;
import com.skua.modules.alarmtmp.entity.AlarmMessageHistory;
import com.skua.modules.alarmtmp.entity.AlarmRecordHistory;
import com.skua.modules.alarmtmp.entity.AlarmRuleConfigPublicTab;
import com.skua.modules.alarmtmp.entity.AlarmRuleLevelConfig;
import com.skua.modules.alarmtmp.entity.AlarmRuleLevelConfigTemplate;
import com.skua.modules.alarmtmp.service.AlarmMessageHistoryService;
import com.skua.modules.alarmtmp.service.AlarmRecordHistoryService;
import com.skua.modules.alarmtmp.service.AlarmRuleConfigService;
import com.skua.modules.alarmtmp.service.IAlarmCustomRuleRepositoryService;
import com.skua.modules.alarmtmp.service.IAlarmRuleConfigPublicTabService;
import com.skua.modules.alarmtmp.service.IAlarmRuleLevelConfigTemplateService;
import com.skua.modules.alarmtmp.vo.AlarmRuleConfigAndLevelVO;
import com.skua.modules.alarmtmp.vo.SystemNoticeVO;
import com.skua.modules.flow.business.service.FlowBusinessService;
import com.skua.modules.flow.business.service.IFlowService;
import com.skua.modules.flow.core.constant.ProcessConstant;
import com.skua.modules.flow.core.entity.BladeFlow;
import com.skua.modules.flow.core.utils.FlowUtil;
import com.skua.modules.flow.support.Kv;
import com.skua.modules.flow.utils.Func;
import com.skua.modules.system.entity.SysUser;
import com.skua.modules.system.service.IPgService;
import com.skua.modules.system.service.ISysUserService;
import com.skua.modules.util.SysMessagePushService;
import com.skua.modules.util.SystemNoticeUtils;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;
/**
 * @program: skboot
 * @description: 实时判断是否存在超时的警告
 * @author: xie chao
 * @create: 2020-11-02 13:48
 */
@Slf4j
@Component
public class RealTimeAlarmJob implements Job {
    @Autowired
    private AlarmRuleConfigService alarmRuleConfigService;
    @Value("${skua.alarmTimeInterval:}")
    private String alarmTimeInterval;//获取时间间隔
    @Autowired
    private AlarmRecordHistoryService alarmRecordHistoryService;
    @Autowired
    private AlarmMessageHistoryService alarmMessageHistoryService;
    @Autowired
    private IAlarmRuleLevelConfigTemplateService alarmRuleLevelConfigTemplateService;
    @Autowired
    private ISysUserService sysUserService;
    @Autowired
    private SystemNoticeUtils systemNoticeUtils;
    @Autowired
    private IPgService pgService;
    @Autowired
    private IFlowService flowService;
    @Autowired
    private FlowBusinessService flowBusinessService;
    @Autowired
    private TaskService taskService;
    @Autowired
    private IAlarmRuleConfigPublicTabService alarmRuleConfigPublicTabService;
    @Autowired
    private IAlarmCustomRuleRepositoryService alarmCustomRuleRepositoryService;
    
    private static String prefix = "【金控数矿】在";
    private static String departNameTemplete = "${departName}";
    private static String contentTemplete = "${alarmParamName}:${actualAvgValue}(${limit})${alarmParamUnit}";
    private static String suffix = "，请注意！";
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        try {
            log.info("水质实时数据报警任务开始");
            //获取水质、水量、工艺报警规则信息
            List<AlarmRuleConfigAndLevelVO> alarmRuleAndAlarmRuleLevelVOList = alarmRuleConfigService.getAlarmRuleAndAlarmRuleLeveList("realTimeAlarmJob");
            //获取设备参数报警规则信息
            List<AlarmRuleConfigAndLevelVO> equipAlarmRuleAndAlarmRuleLevelVOList = alarmRuleConfigService.getAlarmRuleAndAlarmRuleLeveList("equipRealTimeAlarmJob");
            //将报警规则合并
            List<AlarmRuleConfigAndLevelVO> allAlarmRuleAndAlarmRuleLevelVOList = new ArrayList<AlarmRuleConfigAndLevelVO>();
            if(alarmRuleAndAlarmRuleLevelVOList!=null&&alarmRuleAndAlarmRuleLevelVOList.size()>0) {
            	allAlarmRuleAndAlarmRuleLevelVOList.addAll(alarmRuleAndAlarmRuleLevelVOList);
            }
            if(equipAlarmRuleAndAlarmRuleLevelVOList!=null&&equipAlarmRuleAndAlarmRuleLevelVOList.size()>0) {
            	allAlarmRuleAndAlarmRuleLevelVOList.addAll(equipAlarmRuleAndAlarmRuleLevelVOList);
            }
            
            //查询pg数据超标警报
            Map<String, Object> excessAlarmPgList = checkPgExcessAlarm(allAlarmRuleAndAlarmRuleLevelVOList);
            sendMessage(excessAlarmPgList);
            log.info("水质实时数据任务开始结束");
        } catch (Exception e) {
        	e.printStackTrace();
            log.error("水质实时数据任务异常" + e);
        }
    }
    /**
     * 判断pg数据库中超标的警报
     *
     * @param pgExcessAlarmList
     */
    public Map<String, Object> checkPgExcessAlarm(List<AlarmRuleConfigAndLevelVO> pgExcessAlarmList) {
        Map<String, Object> result = Maps.newHashMap();
        //存放厂ID和指标的List集合
        Map<String, String> stringMap = new HashMap<>();
        pgExcessAlarmList.forEach(alarmRuleAndAlarmRuleLevelVO -> {
            String alarmProgramCode = stringMap.get(alarmRuleAndAlarmRuleLevelVO.getDepartId());
            if (StringUtils.isBlank(alarmProgramCode)) {
                stringMap.put(alarmRuleAndAlarmRuleLevelVO.getDepartId(), alarmRuleAndAlarmRuleLevelVO.getAlarmProgramCode());
            } else {
                stringMap.put(alarmRuleAndAlarmRuleLevelVO.getDepartId(), alarmProgramCode + "," + alarmRuleAndAlarmRuleLevelVO.getAlarmProgramCode());
            }
        });
        Map<String, List<Map<String, Object>>> resultListMap = new HashMap<>();
        Long now = DateUtils.getMillis() / 1000;
        //循环将计算数据取出
        stringMap.forEach((departId, alarmProgramCodeStr) -> {
            Long start = now - Integer.parseInt(alarmTimeInterval);
            //根据departId查询数据库的数据，查询的时候注意将超标的字段设置为查询字段
            List<Map<String, Object>> maps = pgService.queryAlarmInfoByXT(departId, alarmProgramCodeStr, start.toString(), now.toString());
            if (maps != null && maps.size() > 0) {
                resultListMap.put(departId, maps);
            }
        });
        Map<String, Map<String, Map<String,Object>>> tmp = new HashMap<>();
        //先按照机构id分组，内部在按照指标名称分组
        if (resultListMap != null && resultListMap.size() > 0) {
            resultListMap.forEach((departId, maps) -> {
                Map<String, List<Map<String, Object>>> nm = maps.stream().collect(Collectors.groupingBy(v -> (String) v.get("nm")));
                nm.forEach((key, value) -> {
                	//获取最大值，最小值
                	value = value.stream().sorted((i, j) -> Double.compare(ConvertUtils.getDouble(i.get("v"), 0), ConvertUtils.getDouble(j.get("v"), 0))).collect(Collectors.toList());
                    //DoubleSummaryStatistics summaryStatistics = value.stream().mapToDouble(value1 -> Double.parseDouble((String) value1.get("v"))).summaryStatistics();
                	Map<String, Map<String,Object>> map = Maps.newHashMap();
                	if(value!=null&&value.size()>0) {
                		map.put("max", CollUtil.getLast(value));
                		map.put("min", CollUtil.getFirst(value));
                    }
                    tmp.put(key, map);
                });
            });
        }
        
        //存放超标数据
        List<AlarmRuleConfigAndLevelVO> excessList = new ArrayList<>();
        //超出有效上下限
        List<AlarmRuleConfigAndLevelVO> errorList = new ArrayList<>();
        for (AlarmRuleConfigAndLevelVO alarmRuleAndAlarmRuleLevelVO : pgExcessAlarmList) {
            String alarmProgramCode = alarmRuleAndAlarmRuleLevelVO.getAlarmProgramCode();
            Map<String, Map<String,Object>> value = tmp.get(alarmProgramCode);
            if (value == null || value.isEmpty()) {
                continue;
            }
            
            Double max = ConvertUtils.getDouble(value.get("max").get("v"), 0);
            String maxTime = DateUtil.format(DateUtil.date(DateUtil.calendar(Long.parseLong(ConvertUtils.getString(value.get("max").get("ts"))+"000"))), "yyyy-MM-dd HH:mm:ss");
            Double min = ConvertUtils.getDouble(value.get("min").get("v"), 0);
            String minTime = DateUtil.format(DateUtil.date(DateUtil.calendar(Long.parseLong(ConvertUtils.getString(value.get("min").get("ts"))+"000"))), "yyyy-MM-dd HH:mm:ss");
            
            //先判断是否超出有效上下限
            String effectiveLowerLimit = alarmRuleAndAlarmRuleLevelVO.getEffectiveLowerLimit();
            String effectiveUpperLimit = alarmRuleAndAlarmRuleLevelVO.getEffectiveUpperLimit();
            if (StringUtils.isNotBlank(effectiveLowerLimit)) {
                double effectiveLower = Double.parseDouble(effectiveLowerLimit);
                if (min < effectiveLower) {
                    alarmRuleAndAlarmRuleLevelVO.setValue(min);
                    alarmRuleAndAlarmRuleLevelVO.setRecordTime(minTime);
                    errorList.add(alarmRuleAndAlarmRuleLevelVO);
                    continue;
                }
            }
            if (StringUtils.isNotBlank(effectiveUpperLimit)) {
                double effectiveUpper = Double.parseDouble(effectiveUpperLimit);
                if (max > effectiveUpper) {
                    alarmRuleAndAlarmRuleLevelVO.setValue(max);
                    alarmRuleAndAlarmRuleLevelVO.setRecordTime(maxTime);
                    errorList.add(alarmRuleAndAlarmRuleLevelVO);
                    continue;
                }
            }
            List<AlarmRuleLevelConfig> alarmRuleLevelConfigList = alarmRuleAndAlarmRuleLevelVO.getAlarmRuleLevelConfigList();
            for (AlarmRuleLevelConfig alarmRuleLevelConfig : alarmRuleLevelConfigList) {
                //判断是否超过数据上下限
                String lowerLimitData = alarmRuleLevelConfig.getAlarmParamLowerLimit();
                String upperLimitData = alarmRuleLevelConfig.getAlarmParamUpperLimit();
                if (StringUtils.isNotBlank(lowerLimitData)) {
                    if (min < Double.parseDouble(lowerLimitData)) {
                        alarmRuleAndAlarmRuleLevelVO.setValue(min);
                        alarmRuleAndAlarmRuleLevelVO.setRecordTime(minTime);
                        alarmRuleAndAlarmRuleLevelVO.setAlarmRuleLevelConfig(alarmRuleLevelConfig);
                        excessList.add(alarmRuleAndAlarmRuleLevelVO);
                        break;
                    }
                }
                if (StringUtils.isNotBlank(upperLimitData)) {
                    if (upperLimitData.contains("(")) {
                        String[] split = upperLimitData.split("\\(");
                        upperLimitData = split[0];
                    }
                    if (max > Double.parseDouble(upperLimitData)) {
                        alarmRuleAndAlarmRuleLevelVO.setValue(max);
                        alarmRuleAndAlarmRuleLevelVO.setRecordTime(maxTime);
                        alarmRuleAndAlarmRuleLevelVO.setAlarmRuleLevelConfig(alarmRuleLevelConfig);
                        excessList.add(alarmRuleAndAlarmRuleLevelVO);
                        break;
                    }
                }
            }
        }
        result.put("excessList", excessList);
        
        if(errorList!=null&&errorList.size()>0) {
        	//无效数据报警添加报警类别
        	QueryWrapper<AlarmRuleConfigPublicTab> alarmTypeQueryWrapper = new QueryWrapper<>();
        	alarmTypeQueryWrapper.eq("java_bean_tag", "invalidDataAlarmJob");
        	AlarmRuleConfigPublicTab alarmRuleConfigPublicTab = alarmRuleConfigPublicTabService.getOne(alarmTypeQueryWrapper);
        	String alarmTypeTreePath = alarmRuleConfigPublicTab.getTreePath();
        	//获取无效数据报警方案规则类别
            QueryWrapper<AlarmCustomRuleRepository> alarmRuleConfigQueryWrapper = new QueryWrapper<AlarmCustomRuleRepository>();
            alarmRuleConfigQueryWrapper.eq("bean_service_name", "invalidDataAlarmJob");
            AlarmCustomRuleRepository alarmCustomRuleRepository = alarmCustomRuleRepositoryService.getOne(alarmRuleConfigQueryWrapper);
            //报警方案规则类别
            String alarmCustomRuleTypeTreepath = alarmCustomRuleRepository.getAlarmRuleTypeTreepath();
            //报警方案规则id
            String alarmRepositoryId = alarmCustomRuleRepository.getId();
            
            errorList.forEach(v ->{
            	//向报警规则对象装入报警方案规则类别相关数据
            	String[] alarmCustomRuleTypeTreeArray = alarmCustomRuleTypeTreepath.split(",");
            	v.setAlarmCustomRuleTopType(alarmCustomRuleTypeTreeArray[0]);
            	//预留报警方案规则类别二级配置
            	//v.setAlarmCustomRuleSecondType(alarmCustomRuleTypeTreeArray[1]);
            	v.setAlarmCustomRuleType(alarmRepositoryId);
            	//预留报警方案id配置
            	//v.setAlarmCustomRuleId("");
            	
            	//向报警报警规则对象装入报警类别相关数据
           	 	String[] treeArray = alarmTypeTreePath.split(",");
                v.setAlarmRuleTopType(treeArray[0]);
                v.setAlarmRuleSecondType(treeArray[1]);
            });
            
        }
        
        result.put("errorList", errorList);
        return result;
    }
    /**
     * 判断是否需要发送短信和通知
     *
     * @param resultList
     */
    public void sendMessage(Map<String, Object> resultList) {
        //超标报警
        List<AlarmRuleConfigAndLevelVO> excessList = (List<AlarmRuleConfigAndLevelVO>) resultList.get("excessList");
        if (excessList != null && excessList.size() > 0) {
            excessList.forEach(alarmRuleAndAlarmRuleLevelVO -> {
                dealCBData(alarmRuleAndAlarmRuleLevelVO);
            });
        }
        //将报警恢复成正常状态
        dealStatus(excessList);
        //质量超出上下限
        List<AlarmRuleConfigAndLevelVO> errorList = (List<AlarmRuleConfigAndLevelVO>) resultList.get("errorList");
        if (errorList != null && errorList.size() > 0) {
            errorList.forEach(alarmRuleAndAlarmRuleLevelVO -> {
                dealZLData(alarmRuleAndAlarmRuleLevelVO);
            });
        }
        //将报警恢复成正常状态
        dealSZLtatus(errorList);
    }
    /**
     * @return void
     * @Description 将质量报警恢复成正常状态
     * @Date 2021-09-10 13:54
     * @Param [errorList]
     **/
    private void dealSZLtatus(List<AlarmRuleConfigAndLevelVO> errorList) {
        //查询报警记录置为正常状态
        QueryWrapper<AlarmRecordHistory> queryWrapper = new QueryWrapper<>();
        queryWrapper.in("alarm_rule_type", Lists.newArrayList("6"));
        queryWrapper.eq("alarm_param_type", "数据超过有效上下限报警配置");
        queryWrapper.in("handle_status", 0);
        List<AlarmRecordHistory> list = alarmRecordHistoryService.list(queryWrapper);
        if (list != null && list.size() > 0) {
            Set<String> tmp = Sets.newHashSet();
            errorList.forEach(alarmRuleConfigAndLevelVO -> {
                tmp.add(alarmRuleConfigAndLevelVO.getAlarmProgramCode());
            });
            List<AlarmRecordHistory> alarmRecordHistories = Lists.newArrayList();
            list.forEach(v -> {
                if (!tmp.contains(v.getAlarmParamCode())) {
                    v.setHandleStatus(1);
                    v.setHandleTime(DateUtils.getDate());
                    //v.setHandleUser("admin");
                    alarmRecordHistories.add(v);
                }
            });
            if (alarmRecordHistories.size() > 0) {
                alarmRecordHistoryService.updateBatchById(alarmRecordHistories);
            }
        }
    }
    /**
     * @return void
     * @Description 将报警恢复成正常状态
     * @Date 2021-09-03 9:44
     * @Param [excessList]
     **/
    private void dealStatus(List<AlarmRuleConfigAndLevelVO> excessList) {
        //查询报警记录置为正常状态
        QueryWrapper<AlarmRecordHistory> queryWrapper = new QueryWrapper<>();
        queryWrapper.in("alarm_rule_type", Lists.newArrayList("1", "2", "3", "5", "8"));
        queryWrapper.in("handle_status", 0);
        List<AlarmRecordHistory> list = alarmRecordHistoryService.list(queryWrapper);
        if (list != null && list.size() > 0) {
            Set<String> tmp = Sets.newHashSet();
            excessList.forEach(alarmRuleConfigAndLevelVO -> {
                AlarmRuleLevelConfig alarmRuleLevelConfig = alarmRuleConfigAndLevelVO.getAlarmRuleLevelConfig();
                tmp.add(alarmRuleConfigAndLevelVO.getAlarmProgramCode() + alarmRuleLevelConfig.getId());
            });
            List<AlarmRecordHistory> alarmRecordHistories = Lists.newArrayList();
            list.forEach(v -> {
                if (!tmp.contains(v.getAlarmParamCode() + v.getAlarmRuleLevelId())) {
                    v.setHandleStatus(1);
                    v.setHandleTime(DateUtils.getDate());
                    v.setHandleUser("admin");
                    alarmRecordHistories.add(v);
                }
            });
            if (alarmRecordHistories.size() > 0) {
                alarmRecordHistoryService.updateBatchById(alarmRecordHistories);
            }
        }
    }
    /**
     * @return void
     * @Description 处理超标报警
     * @Date 2021-09-03 9:18
     * @Param [alarmRuleAndAlarmRuleLevelVO]
     **/
    private void dealCBData(AlarmRuleConfigAndLevelVO alarmRuleAndAlarmRuleLevelVO) {
        String date = DateUtils.getDate("yyyy-MM-dd HH:mm:ss");
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:mm");
        SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //查询质量报警配置
        String departId = alarmRuleAndAlarmRuleLevelVO.getDepartId();
        AlarmRuleLevelConfig alarmRuleLevelConfig = alarmRuleAndAlarmRuleLevelVO.getAlarmRuleLevelConfig();
        Double alarmValue = alarmRuleAndAlarmRuleLevelVO.getValue();
        Double minValue = Double.parseDouble(alarmRuleLevelConfig.getAlarmParamLowerLimit());
        Double maxValue = Double.parseDouble(alarmRuleLevelConfig.getAlarmParamUpperLimit());
        String alarmParamCode = alarmRuleAndAlarmRuleLevelVO.getAlarmProgramCode();
        String alarmParamName = alarmRuleAndAlarmRuleLevelVO.getAlarmParamName();
        String alarmRuleType = alarmRuleAndAlarmRuleLevelVO.getAlarmRuleType();
        String alarmRuleLevelName = alarmRuleLevelConfig.getAlarmRuleLevelName();
        String alarmRuleLevelConfigId = alarmRuleLevelConfig.getId();
        String content = "";
        String departName = departNameTemplete.replace("${departName}", alarmRuleAndAlarmRuleLevelVO.getDepartName());
        String unit = "";
        if (alarmRuleAndAlarmRuleLevelVO.getAlarmParamUnit() != null) {
            unit = alarmRuleAndAlarmRuleLevelVO.getAlarmParamUnit();
        }
        if (alarmValue > maxValue) {
            //最大值超标
            content = contentTemplete.replace("${alarmParamName}", alarmParamName)
                    .replace("${actualAvgValue}", alarmValue.doubleValue() + "")
                    .replace("${limit}", ">" + maxValue)
                    .replace("${alarmParamUnit}", unit);
            content = content +"大于上限";
        } else {
            //最小值超标
            content = contentTemplete.replace("${alarmParamName}", alarmParamName)
                    .replace("${actualAvgValue}", alarmValue.doubleValue() + "")
                    .replace("${limit}", "<" + minValue)
                    .replace("${alarmParamUnit}", unit);
            content = content +"小于下限";
        }
        //查询短信上一条报警是否处理，未处理就不新增报警记录
        //TODO 先从数据库中获取，后期优化放redis中
        QueryWrapper<AlarmRecordHistory> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("depart_id", departId);
        queryWrapper.eq("alarm_rule_type", alarmRuleType);
        queryWrapper.eq("alarm_rule_level_id", alarmRuleLevelConfigId);
        queryWrapper.orderByDesc("record_time").last("limit 1");
        AlarmRecordHistory alarmRecordHistoryOne = alarmRecordHistoryService.getOne(queryWrapper);
        //获取上次信息发送的时间，如果满足则发送
        //TODO 先从数据库中获取，后期优化方redis中
        QueryWrapper<AlarmMessageHistory> alarmMessageHistoryQueryWrapper = new QueryWrapper<>();
        alarmMessageHistoryQueryWrapper.eq("alarm_param_code", alarmParamCode);
        alarmMessageHistoryQueryWrapper.eq("alarm_send_type", "1");
        alarmMessageHistoryQueryWrapper.eq("alarm_rule_type", alarmRuleType);
        alarmMessageHistoryQueryWrapper.eq("alarm_rule_level_id", alarmRuleLevelConfigId);
        alarmMessageHistoryQueryWrapper.orderByDesc("alarm_send_time").last("limit 1");
        AlarmMessageHistory messageHistoryOne = alarmMessageHistoryService.getOne(alarmMessageHistoryQueryWrapper);
        Long nowDateLong = null;
        try {
            nowDateLong = simpleDateFormat1.parse(date).getTime();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        //如果没有上条记录或者处理状态(0：未处理，1:已处理)为已处理
        if ((alarmRecordHistoryOne == null || alarmRecordHistoryOne.getHandleStatus() == 1)) {
            AlarmRecordHistory alarmRecordHistory = new AlarmRecordHistory();
            //手动创建UUID，用于报警自动送审
            String uuid = UUID.randomUUID().toString().replaceAll("-", "");
            alarmRecordHistory.setId(uuid);
            alarmRecordHistory.setAlarmParamCode(alarmParamCode);
            alarmRecordHistory.setAlarmParamName(alarmParamName);
            alarmRecordHistory.setAlarmWorkName(alarmParamName+"报警");
            alarmRecordHistory.setAlarmRuleLevelName(alarmRuleLevelName);
            alarmRecordHistory.setAlarmRuleType(alarmRuleType);
            alarmRecordHistory.setAlarmRuleLevelId(alarmRuleLevelConfigId);
            try {
                //alarmRecordHistory.setRecordTime(simpleDateFormat1.parse(date));
                alarmRecordHistory.setRecordTime(simpleDateFormat1.parse(alarmRuleAndAlarmRuleLevelVO.getRecordTime()));
            } catch (ParseException e) {
                e.printStackTrace();
            }
            alarmRecordHistory.setAlarmParamUpperLimit(maxValue.toString());
            alarmRecordHistory.setAlarmParamLowerLimit(minValue.toString());
            alarmRecordHistory.setAlarmParamUnit(alarmRuleAndAlarmRuleLevelVO.getAlarmParamUnit());
            alarmRecordHistory.setDepartId(departId);
            alarmRecordHistory.setActualAvgValue(alarmValue.toString());
            alarmRecordHistory.setHandleStatus(0);
            alarmRecordHistory.setDelFlag(1);
            
            //添加报警类别数据
            alarmRecordHistory.setHandleMethon(alarmRuleAndAlarmRuleLevelVO.getAlarmRecommend());
            alarmRecordHistory.setAlarmRuleTopType(alarmRuleAndAlarmRuleLevelVO.getAlarmRuleTopType());
            alarmRecordHistory.setAlarmRuleSecondType(alarmRuleAndAlarmRuleLevelVO.getAlarmRuleSecondType());
            alarmRecordHistory.setAlarmRuleTypeTreepath(alarmRuleAndAlarmRuleLevelVO.getAlarmRuleTypeTreepath());
            
            //添加报警方案规则类别数据
            alarmRecordHistory.setAlarmCustomRuleTopType(alarmRuleAndAlarmRuleLevelVO.getAlarmCustomRuleTopType());
            alarmRecordHistory.setAlarmCustomRuleSecondType(alarmRuleAndAlarmRuleLevelVO.getAlarmCustomRuleSecondType());
            alarmRecordHistory.setAlarmCustomRuleType(alarmRuleAndAlarmRuleLevelVO.getAlarmCustomRuleType());
            alarmRecordHistory.setAlarmCustomRuleTypeTreepath(alarmRuleAndAlarmRuleLevelVO.getAlarmCustomRuleTypeTreepath());
            
            //构造报警指标数据json
            List<Map<String,Object>> indexDataList = new ArrayList<Map<String,Object>>();
            Map<String,Object> indexJsonMap = new HashMap<String,Object>();
            indexJsonMap.put("indexCode", alarmParamCode);
            indexJsonMap.put("indexName", alarmParamName);
            indexJsonMap.put("indexValue", alarmValue.toString());
            indexDataList.add(indexJsonMap);
            alarmRecordHistory.setAlarmCustomIndexJsonData(JSONUtil.toJsonStr(indexDataList));
            
            //${start}采集数据${conent}已超标，请注意！
            alarmRecordHistory.setAlarmContent("采集数据" + content + suffix);
            alarmRecordHistory.setCreateBy("system");//标记为系统创建
            //alarmRecordHistory.setHandleUser(alarmRuleLevelConfig.getAlarmWorkRecipient());
            //流程添加定义ID
            String processDefinitionId = flowBusinessService.getProcessDefinitionLastVersionId("productAlarmProcess");
            alarmRecordHistory.setProcessDefinitionId(processDefinitionId);
            alarmRecordHistoryService.save(alarmRecordHistory);
            
            
            //判断是否需要发送系统通知 (内容跟报警记录信息相同)
            if ("1".equals(alarmRuleLevelConfig.getIsSendNotice())) {
                if (StringUtils.isNotBlank(alarmRuleLevelConfig.getAlarmNoticeRecipient())) {
                    //义乌报警存在特定参数逻辑，不适用产品原有消息推送流程
                    SysMessagePushService sysMessagePushService = (SysMessagePushService) SpringContextUtils.getBean("sysMessagePushService");
                    sysMessagePushService.pushAlarmRecordMsgNoProcess(alarmRecordHistory);

                    //SystemNoticeVO systemNoticeVO = new SystemNoticeVO(alarmRuleLevelConfig.getAlarmNoticeRecipient(),alarmRuleLevelName, "在" + date + "时" + departName + "采集数据" + content + suffix, departId, alarmRuleType);
                    //systemNoticeUtils.dealNoticeMessage(systemNoticeVO);
                }
            }
            //判断是否需要自动发起工作流
            if("1".equals(alarmRuleLevelConfig.getIsFlowWork())) {
            	if(StringUtils.isNotBlank(alarmRuleLevelConfig.getAlarmWorkRecipient())) {
            		//自动发起工作流 (改成到Mybatis拦截器里面去发起工单了）
            		startProcessFlow("alarm_record_history","productAlarmProcess",Arrays.asList(alarmRuleLevelConfig.getAlarmWorkRecipient().split(",")),uuid,alarmRecordHistory);
            	}
            }
        }
        //判断是否需要发送短信,1表示发送
        if (alarmRuleLevelConfig.getIsSendSms().equals("1")) {
            //判读是否在发送时间内
            Date allowStartDate = null;
            Date allowEndDate = null;
            Date nowDate = null;
            try {
            	//JSONObject jsonObject = (JSONObject) JSONObject.toJSON(alarmRuleLevelConfig);
            	//System.err.println("****************************************************");
                //System.out.println(jsonObject);
                //System.err.println("****************************************************");
                allowEndDate = simpleDateFormat.parse(alarmRuleLevelConfig.getSmsAllowSendTime().split("-")[1]);
                allowStartDate = simpleDateFormat.parse(alarmRuleLevelConfig.getSmsAllowSendTime().split("-")[0]);
                nowDate = simpleDateFormat.parse(date.substring(11, 16));
            } catch (ParseException e) {
                e.printStackTrace();
            }
            //如果在发送时间内，则发送
            if (isEffectiveDate(nowDate, allowStartDate, allowEndDate)) {
                Date lastTime1 = null;
                //如果数据库没有上次时间，则设置一个默认时间
                if (messageHistoryOne != null) {
                    lastTime1 = messageHistoryOne.getAlarmSendTime();
                } else {
                    try {
                        lastTime1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2020-01-01 00:00:00");
                    } catch (ParseException e) {
                        e.printStackTrace();
                    }
                }
                //判断是否满足报警频率，将两个时间转为毫秒
                Long lastTimeLong1 = lastTime1.getTime();
                if (nowDateLong - lastTimeLong1 > Double.parseDouble(alarmRuleLevelConfig.getSmsSendFrequency()) * 60 * 60 * 1000) {
                    List<String> userList = new ArrayList<>();
                    String alarmSmsRecipient = alarmRuleLevelConfig.getAlarmSmsRecipient();
                    //获取需要发送短信的手机号
                    if (StringUtils.isNotBlank(alarmSmsRecipient)) {
                        String[] userArr = alarmSmsRecipient.split(",");
                        for (int i = 0; i < userArr.length; i++) {
                            userList.add(userArr[i]);
                        }
                        QueryWrapper<SysUser> sysUserQueryWrapper = new QueryWrapper<>();
                        sysUserQueryWrapper.in("id", userList);
                        List<SysUser> sysUserList = sysUserService.list(sysUserQueryWrapper);
                        //获取报警接收人的手机号
                        StringBuilder phoneStringBuilder = new StringBuilder();
                        for (int i = 0; i < sysUserList.size(); i++) {
                            phoneStringBuilder.append(",");
                            String phone1 = sysUserList.get(i).getPhone();
                            if (StringUtils.isNotBlank(phone1)) {
                                phoneStringBuilder.append(phone1);
                                //发送短信
                                HttpSenderMsg.sendMsg(prefix + date + "时" + departName + "采集数据" + content + suffix, phone1);
                                log.info("短信发送成功手机号：" + phone1 + ",内容：" + content);
                            }
                        }
                        String phone = phoneStringBuilder.toString().replaceFirst(",", "");
                        if (StringUtils.isNotBlank(phone)) {
                            //将发送的短信保存到数据库
                            AlarmMessageHistory alarmMessageHistory = new AlarmMessageHistory();
                            alarmMessageHistory.setAlarmSendUser(alarmSmsRecipient);
                            alarmMessageHistory.setAlarmSendPhone(phone);
                            try {
                                alarmMessageHistory.setAlarmSendTime(simpleDateFormat1.parse(date));
                            } catch (ParseException e) {
                                e.printStackTrace();
                            }
                            alarmMessageHistory.setAlarmSendContent(prefix + date + "时" + departName + "采集数据" + content + suffix);
                            alarmMessageHistory.setAlarmSendType("1");
                            alarmMessageHistory.setAlarmParamCode(alarmParamCode);
                            alarmMessageHistory.setAlarmParamName(alarmParamName);
                            alarmMessageHistory.setAlarmRuleLevelId(alarmRuleLevelConfigId);
                            alarmMessageHistory.setAlarmRuleType(alarmRuleType);
                            alarmMessageHistory.setAlarmParamUpperLimit(maxValue.toString());
                            alarmMessageHistory.setAlarmParamLowerLimit(minValue.toString());
                            alarmMessageHistory.setAlarmParamUnit(alarmRuleAndAlarmRuleLevelVO.getAlarmParamUnit());
                            alarmMessageHistory.setDepartId(departId);
                            alarmMessageHistory.setActualAvgValue(alarmValue.toString());
                            alarmMessageHistoryService.save(alarmMessageHistory);
                        }
                    }
                }
            }
        }
    }
    /**
     * @param businessTable
     * @param flowKey
     * @param candidateUserList
     * @param bussinessId
     * @param alarmRecordHistory
     */
    public void startProcessFlow(String businessTable,String flowKey,List<String> candidateUserList,String bussinessId,AlarmRecordHistory alarmRecordHistory) {
        // 启动流程
        Kv variables = Kv.create().set(ProcessConstant.TASK_VARIABLE_CREATE_USER, "");
        String processDefinitionId = flowBusinessService.getProcessDefinitionLastVersionId(flowKey);
        alarmRecordHistory.setProcessDefinitionId(processDefinitionId);
        BladeFlow flow = flowService.startProcessInstanceById(processDefinitionId, FlowUtil.getBusinessKey(businessTable, String.valueOf(bussinessId)), variables);
        if (Func.isNotEmpty(flow)) {
            log.debug("流程已启动,流程ID: " + flow.getProcessInstanceId());
            //动态添加下一节点候选用户
            if(candidateUserList!=null&&candidateUserList.size()>0) {
            	//获取当前活动任务
                TaskEntity taskEntity=(TaskEntity)taskService.createTaskQuery().processInstanceId(flow.getProcessInstanceId()).singleResult();
                String taskId = taskEntity.getId();
                ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
                //获取当前结点审批人  考虑到有多个审批人的情况  需要先查询出所有的审批人   所以涉及到identityLink
                List<String> userIds = processEngine.getTaskService().getIdentityLinksForTask(taskId).stream().map(IdentityLink::getUserId).distinct().collect(Collectors.toList());
                //删除identityLink中的用户关系
                for (String userId : userIds) {
                    taskService.deleteUserIdentityLink(taskId, userId, IdentityLinkType.CANDIDATE);
                }
                //清空task中的assignee
                taskService.unclaim(taskId);
                //当前节点审核人列表 清空申请人
                userIds = new ArrayList<>();
                //当前节点审核人列表 追加流转人
                userIds.addAll(candidateUserList);
                //给当前任务节点分配审核人
                for (String userId : userIds) {
                	taskService.addCandidateUser(taskId, "taskUser_"+userId);
                }
                //工单消息推送

                if (userIds != null && userIds.size() > 0) {
                    List<String> userCidList = new ArrayList<>();
                    userCidList = sysUserService.getCidByUserIds(String.join(",", userIds));

                    //获取用户列表后做消息推送
                    MessageEntity messageEntity = new MessageEntity();
                    messageEntity.setMessageTitle("流程审批消息");
                    messageEntity.setMessageBody("您有一条" + alarmRecordHistory.getAlarmWorkName() + "待审批，请及时处理");
                    messageEntity.setReceiveUser(userIds);
                    messageEntity.setReceiveUserCid(userCidList);
                    messageEntity.setSendUser("系统");
                    messageEntity.setForwardTag("todo");
                    IPushService appPushService = PushMessageFactory.getPushService("MOB");
                    IPushService webPushService = PushMessageFactory.getPushService("WEB");
                    appPushService.pushMessage(messageEntity);
                    webPushService.pushMessage(messageEntity);
                }

            }
            //返回流程id写入leave
            alarmRecordHistory.setProcessInstanceId(flow.getProcessInstanceId());
            alarmRecordHistoryService.saveOrUpdate(alarmRecordHistory);
            log.debug("流程发起成功");
        } else {
        	log.debug("流程发起失败");
        }
    }

    
    /**
     * 判断当前时间是否在[startTime, endTime]区间，注意时间格式要一致
     *
     * @param nowTime   当前时间
     * @param startTime 开始时间
     * @param endTime   结束时间
     * @return
     * @author xiechao
     */
    public static boolean isEffectiveDate(Date nowTime, Date startTime, Date endTime) {
        if (nowTime.getTime() == startTime.getTime()
                || nowTime.getTime() == endTime.getTime()) {
            return true;
        }
        Calendar date = Calendar.getInstance();
        date.setTime(nowTime);
        Calendar begin = Calendar.getInstance();
        begin.setTime(startTime);
        Calendar end = Calendar.getInstance();
        end.setTime(endTime);
        if (date.after(begin) && date.before(end)) {
            return true;
        } else {
            return false;
        }
    }
    /**
     * @return void
     * @Description 处理质量报警
     * @Date 2021-09-01 17:25
     * @Param [alarmRuleAndAlarmRuleLevelVO]
     **/
    private void dealZLData(AlarmRuleConfigAndLevelVO alarmRuleAndAlarmRuleLevelVO) {
    	//获取无效数据报警类别
    	QueryWrapper<AlarmRuleConfigPublicTab> alarmRuleConfigPublicTabQueryWrapper = new QueryWrapper<AlarmRuleConfigPublicTab>();
    	alarmRuleConfigPublicTabQueryWrapper.eq("java_bean_tag", "invalidDataAlarmJob");
    	AlarmRuleConfigPublicTab alarmRuleConfigPublicTab = alarmRuleConfigPublicTabService.getOne(alarmRuleConfigPublicTabQueryWrapper);
        //获取设备信号报警方案规则类别
        QueryWrapper<AlarmCustomRuleRepository> alarmRuleConfigQueryWrapper = new QueryWrapper<AlarmCustomRuleRepository>();
        alarmRuleConfigQueryWrapper.eq("bean_service_name", "invalidDataAlarmJob");
        AlarmCustomRuleRepository alarmCustomRuleRepository = alarmCustomRuleRepositoryService.getOne(alarmRuleConfigQueryWrapper);
        //报警方案规则类别
        String alarmCustomRuleTypeTreepath = alarmCustomRuleRepository.getAlarmRuleTypeTreepath();
        //报警方案规则id
        String alarmRepositoryId = alarmCustomRuleRepository.getId();
    	//获取无效数据报警方案规则类别
    	
        DecimalFormat df = new DecimalFormat("#.##");
        String date = DateUtils.getDate("yyyy-MM-dd HH:mm:ss");
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:mm");
        SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //查询质量报警配置
        String departId = alarmRuleAndAlarmRuleLevelVO.getDepartId();
        QueryWrapper<AlarmRuleLevelConfigTemplate> alarmRuleLevelConfigTemplateQueryWrapper = new QueryWrapper<>();
        alarmRuleLevelConfigTemplateQueryWrapper.eq("depart_id", departId);
        alarmRuleLevelConfigTemplateQueryWrapper.eq("alarm_template_type", "C001C001");
        
        AlarmRuleLevelConfigTemplate alarmRuleLevelConfigTemplate = alarmRuleLevelConfigTemplateService.getOne(alarmRuleLevelConfigTemplateQueryWrapper);
        Double alarmValue = alarmRuleAndAlarmRuleLevelVO.getValue();
        Double minValue = Double.parseDouble(alarmRuleAndAlarmRuleLevelVO.getEffectiveLowerLimit());
        Double maxValue = Double.parseDouble(alarmRuleAndAlarmRuleLevelVO.getEffectiveUpperLimit());
        String alarmParamCode = alarmRuleAndAlarmRuleLevelVO.getAlarmProgramCode();
        String alarmParamName = alarmRuleAndAlarmRuleLevelVO.getAlarmParamName();
        String content = "";
        String departName = departNameTemplete.replace("${departName}", alarmRuleAndAlarmRuleLevelVO.getDepartName());
        String unit = "";
        if (alarmRuleAndAlarmRuleLevelVO.getAlarmParamUnit() != null) {
            unit = alarmRuleAndAlarmRuleLevelVO.getAlarmParamUnit();
        }
        if (alarmValue > maxValue) {
            //最大值超标
            content = contentTemplete.replace("${alarmParamName}", alarmParamName)
                    .replace("${actualAvgValue}", alarmValue.doubleValue() + "")
                    .replace("${limit}", ">" + maxValue)
                    .replace("${alarmParamUnit}", unit);
            content = content +"大于上限";
        } else {
            //最小值超标
            content = contentTemplete.replace("${alarmParamName}", alarmParamName)
                    .replace("${actualAvgValue}", alarmValue.doubleValue() + "")
                    .replace("${limit}", "<" + minValue)
                    .replace("${alarmParamUnit}", unit);
            content = content +"小于下限";
        }
        //查询短信上一条报警是否处理，未处理就不新增报警记录
        //TODO 先从数据库中获取，后期优化放redis中
        QueryWrapper<AlarmRecordHistory> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("depart_id", departId);
        queryWrapper.eq("alarm_param_code", alarmParamCode);
        queryWrapper.eq("alarm_param_type", alarmRuleLevelConfigTemplate.getAlarmTemplateName());
        queryWrapper.eq("alarm_rule_type", alarmRuleLevelConfigTemplate.getAlarmTemplateType());
        queryWrapper.orderByDesc("record_time").last("limit 1");
        AlarmRecordHistory alarmRecordHistoryOne = alarmRecordHistoryService.getOne(queryWrapper);
        //如果没有上条记录或者处理状态(0：未处理，1:已处理)为已处理
        if ((alarmRecordHistoryOne == null || alarmRecordHistoryOne.getHandleStatus() == 1)) {
            AlarmRecordHistory alarmRecordHistory = new AlarmRecordHistory();
            //手动创建UUID，用于报警自动送审
            String uuid = UUID.randomUUID().toString().replaceAll("-", "");
            alarmRecordHistory.setId(uuid);
            alarmRecordHistory.setAlarmParamCode(alarmParamCode);
            alarmRecordHistory.setAlarmParamName(alarmParamName);
            alarmRecordHistory.setAlarmRuleLevelName(alarmRuleLevelConfigTemplate.getAlarmTemplateLevelName());
            alarmRecordHistory.setAlarmRuleType(alarmRuleLevelConfigTemplate.getAlarmTemplateType());
            alarmRecordHistory.setAlarmParamType(alarmRuleLevelConfigTemplate.getAlarmTemplateName());
            try {
                //alarmRecordHistory.setRecordTime(simpleDateFormat1.parse(date));
                alarmRecordHistory.setRecordTime(simpleDateFormat1.parse(alarmRuleAndAlarmRuleLevelVO.getRecordTime()));
            } catch (ParseException e) {
                e.printStackTrace();
            }
            alarmRecordHistory.setAlarmParamUpperLimit(maxValue.toString());
            alarmRecordHistory.setAlarmParamLowerLimit(minValue.toString());
            alarmRecordHistory.setAlarmParamUnit(alarmRuleAndAlarmRuleLevelVO.getAlarmParamUnit());
            alarmRecordHistory.setDepartId(departId);
            alarmRecordHistory.setActualAvgValue(alarmValue.toString());
            alarmRecordHistory.setHandleStatus(0);
            alarmRecordHistory.setDelFlag(1);
            
            //添加报警类别数据
            //向报警规则对象装入报警方案规则类别相关数据
        	String[] alarmCustomRuleTypeTreeArray = alarmCustomRuleTypeTreepath.split(",");
        	//报警类别树
        	String alarmTypeTreePath = alarmRuleConfigPublicTab.getTreePath();
        	String[] treeArray = alarmTypeTreePath.split(",");
            
            alarmRecordHistory.setHandleMethon(alarmRuleAndAlarmRuleLevelVO.getAlarmRecommend());
            alarmRecordHistory.setAlarmRuleTopType(treeArray[0]);
            alarmRecordHistory.setAlarmRuleSecondType(treeArray[1]);
            alarmRecordHistory.setAlarmRuleTypeTreepath(alarmTypeTreePath);
            
            //添加报警方案规则类别数据
            alarmRecordHistory.setAlarmCustomRuleTopType(alarmCustomRuleTypeTreeArray[0]);
            alarmRecordHistory.setAlarmCustomRuleSecondType("");
            alarmRecordHistory.setAlarmCustomRuleType(alarmRepositoryId);
            alarmRecordHistory.setAlarmCustomRuleTypeTreepath(alarmCustomRuleTypeTreepath+","+alarmRepositoryId);
            
            //构造报警指标数据json
            List<Map<String,Object>> indexDataList = new ArrayList<Map<String,Object>>();
            Map<String,Object> indexJsonMap = new HashMap<String,Object>();
            indexJsonMap.put("indexCode", alarmParamCode);
            indexJsonMap.put("indexName", alarmParamName);
            indexJsonMap.put("indexValue", alarmValue.toString());
            indexDataList.add(indexJsonMap);
            alarmRecordHistory.setAlarmCustomIndexJsonData(JSONUtil.toJsonStr(indexDataList));
            
            //${start}采集数据${conent}已超标，请注意！
            alarmRecordHistory.setAlarmContent("采集数据" + content + suffix);
            alarmRecordHistory.setCreateBy("system");
            alarmRecordHistoryService.save(alarmRecordHistory);
            //判断是否需要发送系统通知 (内容跟报警记录信息相同)
            if ("1".equals(alarmRuleLevelConfigTemplate.getIsSendNotice())) {
                if (StringUtils.isNotBlank(alarmRuleLevelConfigTemplate.getAlarmNoticeRecipient())) {
                    SystemNoticeVO systemNoticeVO = new SystemNoticeVO(alarmRuleLevelConfigTemplate.getAlarmNoticeRecipient(),
                            alarmRuleLevelConfigTemplate.getAlarmTemplateLevelName(), "在" + date + "时" + departName + "采集数据" + content + suffix, departId, "6");
                    systemNoticeUtils.dealNoticeMessage(systemNoticeVO);
                }
            }
        }
    }
}