package com.wgcloud.service;

import cn.hutool.core.collection.CollectionUtil;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.wgcloud.dto.SubtitleDto;
import com.wgcloud.entity.SnmpInfo;
import com.wgcloud.entity.SnmpState;
import com.wgcloud.mapper.SnmpStateMapper;
import com.wgcloud.util.FormatUtil;
import com.wgcloud.util.UUIDUtil;
import com.wgcloud.util.staticvar.StaticKeys;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.ui.Model;

import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * @version v3.3
 * @ClassName:SnmpStateService.java
 * @author: http://www.wgstart.com
 * @date: 2022年4月10日
 * @Description: SnmpStateService.java
 * @Copyright: 2019-2021 wgcloud. All rights reserved.
 */
@Service
public class SnmpStateService {

    public PageInfo selectByParams(Map<String, Object> params, int currPage, int pageSize) throws Exception {
        PageHelper.startPage(currPage, pageSize);
        List<SnmpState> list = snmpStateMapper.selectByParams(params);
        PageInfo<SnmpState> pageInfo = new PageInfo<SnmpState>(list);
        return pageInfo;
    }

    public void save(SnmpState SnmpState) throws Exception {
        SnmpState.setId(UUIDUtil.getUUID());
        SnmpState.setCreateTime(new Date());
        snmpStateMapper.save(SnmpState);
    }

    public void saveRecord(List<SnmpState> recordList) throws Exception {
        if (recordList.size() < 1) {
            return;
        }
        for (SnmpState as : recordList) {
            as.setId(UUIDUtil.getUUID());
        }
        snmpStateMapper.insertList(recordList);
    }

    public int deleteById(String[] id) throws Exception {
        return snmpStateMapper.deleteById(id);
    }

    public SnmpState selectById(String id) throws Exception {
        return snmpStateMapper.selectById(id);
    }

    public List<SnmpState> selectAllByParams(Map<String, Object> params) throws Exception {
        return snmpStateMapper.selectAllByParams(params);
    }

    public int deleteByDate(Map<String, Object> map) throws Exception {
        return snmpStateMapper.deleteByDate(map);
    }

    /**
     * 设置图表的副标题，进出口流量的最高、平均、最低值
     * 图表处理，查找最大值，并把进出口流量单位转为MB
     *
     * @param model
     * @param snmpStateList 数据列表
     */
    public void setSubtitle(Model model, List<SnmpState> snmpStateList, SnmpInfo snmpInfo) {
        //图表属性max
        double maxval = 0;

        //下行端口入平均流量最高
        Double maxRxbyt = 0d;
        //下行端口入平均流量平均
        Double avgRxbyt = 0d;
        //下行端口入平均流量最低
        Double minRxbyt = 99999d;
        Double sumRxbyt = 0d;

        //上行端口出平均流量最高
        Double maxSent = 0d;
        //上行端口出平均流量最低
        Double minSent = 99999d;
        //上行端口出平均流量平均
        Double avgSent = 0d;
        Double sumSent = 0d;

        //cpu使用率最高
        Double maxCpuPer = 0d;
        //cpu使用率最低
        Double minCpuPer = 99999d;
        //cpu使用率平均
        Double avgCpuPer = 0d;
        Double sumCpuPer = 0d;

        //内存使用率最高
        Double maxMemSize = 0d;
        //内存使用率最低
        Double minMemSize = 99999d;
        //内存使用率平均
        Double avgMemSize = 0d;
        Double sumMemSize = 0d;

        Double recvAvgTmp = 0d;
        Double sentAvgTmp = 0d;
        Double cpuPerTmp = 0d;
        Double memSizeTmp = 0d;
        if (!CollectionUtil.isEmpty(snmpStateList)) {
            for (SnmpState snmpState : snmpStateList) {
                recvAvgTmp = snmpState.getRecvAvgDouble();
                sentAvgTmp = snmpState.getSentAvgDouble();
                //转为MB begin
                if (StaticKeys.BYTES_STR.equals(snmpInfo.getSnmpUnit())) {
                    //单位是byte
                    recvAvgTmp = recvAvgTmp / 1024 / 1024;
                    sentAvgTmp = sentAvgTmp / 1024 / 1024;
                } else {
                    //单位是KB
                    recvAvgTmp = recvAvgTmp / 1024;
                    sentAvgTmp = sentAvgTmp / 1024;
                }
                //转为MB end
                sentAvgTmp = FormatUtil.formatDouble(sentAvgTmp, 2);
                recvAvgTmp = FormatUtil.formatDouble(recvAvgTmp, 2);
                snmpState.setSentAvg(String.valueOf(sentAvgTmp));
                snmpState.setRecvAvg(String.valueOf(recvAvgTmp));
                if (null != recvAvgTmp) {
                    if (recvAvgTmp > maxRxbyt) {
                        maxRxbyt = recvAvgTmp;
                    }
                    if (recvAvgTmp < minRxbyt) {
                        minRxbyt = recvAvgTmp;
                    }
                    sumRxbyt += recvAvgTmp;
                }
                if (null != sentAvgTmp) {
                    if (sentAvgTmp > maxSent) {
                        maxSent = sentAvgTmp;
                    }
                    if (sentAvgTmp < minSent) {
                        minSent = sentAvgTmp;
                    }
                    sumSent += sentAvgTmp;
                }
                cpuPerTmp = snmpState.getCpuPerDouble();
                memSizeTmp = snmpState.getMemPerDouble();
                if (null != cpuPerTmp) {
                    if (cpuPerTmp > maxCpuPer) {
                        maxCpuPer = cpuPerTmp;
                    }
                    if (cpuPerTmp < minCpuPer) {
                        minCpuPer = cpuPerTmp;
                    }
                    sumCpuPer += cpuPerTmp;
                }
                if (null != memSizeTmp) {
                    if (memSizeTmp > maxMemSize) {
                        maxMemSize = memSizeTmp;
                    }
                    if (memSizeTmp < minMemSize) {
                        minMemSize = memSizeTmp;
                    }
                    sumMemSize += memSizeTmp;
                }
            }
        }
        if (maxRxbyt > maxval) {
            maxval = maxRxbyt;
        }
        if (maxSent > maxval) {
            maxval = maxSent;
        }
        if (maxval == 0) {
            maxval = 1;
        }
        model.addAttribute("snmpAvgMax", Math.ceil(maxval));
        if (snmpStateList.size() > 0) {
            avgRxbyt = sumRxbyt / (double) snmpStateList.size();
            avgSent = sumSent / (double) snmpStateList.size();
            avgCpuPer = sumCpuPer / (double) snmpStateList.size();
            avgMemSize = sumMemSize / (double) snmpStateList.size();
        } else {
            minRxbyt = 0d;
            minSent = 0d;
            minCpuPer = 0d;
            minMemSize = 0d;
        }
        SubtitleDto rxbytSubtitleDto = new SubtitleDto();
        rxbytSubtitleDto.setAvgValue(FormatUtil.formatDouble(avgRxbyt, 2) + "MB/s");
        rxbytSubtitleDto.setMaxValue(maxRxbyt + "MB/s");
        rxbytSubtitleDto.setMinValue(minRxbyt + "MB/s");
        model.addAttribute("rxbytSubtitleDto", rxbytSubtitleDto);
        SubtitleDto sentSubtitleDto = new SubtitleDto();
        sentSubtitleDto.setAvgValue(FormatUtil.formatDouble(avgSent, 2) + "MB/s");
        sentSubtitleDto.setMaxValue(maxSent + "MB/s");
        sentSubtitleDto.setMinValue(minSent + "MB/s");
        model.addAttribute("sentSubtitleDto", sentSubtitleDto);
        SubtitleDto cpuPerSubtitleDto = new SubtitleDto();
        cpuPerSubtitleDto.setAvgValue(FormatUtil.formatDouble(avgCpuPer, 2) + "%");
        cpuPerSubtitleDto.setMaxValue(maxCpuPer + "%");
        cpuPerSubtitleDto.setMinValue(minCpuPer + "%");
        model.addAttribute("cpuPerSubtitleDto", cpuPerSubtitleDto);
        SubtitleDto memSizeSubtitleDto = new SubtitleDto();
        memSizeSubtitleDto.setAvgValue(FormatUtil.formatDouble(avgMemSize, 2) + "%");
        memSizeSubtitleDto.setMaxValue(maxMemSize + "%");
        memSizeSubtitleDto.setMinValue(minMemSize + "%");
        model.addAttribute("memSizeSubtitleDto", memSizeSubtitleDto);
    }


    @Autowired
    private SnmpStateMapper snmpStateMapper;


}