package org.flume.alarm.resp;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.flume.alarm.AlarmEnumDTO.MethaneAlarmEnum;
import org.flume.alarm.base.AbstractResponse;
import org.flume.alarm.base.DeviceTypeEnum;
import org.flume.alarm.core.util.DateUtils;
import org.flume.alarm.core.util.StringUtils;
import org.flume.alarm.domain.Device;
import org.flume.alarm.manager.*;
import org.flume.alarm.restful.DeviceUtilDTO;
import org.flume.alarm.restful.PublicUtilDTO;
import org.flume.alarm.restful.SendUtils;
import org.flume.alarm.util.Configure;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * Created by lenovo on 2018/1/9.
 */
public class MethaneResponse extends AbstractResponse {

    private final Logger logger = LoggerFactory.getLogger(this.getClass().getName());
    private static final String[] mType = {"Data", "Event", "SetResponse", "GetResponse", "StartupRequest"};

    @Override
    public void process(String content) {
        ClassPathXmlApplicationContext ac = this.getAc();
        MethaneManager methaneManager = ac.getBean(MethaneManager.class);
        AlarmRuleManager alarmRuleManager = ac.getBean(AlarmRuleManager.class);
        final AlarmRecordManager alarmRecordManager = ac.getBean(AlarmRecordManager.class);
        DeviceConfigManager deviceConfigManager = ac.getBean(DeviceConfigManager.class);
        DeviceManager deviceManager = ac.getBean(DeviceManager.class);
        ImeiManager imeiManager = ac.getBean(ImeiManager.class);
        SendUtils sendUtils = ac.getBean(SendUtils.class);
        JSONObject json = JSONObject.fromObject(content);
        final String devCode = json.get("devCode").toString();
        logger.info("--------RECEIVE:设备编号：" + devCode + "，上传数据：" + json.toString() + "-------");
        JSONObject jsonObject = (JSONObject) json.get("mBody");
        if (mType[0].equals(json.get("mType")) || mType[3].equals(json.get("mType"))) {//存储上报数据
            String cell = jsonObject.get("cell").toString();
            JSONArray jsonArray = (JSONArray) jsonObject.get("datas");
            for (int i = 0; i < jsonArray.size(); i++) {
                try {
                    final String gas = ((JSONObject) jsonArray.get(i)).get("gas").toString();
                    final String upTime = ((JSONObject) jsonArray.get(i)).get("uptime").toString();
                    methaneManager.saveData(devCode, gas, cell, upTime);//存采集数据

                    //消除设备异常
                    if (i < jsonArray.size() - 1) continue;
                    alarmRecordManager.cancelDeviceAlarm(devCode);
                    alarmRecordManager.deleteByDevcode(devCode);
                    String thresh = alarmRuleManager.getRuleStr(devCode, DeviceTypeEnum.Methane.toString());//获取报警阈值
                    if (Float.valueOf(gas) > Float.valueOf(thresh.split(",")[1])) {

                        int count = alarmRecordManager.isAlarm(devCode);
                        //消除历史告警
                        if (count == 0) {
                            alarmRecordManager.cancelAlarm(devCode);
                        }
                        if (count >= Integer.valueOf(Configure.getProperty("alarmCount", "3")).intValue()) continue;

                        alarmRecordManager.saveData(devCode, DeviceTypeEnum.Methane.toString(), gas,
                                String.valueOf(MethaneAlarmEnum.OVER_THRESH.getIndex()), "0");

                        if (count == Integer.valueOf(Configure.getProperty("alarmCount", "3")).intValue() - 1) {

                            //下面推送报警事件至业务中台
                            sendUtils.sendDataCenter(devCode, DeviceTypeEnum.Methane.toString(), "RJ0104",
                                    "RJ010419", MethaneAlarmEnum.OVER_THRESH.toString());
                            //推送事件至物联网平台
                            sendUtils.sendAlarmMqRocket(MethaneAlarmEnum.OVER_THRESH.toString(),
                                    "Methane_" + MethaneAlarmEnum.OVER_THRESH.name(),
                                    gas,
                                    devCode,
                                    DeviceTypeEnum.Methane.toString());

                            // 通过短信发送报警消息
                            Device device = deviceManager.getDeviceByDevCode(devCode, DeviceTypeEnum.Methane.toString());
                            if (null == device || StringUtils.isBlank(device.getInstallPosition())) return;
                            JSONObject eventObj = new JSONObject();
                            eventObj.put("type", MethaneAlarmEnum.OVER_THRESH.toString() + "报警");
                            eventObj.put("value", "浓度值为" + gas + "LEL%");
                            sendUtils.sendEventBySms(device, eventObj);
                        }
                    }
                    /***
                     * 下面推送采集数据
                     */

                    if ("true".equals(Configure.getProperty("synchronize.enabled", "false"))) {
                        ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(1);
                        TimerTask task = new TimerTask() {
                            @Override
                            public void run() {

                                Map<String, Object> dataMap = new HashMap<String, Object>();
                                Map<String, Object> paramMap = new HashMap<String, Object>();
                                dataMap.put("serviceId", DeviceUtilDTO.devTypeCodeMap.
                                        get(DeviceTypeEnum.Methane.toString()));
                                paramMap.put("gas", gas);
                                dataMap.put("paras", paramMap);
                                DeviceUtilDTO.sendDataMsg(Configure.getProperty("reportInfoURL"),
                                        new DeviceUtilDTO("", "false", "updata", "alarm", "", "",
                                                DateUtils.sdf4.format(new Date()), dataMap, devCode,
                                                DeviceTypeEnum.Methane.toString()));

                            }
                        };
                        newScheduledThreadPool.schedule(task, 100, TimeUnit.MILLISECONDS);
                    }
                    sendUtils.sendStatusMqRocket(devCode, DeviceTypeEnum.Methane.toString());

                    //采集数据上链
                    PublicUtilDTO.sendMethaneBusiness(devCode,
                            DeviceTypeEnum.Methane.toString(),
                            "",
                            gas,
                            DateUtils.DateFormat(upTime));

                } catch (IOException e) {
                    e.printStackTrace();
                    logger.error("--------ERROR:设备编号：" + devCode + "，存储数据：" + jsonArray.get(i).toString() + "失败-------");
                }
            }
        } else if (mType[1].equals(json.get("mType"))) {//存储报警事件
            JSONArray jsonArray = (JSONArray) jsonObject.get("eventType");
            for (int i = 0; i < jsonArray.size(); i++) {
                try {
                    alarmRecordManager.saveData(devCode, DeviceTypeEnum.Methane.toString(), "",
                            String.valueOf(MethaneAlarmEnum.valueOf(jsonArray.get(i).toString()).getIndex()), "1");
                } catch (IOException e) {
                    e.printStackTrace();
                    logger.error("--------ERROR:设备编号：" + devCode + "，存储报警数据：" + jsonArray.get(i).toString() + "失败-------");
                }
            }
        } else if (mType[2].equals(json.get("mType"))) {//更新下发参数状态
            try {
                if (DeviceTypeEnum.Methane.name().equals(json.get("devType"))) {
                    if ("MethaneConfigSuccess".equals(jsonObject.get("bType"))) {
                        deviceConfigManager.updateStatus(devCode);
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
                logger.error("--------ERROR:设备编号：" + devCode + "，更新参数下发状态失败-------");
            }
        } else if (mType[4].equals(json.get("mType"))) {//三码存储
            try {
                String imei = jsonObject.get("imei").toString();
                String iccid = jsonObject.get("iccid").toString();
                imeiManager.saveData(devCode, imei, iccid);
            } catch (Exception e) {
                e.printStackTrace();
                logger.error("--------ERROR:设备编号：" + devCode + "，更新参数下发状态失败-------");
            }
        }
    }
}