package com.wgcloud.controller;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.comparator.PropertyComparator;
import cn.hutool.json.JSONUtil;
import com.github.pagehelper.PageInfo;
import com.wgcloud.config.CommonConfig;
import com.wgcloud.dto.ChartDapingNewInfo;
import com.wgcloud.entity.DiskState;
import com.wgcloud.entity.HostDiskPer;
import com.wgcloud.entity.LogInfo;
import com.wgcloud.entity.SystemInfo;
import com.wgcloud.service.*;
import com.wgcloud.util.DateUtil;
import com.wgcloud.util.FormatUtil;
import com.wgcloud.util.HostUtil;
import com.wgcloud.util.ThreadPoolUtil;
import com.wgcloud.util.staticvar.StaticKeys;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.*;

/**
 * @version v3.3
 * @ClassName:DapingNewController.java
 * @author: http://www.wgstart.com
 * @date: 20212年6月9日
 * @Description: 大屏新版controller
 * @Copyright: 2019-2022 wgcloud. All rights reserved.
 */
@Controller
@RequestMapping(value = "/dapingNew")
public class DapingNewController {


    private void testThread() {
        Runnable runnable = () -> {
            logger.info("DapingNewController----------testThread");
        };
        ThreadPoolUtil.executor.execute(runnable);
    }


    private static final Logger logger = LoggerFactory.getLogger(DapingNewController.class);
    @Resource
    private DbTableService dbTableService;
    @Resource
    private PortInfoService portInfoService;
    @Resource
    private FileSafeService fileSafeService;
    @Resource
    private DceInfoService dceInfoService;
    @Resource
    private SnmpInfoService snmpInfoService;
    @Resource
    private DbInfoService dbInfoService;
    @Resource
    private SystemInfoService systemInfoService;
    @Resource
    private AppInfoService appInfoService;
    @Resource
    private FileWarnInfoService fileWarnInfoService;
    @Resource
    private FileWarnStateService fileWarnStateService;
    @Resource
    private HostDiskPerService hostDiskPerService;
    @Resource
    private DockerInfoService dockerInfoService;
    @Resource
    private LogInfoService logInfoService;
    @Autowired
    private HeathMonitorService heathMonitorService;
    @Autowired
    private ShellInfoService shellInfoService;
    @Resource
    private AccountInfoService accountInfoService;
    @Resource
    private DiskStateService diskStateService;
    @Autowired
    private CommonConfig commonConfig;

    /**
     * 根据条件查询host列表
     *
     * @param model
     * @param request
     * @return
     */
    @RequestMapping(value = "index")
    public String index(Model model, HttpServletRequest request) {
        Map<String, Object> params = new HashMap<String, Object>();
        try {
            int totalSystemInfoSize = systemInfoService.countByParams(params);
            //监控主机总量
            model.addAttribute("totalSystemInfoSize", totalSystemInfoSize);
            params.put("state", StaticKeys.DOWN_STATE);
            int hostDownSize = systemInfoService.countByParams(params);
            //下线主机数量
            model.addAttribute("hostDownSize", hostDownSize);

            params.clear();
            int totalSizeApp = appInfoService.countByParams(params);
            //进程总数量
            model.addAttribute("totalSizeApp", totalSizeApp);
            int dockerSize = dockerInfoService.countByParams(params);
            //docker总数量
            model.addAttribute("dockerSize", dockerSize);

            params.put("state", StaticKeys.DOWN_STATE);
            int downAppSize = appInfoService.countByParams(params);
            //监控进程下线数量
            model.addAttribute("downAppSize", downAppSize);
            int downDockerSize = dockerInfoService.countByParams(params);
            //监控docker下线数量
            model.addAttribute("downDockerSize", downDockerSize);

            params.clear();
            int portSize = portInfoService.countByParams(params);
            //端口总数量
            model.addAttribute("portSize", portSize);
            params.put("state", StaticKeys.DOWN_STATE);
            int portDownSize = portInfoService.countByParams(params);
            //端口下线数量
            model.addAttribute("portDownSize", portDownSize);

            params.clear();
            int dceSize = dceInfoService.countByParams(params);
            //数通设备总数量
            model.addAttribute("dceSize", dceSize);
            params.put("resTimes", -1);
            int dceDownSize = dceInfoService.countByParams(params);
            //数通设备下线数量
            model.addAttribute("dceDownSize", dceDownSize);

            params.clear();
            int snmpSize = snmpInfoService.countByParams(params);
            //snmp设备总数量
            model.addAttribute("snmpSize", snmpSize);
            params.put("state", StaticKeys.DOWN_STATE);
            int snmpDownSize = snmpInfoService.countByParams(params);
            //snmp设备下线数量
            model.addAttribute("snmpDownSize", snmpDownSize);

            params.clear();
            Integer fileWarnSize = fileWarnInfoService.countByParams(params);
            //日志监控总量
            model.addAttribute("fileWarnSize", fileWarnSize == null ? 0 : fileWarnSize);

            params.clear();
            Integer fileSafeSize = fileSafeService.countByParams(params);
            //文件防篡改总量
            model.addAttribute("fileSafeSize", fileSafeSize == null ? 0 : fileSafeSize);
            params.put("state", StaticKeys.DOWN_STATE);
            int fileSafeDownSize = fileSafeService.countByParams(params);
            //文件防篡改下线数量
            model.addAttribute("fileSafeDownSize", fileSafeDownSize);

            params.clear();
            Integer dbTableSize = dbTableService.countByParams(params);
            //数据表总量
            model.addAttribute("dbTableSize", dbTableSize);

            params.clear();
            int dbInfoSize = dbInfoService.countByParams(params);
            //数据源数量
            model.addAttribute("dbInfoSize", dbInfoSize);

            params.clear();
            params.put("dbState", StaticKeys.DOWN_STATE);
            int dbInfoDownSize = dbInfoService.countByParams(params);
            //失败数据源数量
            model.addAttribute("dbInfoDownSize", dbInfoDownSize);

            params.clear();
            int heathSize = heathMonitorService.countByParams(params);
            //服务接口数量
            model.addAttribute("heathSize", heathSize);
            params.put("heathStatus", StaticKeys.HEATH_STATUS_200);
            int heath200Size = heathMonitorService.countByParams(params);
            model.addAttribute("heath200Size", heath200Size);
            //服务接口失败数量
            model.addAttribute("heatherrSize", (heathSize - heath200Size));

            params.clear();
            int shellInfoSize = shellInfoService.countByParams(params);
            //失败数据源数量
            model.addAttribute("shellInfoSize", shellInfoSize);


            //监控资源总数量
            Integer resourceAllSize = totalSystemInfoSize + totalSizeApp + dockerSize + portSize + dceSize + snmpSize + fileWarnSize +
                    dbInfoSize + heathSize + fileSafeSize + dbTableSize;
            model.addAttribute("resourceAllSize", resourceAllSize);

            //设置每个系统类型的数量
            params.clear();
            List<SystemInfo> systemInfoList = systemInfoService.selectAllByParams(params);
            setSystemType(systemInfoList, model);

            //累积告警(次数)
            params.clear();
            params.put("hostname", "告警");
            model.addAttribute("warnCount", logInfoService.countByParams(params));

            // 主机及其资源告警次数最高，取前6个
            setTopDownHostChart(model);

            //设置cpu总核数，内存总大小
            setMiddleData(systemInfoList, model);

            //设置大屏显示的日志告警和恢复信息
            setLogInfo(model);

            //设置服务接口状态类型饼图
            setHeathMonitorType(model, heathSize);

            // 设置告警统计信息蜘蛛网图
            warnInfoInit(model);

            //主机进程数量，连接数量，mem使用率，cpu使用率，磁盘使用率，最新上报前6
            hostInfoTop6(model);

            return "daping/indexNew";
        } catch (Exception e) {
            logger.error("大屏展示错误", e);
        }
        return "";
    }

    /**
     * 设置服务接口状态类型饼图
     *
     * @param model
     */
    private void setHeathMonitorType(Model model, Integer heathSize) {
        Map<String, Object> params = new HashMap<String, Object>();
        try {
            params.put("heathStatus", StaticKeys.HEATH_STATUS_200);
            int heath200Size = heathMonitorService.countByParams(params);
            model.addAttribute("heath200Size", heath200Size);

            params.put("heathStatus", "400");
            int heath400Size = heathMonitorService.countByParams(params);
            model.addAttribute("heath400Size", heath400Size);

            params.put("heathStatus", "403");
            int heath403Size = heathMonitorService.countByParams(params);
            model.addAttribute("heath403Size", heath403Size);

            params.put("heathStatus", "404");
            int heath404Size = heathMonitorService.countByParams(params);
            model.addAttribute("heath404Size", heath404Size);

            params.put("heathStatus", "500");
            int heath500Size = heathMonitorService.countByParams(params);
            model.addAttribute("heath500Size", heath500Size);


            int heathOtherSize = heathSize - heath200Size - heath400Size - heath403Size - heath404Size - heath500Size;
            model.addAttribute("heathOtherSize", heathOtherSize);
        } catch (Exception e) {
            logger.error("setHeathMonitorType错误", e);
        }

    }

    /**
     * 设置每个系统类型的数量
     *
     * @param systemInfoList
     * @param model
     */
    private void setSystemType(List<SystemInfo> systemInfoList, Model model) {
        Map<String, Integer> map = HostUtil.getSystemTypeMap(systemInfoList);
        Integer windows = 0;
        Integer centos = 0;
        Integer redhat = 0;
        Integer ubuntu = 0;
        Integer debian = 0;
        Integer others = 0;
        if (null != map.get("windows")) {
            windows = map.get("windows");
        }
        if (null != map.get("centos")) {
            centos = map.get("centos");
        }
        if (null != map.get("redhat")) {
            redhat = map.get("redhat");
        }
        if (null != map.get("ubuntu")) {
            ubuntu = map.get("ubuntu");
        }
        if (null != map.get("debian")) {
            debian = map.get("debian");
        }
        if (null != map.get("其他Linux")) {
            others = map.get("其他Linux");
        }
        model.addAttribute("windowsSize", windows);
        model.addAttribute("centosSize", centos);
        model.addAttribute("redhatSize", redhat);
        model.addAttribute("ubuntuSize", ubuntu);
        model.addAttribute("debianSize", debian);
        model.addAttribute("othersSize", others);
    }


    /**
     * 主机及其资源告警次数最高，取前6个
     *
     * @param model
     */
    private void setTopDownHostChart(Model model) {
        Map<String, Object> params = new HashMap<String, Object>();
        List<ChartDapingNewInfo> chartInfoList = new ArrayList();
        try {
            //取最近一周的数据比对
            int days = 7;
            List<String> dateList = getDateList(days);
            String startDay = dateList.get(0);
            String endDay = dateList.get(dateList.size() - 1);
            params.put(StaticKeys.SEARCH_START_TIME, startDay + " 00:00:00");
            params.put(StaticKeys.SEARCH_END_TIME, endDay + " 23:59:59");
            List<SystemInfo> systemInfoList = systemInfoService.selectAllByParams(params);
            for (SystemInfo systemInfo : systemInfoList) {
                params.put("hostname", systemInfo.getHostname());
                params.put("hostnameNe", "已恢复");
                int size = logInfoService.countByParams(params);
                ChartDapingNewInfo chartInfo = new ChartDapingNewInfo();
                chartInfo.setName(systemInfo.getHostname());
                chartInfo.setValue(size);
                chartInfoList.add(chartInfo);
            }
            Collections.sort(chartInfoList, new PropertyComparator<>("value"));

            //告警次数最高6个主机 begin
            CollectionUtil.reverse(chartInfoList);
            List<ChartDapingNewInfo> chartInfoListTmp = new ArrayList();
            if (chartInfoList.size() > 6) {
                chartInfoListTmp = chartInfoList.subList(0, 6);
            } else {
                chartInfoListTmp = chartInfoList;
            }
            //添加主机备注信息
            for (ChartDapingNewInfo dto : chartInfoListTmp) {
                dto.setName(dto.getName() + HostUtil.addRemark(dto.getName()));
            }
            model.addAttribute("topDownHostChart", JSONUtil.parseArray(chartInfoListTmp));
            //告警次数最高6个主机 end
        } catch (Exception e) {
            logger.error("统计分析主机及资源告警次数TOP10错误", e);
        }
    }

    /**
     * 设置大屏显示的系统日志前10条，两边各显示5条
     *
     * @param model
     */
    private void setLogInfo(Model model) throws Exception {
        List<LogInfo> recordList = new ArrayList<>();
        Map<String, Object> params = new HashMap<String, Object>();
        PageInfo logListPage = logInfoService.selectByParams(params, 1, 10);
        if (logListPage.getList().size() <= 5) {
            model.addAttribute("logLeftList", logListPage.getList());
            model.addAttribute("logRightList", recordList);
        }
        if (logListPage.getList().size() > 5) {
            model.addAttribute("logLeftList", logListPage.getList().subList(0, 5));
            model.addAttribute("logRightList", logListPage.getList().subList(5, logListPage.getList().size()));
        }

    }

    /**
     * 设置告警统计信息蜘蛛网图
     *
     * @param model
     */
    private void warnInfoInit(Model model) {
        try {
            Map<String, Object> params = new HashMap<String, Object>();
            params.put("hostname", "主机下线告警");
            int hostDownWarnSize = logInfoService.countByParams(params);
            //主机下线次数
            model.addAttribute("hostDownWarnSize", hostDownWarnSize);

            params.clear();
            params.put("hostname", "内存告警");
            int memWarnSize = logInfoService.countByParams(params);
            //内存告警次数
            model.addAttribute("memWarnSize", memWarnSize);

            params.clear();
            params.put("hostname", "CPU告警");
            int cpuWarnSize = logInfoService.countByParams(params);
            //cpu告警次数
            model.addAttribute("cpuWarnSize", cpuWarnSize);

            params.clear();
            params.put("hostname", "传输速率告警");
            int netWarnSize = logInfoService.countByParams(params);
            //上行下行速率告警次数
            model.addAttribute("netWarnSize", netWarnSize);

            params.clear();
            params.put("hostname", "磁盘告警");
            int diskWarnSize = logInfoService.countByParams(params);
            //磁盘告警次数
            model.addAttribute("diskWarnSize", diskWarnSize);

            params.clear();
            params.put("hostname", "系统负载(5分钟)告警");
            int load5WarnSize = logInfoService.countByParams(params);
            //系统负载告警次数
            model.addAttribute("load5WarnSize", load5WarnSize);

            //设置告警次数最大值 begin
            int WarnCountMaxSize = 1;
            if (hostDownWarnSize > WarnCountMaxSize) {
                WarnCountMaxSize = hostDownWarnSize;
            }
            if (memWarnSize > WarnCountMaxSize) {
                WarnCountMaxSize = memWarnSize;
            }
            if (cpuWarnSize > WarnCountMaxSize) {
                WarnCountMaxSize = cpuWarnSize;
            }
            if (netWarnSize > WarnCountMaxSize) {
                WarnCountMaxSize = netWarnSize;
            }
            if (diskWarnSize > WarnCountMaxSize) {
                WarnCountMaxSize = diskWarnSize;
            }
            if (load5WarnSize > WarnCountMaxSize) {
                WarnCountMaxSize = load5WarnSize;
            }
            model.addAttribute("WarnCountMaxSize", WarnCountMaxSize);
            //设置告警次数最大值 begin

        } catch (Exception e) {
            logger.error("设置告警统计信息蜘蛛网图错误", e);
        }

    }

    /**
     * 设置所有主机最近10分钟状态，cpu总核数，总内存
     *
     * @param model
     * @param list
     */
    private void setMiddleData(List<SystemInfo> list, Model model) {
        //cpu使用率最高
        Double maxCpu = 0d;
        //cpu使用率平均
        Double avgCpu = 0d;
        //cpu使用率最低
        Double minCpu = 1000d;
        Double sumCpu = 0d;

        //内存使用率最高
        Double maxMem = 0d;
        //内存使用率最低
        Double minMem = 1000d;
        //内存使用率平均
        Double avgMem = 0d;
        Double sumMem = 0d;


        //5分钟负载最高
        Double maxFiveLoad = 0d;
        //5分钟负载平均
        Double avgFiveLoad = 0d;
        //5分钟负载最低
        Double minFiveLoad = 1000d;
        Double sumFiveLoad = 0d;

        //15分钟负载最高
        Double maxFifteenLoad = 0d;
        //15分钟负载最低
        Double minFifteenLoad = 1000d;
        //15分钟负载平均
        Double avgFifteenLoad = 0d;
        Double sumFifteenLoad = 0d;

        //主机数量
        int systemSize = 0;

        //cpu总核数
        int cpuCoresSum = 0;
        //内存总和
        double memSum = 0;

        //所有主机运行总时间秒
        long uptimeSum = 0;

        for (SystemInfo systemInfo : list) {
            systemSize += 1;
            //组装cpu使用率 begin
            if (null != systemInfo.getCpuPer()) {
                if (systemInfo.getCpuPer() > maxCpu) {
                    maxCpu = systemInfo.getCpuPer();
                }
                if (systemInfo.getCpuPer() < minCpu) {
                    minCpu = systemInfo.getCpuPer();
                }
                sumCpu += systemInfo.getCpuPer();
            }
            //组装cpu使用率 end

            //组装内存使用率 begin
            if (null != systemInfo.getMemPer()) {
                if (systemInfo.getMemPer() > maxMem) {
                    maxMem = systemInfo.getMemPer();
                }
                if (systemInfo.getMemPer() < minMem) {
                    minMem = systemInfo.getMemPer();
                }
                sumMem += systemInfo.getMemPer();
            }
            //组装内存使用率 end


            //组装5分钟负载 begin
            if (null != systemInfo.getFiveLoad()) {
                if (Double.valueOf(systemInfo.getFiveLoad()) > maxFiveLoad) {
                    maxFiveLoad = Double.valueOf(systemInfo.getFiveLoad());
                }
                if (Double.valueOf(systemInfo.getFiveLoad()) < minFiveLoad) {
                    minFiveLoad = Double.valueOf(systemInfo.getFiveLoad());
                }
                sumFiveLoad += Double.valueOf(systemInfo.getFiveLoad());
            }
            //组装5分钟负载 end

            //组装15分钟负载 begin
            if (null != systemInfo.getFifteenLoad()) {
                if (Double.valueOf(systemInfo.getFifteenLoad()) > maxFifteenLoad) {
                    maxFifteenLoad = Double.valueOf(systemInfo.getFifteenLoad());
                }
                if (Double.valueOf(systemInfo.getFifteenLoad()) < minFifteenLoad) {
                    minFifteenLoad = Double.valueOf(systemInfo.getFifteenLoad());
                }
                sumFifteenLoad += Double.valueOf(systemInfo.getFifteenLoad());
            }
            //组装15分钟负载 end

            //组装cpu总核数 begin
            try {
                cpuCoresSum += Integer.valueOf(systemInfo.getCpuCoreNum());
            } catch (Exception e) {
                logger.error("统计所有主机总核数错误", e);
            }
            //组装cpu总核数 end

            //组装总内存 begin
            try {
                memSum += Double.valueOf(systemInfo.getTotalMem().replace("G", ""));
            } catch (Exception e) {
                logger.error("统计所有主机总内存错误", e);
            }
            //组装总内存 end

            //运行总时间秒 begin
            if (null != systemInfo.getUptime()) {
                uptimeSum += systemInfo.getUptime();
            }
            //运行总时间秒 end
        }

        model.addAttribute("cpuCoresSum", cpuCoresSum);
        model.addAttribute("memSum", FormatUtil.gToT(memSum + ""));
        model.addAttribute("uptimeSum", FormatUtil.secondsToDays(uptimeSum));

        if (systemSize > 0) {
            avgCpu = sumCpu / list.size();
            avgMem = sumMem / list.size();
            avgFifteenLoad = sumFifteenLoad / list.size();
            avgFiveLoad = sumFiveLoad / list.size();
        } else {
            minCpu = 0d;
            minMem = 0d;
            avgFifteenLoad = 0d;
            avgFiveLoad = 0d;
        }

        //最近5分钟所有主机cpu状态 begin
        model.addAttribute("maxCpuInfo", maxCpu);
        model.addAttribute("avgCpuInfo", FormatUtil.formatDouble(avgCpu, 2));
        model.addAttribute("minCpuInfo", minCpu);
        //最近5分钟所有主机cpu状态 end

        //最近5分钟所有主机内存状态 begin
        model.addAttribute("maxMemInfo", maxMem);
        model.addAttribute("avgMemInfo", FormatUtil.formatDouble(avgMem, 2));
        model.addAttribute("minMemInfo", minMem);
        //最近5分钟所有主机内存状态 end


        model.addAttribute("maxFiveLoad", maxFiveLoad);
        model.addAttribute("minFiveLoad", minFiveLoad);
        model.addAttribute("avgFiveLoad", FormatUtil.formatDouble(avgFiveLoad, 2));
        model.addAttribute("maxFifteenLoad", maxFifteenLoad);
        model.addAttribute("minFifteenLoad", minFifteenLoad);
        model.addAttribute("avgFifteenLoad", FormatUtil.formatDouble(avgFifteenLoad, 2));

        //磁盘总使用率最高
        Double maxDiskPer = 0d;
        String maxDiskPerIp = "";
        //磁盘总使用率最低
        Double minDiskPer = 1000d;
        String minDiskPerIp = "";
        //磁盘总使用率平均
        Double avgDiskPer = 0d;
        //磁盘总使用率总和
        Double sumDiskPer = 0d;
        try {
            //组织磁盘总使用率最大平均最低值 begin
            Map<String, Object> params = new HashMap<String, Object>();
            String oneDayBefore = DateUtil.getDateBefore(1);
            params.put(StaticKeys.SEARCH_START_TIME, oneDayBefore.substring(0, 10) + " 00:00:00");
            params.put(StaticKeys.SEARCH_END_TIME, oneDayBefore.substring(0, 10) + " 23:59:59");
            List<HostDiskPer> hostDiskPerList = hostDiskPerService.selectAllByParams(params);
            for (HostDiskPer hostDiskPer : hostDiskPerList) {
                if (null != hostDiskPer.getDiskSumPer() && hostDiskPer.getDiskSumPer() > maxDiskPer) {
                    maxDiskPer = hostDiskPer.getDiskSumPer();
                }
                if (null != hostDiskPer.getDiskSumPer() && hostDiskPer.getDiskSumPer() < minDiskPer) {
                    minDiskPer = hostDiskPer.getDiskSumPer();
                }
                if (null != hostDiskPer.getDiskSumPer()) {
                    sumDiskPer += hostDiskPer.getDiskSumPer();
                }
            }
            if (hostDiskPerList.size() > 0) {
                avgDiskPer = sumDiskPer / hostDiskPerList.size();
            } else {
                minDiskPer = 0d;
            }
            model.addAttribute("maxDiskPer", maxDiskPer);
            model.addAttribute("avgDiskPer", avgDiskPer);
            model.addAttribute("minDiskPer", minDiskPer);
            //组织磁盘总使用率最大平均最低值 end
        } catch (Exception e) {
            logger.error("组织磁盘总使用率最大平均最低值错误", e);
        }

    }

    /**
     * mem使用率，cpu使用率，最新上报前6
     *
     * @param model
     */
    private void hostInfoTop6(Model model) {
        try {
            Double maxSystemValue = 1d;
            Map<String, Object> params = new HashMap<String, Object>();
            params.put("orderBy", "CREATE_TIME");
            params.put("orderType", "DESC");
            PageInfo<SystemInfo> pageInfo = systemInfoService.selectByParams(params, 1, 6);
            List<String> hostNameTop6List = new ArrayList<>();
            List<Double> hostMemTop6List = new ArrayList<>();
            List<Double> hostCpuTop6List = new ArrayList<>();
            List<Integer> hostProcsTop6List = new ArrayList<>();
            List<Integer> hostNetConnectionsTop6List = new ArrayList<>();
            List<Double> hostDiskPerTop6List = new ArrayList<>();
            Map<String, Object> paramsAppInfo = new HashMap<String, Object>();
            for (SystemInfo systemInfo : pageInfo.getList()) {
                hostNameTop6List.add(systemInfo.getHostname());
                hostMemTop6List.add(systemInfo.getMemPer());
                hostCpuTop6List.add(systemInfo.getCpuPer());
                if (!StringUtils.isEmpty(systemInfo.getProcs())) {
                    hostProcsTop6List.add(Integer.valueOf(systemInfo.getProcs()));
                } else {
                    hostProcsTop6List.add(0);
                }

                if (!StringUtils.isEmpty(systemInfo.getNetConnections())) {
                    hostNetConnectionsTop6List.add(Integer.valueOf(systemInfo.getNetConnections()));
                } else {
                    hostNetConnectionsTop6List.add(0);
                }

                //设置磁盘总使用率 begin
                paramsAppInfo.put("hostname", systemInfo.getHostname());
                List<DiskState> deskStates = diskStateService.selectAllByParams(paramsAppInfo);
                HostUtil.setDiskSumPer(deskStates, systemInfo);
                hostDiskPerTop6List.add(systemInfo.getDiskPer());
                //设置磁盘总使用率 end
            }

            //取最大值 begin
            for (Double memPer : hostMemTop6List) {
                if (memPer > maxSystemValue) {
                    maxSystemValue = memPer;
                }
            }
            for (Double cpuPer : hostCpuTop6List) {
                if (cpuPer > maxSystemValue) {
                    maxSystemValue = cpuPer;
                }
            }
            for (Double diskPer : hostDiskPerTop6List) {
                if (diskPer > maxSystemValue) {
                    maxSystemValue = diskPer;
                }
            }
            maxSystemValue = FormatUtil.formatDouble(maxSystemValue * 1.2, 2);
            //取最大值 end

            model.addAttribute("hostNameTop6List", JSONUtil.parseArray(hostNameTop6List));
            model.addAttribute("hostMemTop6List", JSONUtil.parseArray(hostMemTop6List));
            model.addAttribute("hostCpuTop6List", JSONUtil.parseArray(hostCpuTop6List));
            model.addAttribute("hostProcsTop6List", JSONUtil.parseArray(hostProcsTop6List));
            model.addAttribute("hostNetConnectionsTop6List", JSONUtil.parseArray(hostNetConnectionsTop6List));
            model.addAttribute("hostDiskPerTop6List", JSONUtil.parseArray(hostDiskPerTop6List));
            model.addAttribute("maxSystemValue", maxSystemValue);

        } catch (Exception e) {
            logger.error("主机最新上报前10错误", e);
        }

    }

    /**
     * 获取时间列表
     *
     * @param days 几天
     * @return
     */
    public List<String> getDateList(int days) {
        List<String> dateList = new ArrayList<String>();
        String sevenDayBefore = DateUtil.getDateBefore(days);
        for (int i = 1; i < days + 1; i++) {
            sevenDayBefore = DateUtil.getDateBefore(i);
            dateList.add(sevenDayBefore.substring(0, 10));
        }
        CollectionUtil.reverse(dateList);
        return dateList;
    }


}