package com.moral.monitor.listener;

import com.moral.monitor.dao.TaskDao;
import com.moral.monitor.entity.*;
import com.moral.monitor.listener.message.Tomq;
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 Listener implements MessageListener {

    @Resource
    RabbitTemplate rabbitTemplate;

    @Resource
    TaskDao taskDao;

    private Logger logger = LoggerFactory.getLogger(Listener.class);

    public void onMessage(Message message) {

        logger.warn("正在运行的线程名称=" + Thread.currentThread().getName());

        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 win = receiveMsgMap.remove("win");
        removeNotNumber(receiveMsgMap);
        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;
        }else {
            removeNotBind(receiveMsgMap,exsensorMap,bindsensor);
        }

        //为绑定传感器产生历史和即时数据
        List<State> states = taskDao.findstateBymac(mac);
        updateOrinsertstate(receiveMsgMap, mac, exsensorMap);
        if (states.size()==0){
            insertTohistory(receiveMsgMap, mac, exsensorMap);
        } else {
            insertTohistoryDistinct(receiveMsgMap,mac,exsensorMap,states);
        }

        //查找临界值表
        List<Critical> criticals = taskDao.findcritical();
        LinkedHashMap<String, Critical> sensor_criticals = new LinkedHashMap<String, Critical>();
        for (Critical c:criticals){
            String sensor = c.getSensor();
            sensor_criticals.put(sensor,c);
        }

        //查找此设备已绑定的传感器，超标判断
        //维护设备报警级别
        List<Integer> level = new ArrayList<Integer>();
        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);
            double value =Double.parseDouble(mac_value);
            //取出此传感器的 临界值对象
            Critical critical = sensor_criticals.get(sensor);

            int sensor_level = 0;
            if (value >= critical.getFirst()) {
                level.add(1);
                sensor_level =1;
            } else if (value >= critical.getSecond()) {
                level.add(2);
                sensor_level = 2;
            } else if (value >= critical.getThird()) {
                level.add(3);
                sensor_level = 3;
            }

            if(sensor_level!=0){
                String alarmMsg = "{\"mac\":\"" + mac + "\",\"" +mac_key + "\":" + value + ",\"level\":" + sensor_level + "}";
                Tomq tomq = new Tomq(rabbitTemplate, alarmMsg);
                tomq.run();
            }

        }

        //更新设备状态
        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) {
        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);
                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 insertTohistoryDistinct(Map<String, String> receiveMsgMap, String mac, Map<String, String> exsensorMap,List<State> states){
        LinkedHashMap<String, Double> state_kv = new LinkedHashMap<String, Double>();
        for(State s:states){
            state_kv.put(s.getMac_key(),s.getMac_value());
        }
        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();
            double value =Double.parseDouble(mac_value);
            String  sensor = exsensorMap.get(mac_key);
            Double statevalue = state_kv.get(mac_key);
                if(value!=statevalue){
                    taskDao.insertTohistory(mac, sensor, mac_key,mac_value);
                }
        }


    }



    private void insertTohistory(Map<String, String> receiveMsgMap, String mac, Map<String, String> exsensorMap) {
        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);
            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);//value没用到
            }
        }
        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.getMacKey(), sensor.getSensor());
        }
        return ex_sensorMap;
    }




    private  void removeNotBind(Map<String, String> receiveMsgMap,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 sensor = exsensorMap.get(mac_key);
            if(!bindsensor.containsKey(sensor)){
                iterator.remove();
            }
        }
    }


      private  void removeNotNumber(Map<String, String> receiveMsgMap){
          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_value = next.getValue();
              boolean str2Num = isStr2Num(mac_value);
              if (!str2Num) {
                  iterator.remove();
              }
          }
      }


    private boolean  isStr2Num(String str) {
        try {
            Double.parseDouble(str);
            return true;
        } catch (NumberFormatException e) {
            return false;
        }
    }


    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;
    }

}