package com.casic.service.impl;

import com.alibaba.druid.util.StringUtils;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.casic.dao.AlarmMapper;
import com.casic.dao.BusConfigMapper;
import com.casic.model.*;
import com.casic.service.AlarmService;
import com.casic.util.DeviceDataTableEnum;
import com.casic.util.RedisCommonUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.dao.DataAccessException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Slf4j
@Service
public class AlarmServiceImple extends ServiceImpl<AlarmMapper, AlarmLevel> implements AlarmService {

    @Resource
    private BusConfigMapper busConfigMapper;
    @Resource
    private RedisCommonUtil redisCommonUtil;

    public Object getAlarmRecord(String deviceType, Integer currentIndex, Integer pageSize, String devcode) {
        ResponseData responseData = new ResponseData();
        try {
            Map<String, Object> page = new HashMap();
            page.put("total", this.baseMapper.getAlarmTotalRecord(deviceType, devcode));
            List<Map<String, Object>> alarmRecordList = this.baseMapper.getAlarmRecord(deviceType, devcode, pageSize * (currentIndex - 1), pageSize);
            page.put("rows", alarmRecordList);
            responseData.setData(page);
            responseData.setMessage(ResponseData.DEFAULT_SUCCESS_MESSAGE);
            responseData.setCode(ResponseData.DEFAULT_SUCCESS_CODE);
        } catch (DataAccessException dae) {
            log.error("设备数据查询异常，设备类型{},异常信息{}", deviceType, dae.getMessage());
            responseData.setMessage(ResponseData.DEFAULT_ERROR_MESSAGE);
            responseData.setCode(ResponseData.DEFAULT_ERROR_CODE);
        }
        return responseData;
    }

    @Transactional
    public Object excuteAlramBatchCancel(String deviceType, String devcode) {
        ResponseData responseData = new ResponseData();
        try {
            this.baseMapper.excuteAlramBatchCancel(deviceType, devcode);
            this.baseMapper.excuteJobBatchCancel(deviceType, devcode);
            responseData.setMessage(ResponseData.DEFAULT_SUCCESS_MESSAGE);
            responseData.setCode(ResponseData.DEFAULT_SUCCESS_CODE);
        } catch (DataAccessException dae) {
            log.error("批量消警异常，设备类型{},异常信息{}", deviceType, dae.getMessage());
            responseData.setMessage(ResponseData.DEFAULT_ERROR_MESSAGE);
            responseData.setCode(ResponseData.DEFAULT_ERROR_CODE);
        }
        return responseData;
    }


    @Transactional
    public Object addAlarmConfig(AlarmConfigParam alarmConfigParam) {
        ResponseData responseData = new ResponseData();
        try {
            responseData.setMessage(ResponseData.DEFAULT_SUCCESS_MESSAGE);
            addBusConfig(alarmConfigParam);
            addRuleConfig(alarmConfigParam);
            responseData.setCode(ResponseData.DEFAULT_SUCCESS_CODE);
        } catch (DataAccessException dae) {
            log.error("风险配置异常,异常信息{}", dae.getMessage());
            responseData.setMessage(ResponseData.DEFAULT_ERROR_MESSAGE);
            responseData.setCode(ResponseData.DEFAULT_ERROR_CODE);
        }
        return responseData;
    }

    private void addRuleConfig(AlarmConfigParam alarmConfigParam) {
        Map alarmRuleMap = new HashMap();
        alarmRuleMap.put("DEVICE_TYPE", alarmConfigParam.getDeviceType());
        this.baseMapper.deleteByMap(alarmRuleMap);
        AlarmLevel alarmRule = new AlarmLevel();
        DeviceDataTableEnum deviceDataTableEnum = DeviceDataTableEnum.DEVICE_TYPE_TABLE.getTableNameMap()
                .get(Integer.valueOf(alarmConfigParam.getDeviceType()));
        alarmRule.setName(deviceDataTableEnum.getTypeName());
        alarmRule.setHighValue(Float.valueOf(alarmConfigParam.getThresholdVol()));
        alarmRule.setTs(new Date());
        alarmRule.setLevel(1);
        alarmRule.setDeviceType(alarmConfigParam.getDeviceType());
        this.baseMapper.insert(alarmRule);
    }

    private void addBusConfig(AlarmConfigParam alarmConfigParam) {
        String devcode = StringUtils.isEmpty(alarmConfigParam.getDevcode()) ? this.baseMapper.getDeviceDevcode(alarmConfigParam.getDeviceType()) : alarmConfigParam.getDevcode();
        sendBusConfig(alarmConfigParam, devcode);
        String devcideId = this.baseMapper.getDeviceByDevcode(alarmConfigParam.getDeviceType(), devcode);
        BusConfig busConfig = new BusConfig();
        busConfig.setDeviceId(devcideId);
        busConfig.setFramecontent("3," + alarmConfigParam.getCollectInterval() + "," + alarmConfigParam.getCollectInterval() +
                "," + alarmConfigParam.getRetryNum() + "," + alarmConfigParam.getIp() + "," + alarmConfigParam.getPort());
        busConfig.setSensorid("");
        busConfig.setStatus("0");
        busConfig.setAttemptscurrent(0);
        busConfig.setWritetime(new Date());
        busConfig.setAttemptsmax(3);
        busConfigMapper.insert(busConfig);
    }

    private void sendBusConfig(AlarmConfigParam alarmConfigParam, String devcode) {
        CommConfigDTO commConfigDTO = new CommConfigDTO();
        commConfigDTO.setInterval(StringUtils.isEmpty(alarmConfigParam.getCollectInterval()) ? 300 : Long.valueOf(alarmConfigParam.getCollectInterval()));
        commConfigDTO.setRepeat(StringUtils.isEmpty(alarmConfigParam.getRetryNum()) ? 300 : Long.valueOf(alarmConfigParam.getRetryNum()));
        commConfigDTO.setTimes(Long.valueOf(1));
//        commConfigDTO.setIp(alarmConfigParam.getIp());
//        commConfigDTO.setPort(StringUtils.isEmpty(alarmConfigParam.getPort()) ? 8080 : Long.valueOf(alarmConfigParam.getPort()));
        commConfigDTO.setPeriod(StringUtils.isEmpty(alarmConfigParam.getUploadCycle()) ? 300 : Long.valueOf(alarmConfigParam.getUploadCycle()));
//        commConfigDTO.setThresh();
        commConfigDTO.setThresh(StringUtils.isEmpty(alarmConfigParam.getThresholdVol()) ? 50: Float.valueOf(alarmConfigParam.getThresholdVol()));
        redisCommonUtil.send(commConfigDTO, devcode);
    }


}