package org.flume.alarm.resp;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.flume.alarm.AlarmEnumDTO.NoiseAlarmEnum;
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 NoiseResponse 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();
        NoiseManager noiseManager = ac.getBean(NoiseManager.class);
        AlarmRuleManager alarmRuleManager = ac.getBean(AlarmRuleManager.class);
        final AlarmRecordManager alarmRecordManager = ac.getBean(AlarmRecordManager.class);
        DeviceManager deviceManager = ac.getBean(DeviceManager.class);
        DeviceConfigManager deviceConfigManager = ac.getBean(DeviceConfigManager.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();
            String pci = null != jsonObject.get("pci") ? jsonObject.get("pci").toString() : "";
            String rsrp = null != jsonObject.get("rsrp") ? jsonObject.get("rsrp").toString() : "";
            String snr = null != jsonObject.get("snr") ? jsonObject.get("snr").toString() : "";
            JSONArray jsonArray = (JSONArray) jsonObject.get("datas");
            for (int i = 0; i < jsonArray.size(); i++) {
                try {
                    final String val = ((JSONObject) jsonArray.get(i)).get("noiseVal").toString();
                    final String freq = ((JSONObject) jsonArray.get(i)).get("noiseFreq").toString();
                    final String upTime = ((JSONObject) jsonArray.get(i)).get("uptime").toString();
                    noiseManager.saveData(devCode, cell, upTime, freq, val, pci, rsrp, snr);//存采集数据

                    //消除设备异常
                    if (i < jsonArray.size() - 1) continue;
                    alarmRecordManager.cancelDeviceAlarm(devCode);
                    alarmRecordManager.deleteByDevcode(devCode);

                    String thresh = alarmRuleManager.getRuleStr(devCode, DeviceTypeEnum.Noise.toString());//获取报警阈值
                    if (StringUtils.isNotBlank(thresh) &&
                            Float.valueOf(val) > Float.valueOf(thresh)) {

                        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.Noise.toString(), val + "," + freq,
                                String.valueOf(NoiseAlarmEnum.OVER_THRESH.getIndex()), "0");

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

                            //下面推送报警事件至业务中台
                            sendUtils.sendDataCenter(devCode, DeviceTypeEnum.Noise.toString(), "RJ0104",
                                    "RJ010424", NoiseAlarmEnum.OVER_THRESH.toString());
                            //推送事件至物联网平台
                            sendUtils.sendAlarmMqRocket(NoiseAlarmEnum.OVER_THRESH.toString(),
                                    "Noise_" + NoiseAlarmEnum.OVER_THRESH.name(),
                                    freq,
                                    devCode,
                                    NoiseAlarmEnum.OVER_THRESH.toString());

                            // 推送至短信报警
                            Device device = deviceManager.getDeviceByDevCode(devCode, DeviceTypeEnum.Noise.toString());
                            if (null == device || StringUtils.isBlank(device.getInstallPosition())) return;
                            JSONObject eventObj = new JSONObject();
                            eventObj.put("type", "管线漏损报警");
                            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.Noise.toString()));
                                paramMap.put("noiseVal", val);
                                paramMap.put("noiseFreq", freq);
                                dataMap.put("paras", paramMap);
                                DeviceUtilDTO.sendDataMsg(Configure.getProperty("reportInfoURL"),
                                        new DeviceUtilDTO("", "false", "updata", "alarm", "", "",
                                                DateUtils.sdf4.format(new Date()), dataMap, devCode,
                                                DeviceTypeEnum.Noise.toString()));

                            }
                        };
                        newScheduledThreadPool.schedule(task, 100, TimeUnit.MILLISECONDS);
                    }

                    sendUtils.sendStatusMqRocket(devCode, DeviceTypeEnum.Noise.toString());
                    PublicUtilDTO.sendNoiseBusiness(devCode,
                            DeviceTypeEnum.Noise.toString(),
                            "",
                            val,
                            DateUtils.DateFormat(upTime));
                    //测试可信设备基础信息上链
//                    String businessNumber = System.currentTimeMillis()+"";
//                    PublicUtilDTO.sendAddDeviceBusiness(devCode, DeviceTypeEnum.Noise.toString(), "桃花路",
//                            "114.894087714699", "25.8174505796034",businessNumber);
//                    PublicUtilDTO.sendDeleteDeviceBusiness(devCode,businessNumber);

                } 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.Noise.toString(), "",
                            String.valueOf(NoiseAlarmEnum.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.Noise.name().equals(json.get("devType"))) {
                    if ("NoiseConfigSuccess".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 + "，更新参数下发状态失败-------");
            }
        }

    }
}