package com.moral.monitor.listener;

import com.moral.monitor.dao.TaskDao;
import com.moral.monitor.entity.*;
import com.moral.monitor.listener.message.*;
import net.sf.json.JSONObject;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageListener;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import javax.annotation.Resource;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;

public class MonitorListener implements MessageListener {
    @Resource
    RabbitTemplate rabbitTemplate;
    @Resource
    TaskDao taskDao;
    private Logger logger = LoggerFactory.getLogger(MonitorListener.class);
    public void onMessage(Message message) {
        String receiveMsg = null;
        try {
            receiveMsg = new String(message.getBody(), "utf-8");
        } catch (UnsupportedEncodingException e) {
            logger.warn(e.getMessage());
        }
        logger.warn(receiveMsg);
        Map<String, String> receiveMsgMap = toMap(receiveMsg);
        String mac = receiveMsgMap.remove("mac");
        String ver = receiveMsgMap.remove("ver");
        String rtime = receiveMsgMap.remove("time");
        String date = getDate();//logger，noticelog使用
        Equipment equipment = taskDao.selectFromequipment(mac);
        if (equipment==null) {
            logger.warn("设备" + mac + "不在设备表中");
            return;
        }
        //设置设备在线状态4
        if (equipment.getState()==0) {
            taskDao.updateequipmentstate(4, mac);
        }
        //eX和传感器的映射关系,根据设备版本号动态产生
        Map<String, String> exsensorMap = exSensortoMap(ver);
        taskDao.insertTologger(mac, receiveMsg, date);
        //获取设备已绑定的传感器
        Map<String, String> bindsensor = macBindSensor(mac);
        if (bindsensor.size()<=0) {
            logger.warn("设备" + mac + "没有绑定任何传感器");
            return;
        }
        //根据绑定传感器产生历史和即时数据
        insertTohistory(receiveMsgMap, mac, exsensorMap, bindsensor);
        updateOrinsertstate(receiveMsgMap, mac, exsensorMap, bindsensor);
        //已绑定传感器且与报警组关联才会返回一个AlarmSensor
        List<AlarmSensor> sensors = taskDao.findAllsensorBymac(mac, ver);
        if (!(sensors.size() > 0)) {
            logger.warn("设备" + mac + "传感器与报警组没有关联");
            return;
        }
        //维护设备报警级别
        List<Integer> level = new ArrayList<Integer>();
        for (AlarmSensor sensor : sensors) {
            if (!(receiveMsgMap.containsKey(sensor.getMac_key()))) {
                logger.warn("设备绑定的传感器" + sensor.getSensor() + "没有接收到对应的数据");
                continue;
            }
            int alarm_type = 0;
            //微信推送用
            int sensor_level = 0;
            String alarm_desc = null;
            double value = Double.parseDouble(receiveMsgMap.get(sensor.getMac_key()));
            String displayvalue = digit(value, sensor.getDigit());
            if (value >= sensor.getFirst()) {
                alarm_type = sensor.getFirst_notice();
                level.add(1);
                alarm_desc = "一级";
                sensor_level =1;
            } else if (value >= sensor.getSecond()) {
                alarm_type = sensor.getSecond_notice();
                level.add(2);
                alarm_desc = "二级";
                sensor_level = 2;
            } else if (value >= sensor.getThird()) {
                alarm_type = sensor.getThird_notice();
                level.add(3);
                alarm_desc = "三级";
                sensor_level = 3;
            }
            if (alarm_desc == null) {
                String sensorname = sensor.getSensor();
                if (sensorname.equals("湿度") || sensorname.equals("温度")) {
                    Double inverse_first = sensor.getInverse_first();
                    Double inverse_second = sensor.getInverse_second();
                    Double inverse_third = sensor.getInverse_third();
                    if (value <= (inverse_first == null?Integer.MIN_VALUE:inverse_first)) {
                        alarm_type = sensor.getFirst_notice();
                        level.add(1);
                        alarm_desc = "一级";
                        sensor_level = 1;
                    } else if (value <= (inverse_second==null?Integer.MIN_VALUE:inverse_second)){
                        alarm_type = sensor.getSecond_notice();
                        level.add(2);
                        alarm_desc = "二级";
                        sensor_level = 2;
                    } else if (value <= (inverse_third==null?Integer.MIN_VALUE:inverse_third)) {
                        alarm_type = sensor.getThird_notice();
                        level.add(3);
                        alarm_desc= "三级";
                        sensor_level=3;
                    }
                }
            }

            Alarmlog alarmlog = taskDao.selectFromalarmlogBysensor(mac, sensor.getSensor());
            //根据alarm_desc判断是否有超标，并更改传感器报警记录表中最近一条的状态
            if (alarm_desc == null) {
                if (alarmlog!=null&&alarmlog.getAlarmstate()!=0) {
                    int id = alarmlog.getId();
                    taskDao.updatealarmlogstate(id);
                }
                logger.warn("设备" + mac + "的" + sensor.getSensor() + "传感器没有超标");
                continue;
            }

            HashMap<String, Integer> alarmstate = new HashMap<String, Integer>();
            alarmstate.put("三级", 3);
            alarmstate.put("二级", 2);
            alarmstate.put("一级", 1);
            //至此传感器超标。但是否要存入传感器此次的报警数据和是否报警看最近一条报警记录的状态字段，且要成功报警要先有报方式和报警用户
            if (alarmlog == null || alarmlog.getAlarmstate() == 0){
                taskDao.insertToalarmlog(mac, sensor.getSensor(), value, alarm_desc, equipment.getAddress(), alarmstate.get(alarm_desc),equipment.getName(),sensor.getUnits());
                String alarmMsg = "{\"mac\":\"" + mac + "\",\"" + sensor.getMac_key() + "\":" + value + ",\"level\":" + sensor_level + "}";
                Tomq tomq = new Tomq(rabbitTemplate, alarmMsg);
                tomq.run();
                //是否有报警方式
                if (alarm_type == 0) {
                    logger.warn("设备" + mac + "的" + sensor.getSensor() + "传感器没有设置报警方式");
                    continue;
                }
                //最终有无关联到用户
                String alarm = sensor.getAlarm();
                //一个报警组对应一个用户组，不需要循环
                List<User> users = taskDao.findAlluserBysensor(alarm);
                if (!(users.size() > 0)) {
                    logger.warn("报警组没有关联接收报警的用户");
                    continue;
                }
                for (User u : users){
                    //保存报警通知和邮件通知使用
                    String alarm_content = equipment.getAddress() + "：" + sensor.getSensor() + "超标！" + alarm_desc + ":" + displayvalue + "" + sensor.getUnits() + "!";
                    if ((alarm_type & 1) > 0){
                        String noticetype = "邮件通知";
                        saveNotice(equipment, u, sensor, alarm_content, noticetype, sensor_level, date);
                        logger.warn("发送邮件报警给" + u.getName() + "用户");
                    }
                    if ((alarm_type & 2) > 0){
                        String noticetype = "微信通知";
                        saveNotice(equipment, u, sensor, alarm_content, noticetype, sensor_level, date);
                        logger.warn("发送微信报警给" + u.getName() + "用户");
                    }
                    if ((alarm_type & 4) > 0){
                        String noticetype = "短信通知";
                        saveNotice(equipment, u, sensor, alarm_content, noticetype, sensor_level, date);
                        logger.warn("发送短信报警给" + u.getName() + "用户");
                    }
                    if ((alarm_type & 8) > 0){
                        String noticetype = "电话通知";
                        saveNotice(equipment, u, sensor, alarm_content, noticetype, sensor_level, date);
                        logger.warn("发送电话报警给" + u.getName() + "用户");
                    }
                }
            }
        }
        //更新设备状态
        if (!(level.size() > 0)) {
            taskDao.updateequipmentstate(4, mac);//用户角度没有报警就是正常
            return;
        }
        Integer maxlevel = Collections.max(level);
        taskDao.updateequipmentstate(maxlevel, mac);
    }

    private String getDate() {
        Date d = new Date();
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return formatter.format(d);
    }

    private void saveNotice(Equipment equipment, User u, AlarmSensor sensor, String alarm_content, String noticetype, int sensor_level, String date) {
        taskDao.insertTonoticelog(u.getId(), u.getName(), noticetype, equipment.getMac(), equipment.getName(), alarm_content, sensor.getSensor(), equipment.getAddress(), sensor_level, date);
    }

    public String digit(double num, int digit) {
        BigDecimal y = new BigDecimal(num);
        double b = y.setScale(digit, BigDecimal.ROUND_HALF_UP).doubleValue();
        double c = b - (int) b;
        if (c == 0) {
            return String.valueOf((int) b);
        } else {
            return String.valueOf(b);
        }
    }

    private void updateOrinsertstate(Map<String, String> receiveMsgMap, String mac, Map<String, String> exsensorMap, Map<String, String> bindsensor) {
        Set<Map.Entry<String, String>> entries = receiveMsgMap.entrySet();
        Iterator<Map.Entry<String, String>> iterator = entries.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, String> next = iterator.next();
            String mac_key = next.getKey();
            String mac_value = next.getValue();
            String sensor = exsensorMap.get(mac_key);
            if (bindsensor.containsKey(sensor)) {
                List<State> states = taskDao.selectFromstate(mac, mac_key);//防止并发时会有多条
                if (states.size() == 0) {
                    taskDao.insertTostate(mac, sensor, mac_key, mac_value);
                } else if (states.size() == 1) {
                    taskDao.updatestate(mac_value, mac, mac_key);
                } else if (states.size() >= 2) {
                    taskDao.deleteFromstateBymacandmackey(mac, mac_key);
                    taskDao.insertTostate(mac, sensor, mac_key, mac_value);
                }
            }
        }
    }

    private void insertTohistory(Map<String, String> receiveMsgMap, String mac, Map<String, String> exsensorMap, Map<String, String> bindsensor) {
        Set<Map.Entry<String, String>> entries = receiveMsgMap.entrySet();
        Iterator<Map.Entry<String, String>> iterator = entries.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, String> next = iterator.next();
            String mac_key = next.getKey();
            String mac_value = next.getValue();
            String sensor = exsensorMap.get(mac_key);
            if (bindsensor.containsKey(sensor)) {
                taskDao.insertTohistory(mac, sensor, mac_key, mac_value);
            }
        }
    }

    private Map<String, String> macBindSensor(String mac) {
        Map<String, String> bindsensor = new LinkedHashMap<String, String>();
        List<AlarmSensor> alarmSensors = taskDao.selectFrommacBymac(mac);
        for (AlarmSensor sensor : alarmSensors) {
            String sensorname = sensor.getSensor();
            if (StringUtils.isNotBlank(sensorname)) {
                bindsensor.put(sensorname, sensorname);
            }
        }
        return bindsensor;
    }

    private Map<String, String> exSensortoMap(String ver) {
        List<Sensor> sensors = taskDao.selectFromsensorByver(ver);
        Map<String, String> ex_sensorMap = new LinkedHashMap<String, String>();
        for (Sensor sensor : sensors) {
            ex_sensorMap.put(sensor.getMac_key(), sensor.getSensor());
        }
        return ex_sensorMap;
    }

    private Map<String, String> toMap(String receiveMsg) {
        Map<String, String> receiveMsgMap = new LinkedHashMap<String, String>();
        JSONObject jsonObject = JSONObject.fromObject(receiveMsg);
        Iterator it = jsonObject.keys();
        while (it.hasNext()) {
            String key = it.next().toString();
            String value = jsonObject.get(key).toString();
            receiveMsgMap.put(key, value);
        }
        return receiveMsgMap;
    }
}