package com.moral.service.impl;

import com.alibaba.fastjson.JSONReader;
import com.alibaba.fastjson.TypeReference;
import com.moral.common.bean.Constants;
import com.moral.common.util.RedisUtils;
import com.moral.entity.MonitorPoint;
import com.moral.entity.alarm.AlarmConfig;
import com.moral.entity.alarm.AlarmConfigValue;
import com.moral.entity.alarm.AlarmMode;
import com.moral.entity.alarm.AlarmSensorLevel;
import com.moral.mapper.AlarmConfigMapper;
import com.moral.service.AlarmConfigService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.session.SessionProperties;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

@Service
public class AlarmConfigServiceImpl implements AlarmConfigService{
    /** 缺省三级警报配置 .*/
    @Value(value = "classpath:system/alarmLevels.json")
    private org.springframework.core.io.Resource resource;
    private static AlarmConfigValue defaultAlarmConfigValue;
    @Autowired
    public AlarmConfigValue getDefaultAlarmConfigValue(){
        if(defaultAlarmConfigValue!=null){
            return defaultAlarmConfigValue;
        }else {
            InputStreamReader reader = null;
            AlarmConfigValue alarmConfigValue = null;
            try {
                reader = new InputStreamReader(resource.getInputStream());
                alarmConfigValue = new JSONReader(reader).readObject(new TypeReference<AlarmConfigValue>() {});
            } catch (IOException e) {
                e.printStackTrace();
            }
            return  alarmConfigValue;
        }
    }
    @Resource
    RedisUtils redisUtils;
    @Resource
    AlarmConfigMapper alarmConfigMapper;
    @Override
    public Optional<AlarmConfig> queryValueByOrganizationId(int organizationId) {
        String key = RedisUtils.getAlarmKey(organizationId);
        AlarmConfigValue alarmConfigValue = redisUtils.get(key,new TypeReference<AlarmConfigValue>(){});
        if(alarmConfigValue==null) {
            AlarmConfig alarmConfig = alarmConfigMapper.selectByOrganizationId(organizationId);
            if (alarmConfig != null && alarmConfig.getValue() != null) {
                return Optional.ofNullable(alarmConfig);
            } else {
                alarmConfigValue = getDefaultAlarmConfigValue();
            }
        }
        AlarmConfig alarmConfigNotWithId = new AlarmConfig();
        alarmConfigNotWithId.setValue(alarmConfigValue);
        return Optional.ofNullable(alarmConfigNotWithId);
    }

    @Override
    public Optional<AlarmConfig> queryByOrganizationId(int organizationId) {
        AlarmConfig alarmConfig = alarmConfigMapper.selectByOrganizationId(organizationId);
        if(alarmConfig==null){
            alarmConfig = new AlarmConfig();
            alarmConfig.setValue(getDefaultAlarmConfigValue());
        }
        return Optional.ofNullable(alarmConfig);
    }

    @Override
    public String getValueByOrganizationId(int organizationId) {
        return alarmConfigMapper.getValueByOrganizationId(organizationId);
    }

    @Override
    public Optional<AlarmConfig> queryByMonitorPointId(int mpId) {
        AlarmConfig alarmConfig = alarmConfigMapper.selectByMonitorPointId(mpId);
        if(alarmConfig==null){
            alarmConfig = new AlarmConfig();
            alarmConfig.setValue(getDefaultAlarmConfigValue());
        }
        return Optional.ofNullable(alarmConfig);
    }

    @Override
    public Optional<AlarmConfig> queryByDeviceMac(String mac) {
        AlarmConfig alarmConfig = alarmConfigMapper.selectByDeviceMac(mac);
        if(alarmConfig==null){
            alarmConfig = new AlarmConfig();
            alarmConfig.setValue(getDefaultAlarmConfigValue());
        }
        return Optional.ofNullable(alarmConfig);
    }

    @Override
    public void addOrModify(AlarmConfig alarmConfig) {
        try{
            if(alarmConfig.getId()==null){
                alarmConfig.setCreateTime(new Date());
                alarmConfig.setUpdateTime(new Date());
                alarmConfigMapper.insertSelective(alarmConfig);
            }else {
                alarmConfig.setUpdateTime(new Date());
                alarmConfigMapper.updateByPrimaryKeySelective(alarmConfig);
            }
            String key = RedisUtils.getAlarmKey(alarmConfig.getOrganizationId());
            redisUtils.set(key,simplifyAlarmConfigValue(alarmConfig.getValue()));
        }
        catch (Exception ex){
            throw  ex;
        }
    }

    @Override
    public int containOrgId(Integer orgId) {
        return alarmConfigMapper.containOrgId(orgId);
    }

    public AlarmConfigValue simplifyAlarmConfigValue(AlarmConfigValue value){
          Map<String,AlarmSensorLevel> alarmSensorLevelMap = value.getAlarmLevels();
          List<String> cleanKeys = new ArrayList<>();
          for(String key:alarmSensorLevelMap.keySet()){
                 AlarmSensorLevel alarmSensorLevel = alarmSensorLevelMap.get(key);
                 if(!alarmSensorLevel.isEnable()){
                     cleanKeys.add(key);
                 }else{
                     List<Float> increments = alarmSensorLevel.getIncrement();
                     if(increments!=null){
                         boolean isIncrement =  increments.size()<3||
                                 (increments.get(0)==0&&increments.get(1)==0&&increments.get(2)==0);
                         if(isIncrement){
                             alarmSensorLevel.setIncrement(null);
                         }
                     }
                     if(alarmSensorLevel.isDegressEnable()){
                         List<Float> degressions = alarmSensorLevel.getDegression();
                         if(degressions!=null){
                             boolean isDegression =  degressions.size()<3||
                                     (degressions.get(0)==0&&degressions.get(1)==0&&degressions.get(2)==0);
                             if(isDegression){
                                 alarmSensorLevel.setDegression(null);
                             }
                         }
                     }else{
                         //未启用反向三级直接置空
                         alarmSensorLevel.setDegression(null);
                     }
                 }
          }
          for (String key:cleanKeys){
              alarmSensorLevelMap.remove(key);
          }
          AlarmMode alarmMode = value.getAlarmMode();
          if(!alarmMode.isEnable()){
              alarmMode.setLevel1(null);
              alarmMode.setLevel2(null);
              alarmMode.setLevel3(null);
          }else{
              if(alarmMode.getLevel1()!=null&&alarmMode.getLevel1().isEmpty()){
                  alarmMode.setLevel1(null);
              }
              if(alarmMode.getLevel2()!=null&&alarmMode.getLevel2().isEmpty()){
                  alarmMode.setLevel2(null);
              }
              if(alarmMode.getLevel3()!=null&&alarmMode.getLevel3().isEmpty()){
                  alarmMode.setLevel3(null);
              }
          }
          return value;
    }
}