package com.wgcloud.task;

import cn.hutool.core.collection.CollectionUtil;
import com.wgcloud.common.NettytHandler;
import com.wgcloud.config.CommonConfig;
import com.wgcloud.entity.*;
import com.wgcloud.service.*;
import com.wgcloud.util.DateUtil;
import com.wgcloud.util.HostUtil;
import com.wgcloud.util.ServerBackupUtil;
import com.wgcloud.util.ThreadPoolUtil;
import com.wgcloud.util.msg.WarnMailUtil;
import com.wgcloud.util.msg.WarnPools;
import com.wgcloud.util.staticvar.BatchData;
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.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.*;

/**
 * @version v3.3
 * @ClassName:DataScheduledTask.java
 * @author: http://www.wgstart.com
 * @date: 2021年3月16日
 * @Description: 定时提交监控数据，清理历史数据
 * @Copyright: 2019-2021 wgcloud. All rights reserved.
 */
@Component
public class DataScheduledTask {
    private Logger logger = LoggerFactory.getLogger(DataScheduledTask.class);


    @Autowired
    private SystemInfoService systemInfoService;
    @Autowired
    private DiskStateService diskStateService;
    @Autowired
    private DeskIoService deskIoService;
    @Autowired
    private DiskSmartService diskSmartService;
    @Autowired
    private HostDiskPerService hostDiskPerService;
    @Autowired
    private CpuTemperaturesService cpuTemperaturesService;
    @Autowired
    private LogInfoService logInfoService;
    @Autowired
    private AppInfoService appInfoService;
    @Autowired
    private CustomInfoService customInfoService;
    @Autowired
    private FileWarnInfoService fileWarnInfoService;
    @Autowired
    private DockerInfoService dockerInfoService;
    @Autowired
    private PortInfoService portInfoService;
    @Autowired
    private FileSafeService fileSafeService;
    @Autowired
    private CpuStateService cpuStateService;
    @Autowired
    private MemStateService memStateService;
    @Autowired
    private NetIoStateService netIoStateService;
    @Autowired
    private SysLoadStateService sysLoadStateService;
    @Autowired
    private AppStateService appStateService;
    @Autowired
    private CustomStateService customStateService;
    @Autowired
    private FileWarnStateService fileWarnStateService;
    @Autowired
    private ShellStateService shellStateService;
    @Autowired
    private HeathStateService heathStateService;
    @Autowired
    private DceStateService dceStateService;
    @Autowired
    private SnmpStateService snmpStateService;
    @Autowired
    private DockerStateService dockerStateService;
    @Autowired
    private DbTableCountService dbTableCountService;
    @Autowired
    private TaskUtilService taskUtilService;
    @Autowired
    private CommonConfig commonConfig;


    /**
     * 29秒后执行，之后每隔29秒执行, 单位：ms。
     * 批量提交数据
     */
    @Scheduled(initialDelay = 29000L, fixedRate = 29 * 1000)
    public synchronized void commitTask() {
        if (DateUtil.isClearTime()) {
            logger.info("正在清空历史趋势图数据，不执行提交监控数据----------" + DateUtil.getCurrentDateTime());
            BatchData.clearAll();
            return;
        }
        logger.info("批量提交监控数据任务开始----------" + DateUtil.getCurrentDateTime());
        try {
            if (BatchData.FILEWARN_STATE_LIST.size() > 0) {
                List<FileWarnState> FILEWARN_STATE_LIST = new ArrayList<FileWarnState>();
                FILEWARN_STATE_LIST.addAll(BatchData.FILEWARN_STATE_LIST);
                BatchData.FILEWARN_STATE_LIST.clear();
                fileWarnStateService.saveRecord(FILEWARN_STATE_LIST);
            }
            if (BatchData.APP_STATE_LIST.size() > 0) {
                List<AppState> APP_STATE_LIST = new ArrayList<AppState>();
                APP_STATE_LIST.addAll(BatchData.APP_STATE_LIST);
                BatchData.APP_STATE_LIST.clear();
                appStateService.saveRecord(APP_STATE_LIST);
            }
            if (BatchData.CUSTOM_STATE_LIST.size() > 0) {
                List<CustomState> CUSTOM_STATE_LIST = new ArrayList<CustomState>();
                CUSTOM_STATE_LIST.addAll(BatchData.CUSTOM_STATE_LIST);
                BatchData.CUSTOM_STATE_LIST.clear();
                customStateService.saveRecord(CUSTOM_STATE_LIST);
            }
            if (BatchData.HEATH_STATE_LIST.size() > 0) {
                List<HeathState> HEATH_STATE_LIST = new ArrayList<HeathState>();
                HEATH_STATE_LIST.addAll(BatchData.HEATH_STATE_LIST);
                BatchData.HEATH_STATE_LIST.clear();
                heathStateService.saveRecord(HEATH_STATE_LIST);
            }
            if (BatchData.DCE_STATE_LIST.size() > 0) {
                List<DceState> DCE_STATE_LIST = new ArrayList<DceState>();
                DCE_STATE_LIST.addAll(BatchData.DCE_STATE_LIST);
                BatchData.DCE_STATE_LIST.clear();
                dceStateService.saveRecord(DCE_STATE_LIST);
            }
            if (BatchData.DBTABLE_COUNT_LIST.size() > 0) {
                List<DbTableCount> DBTABLE_COUNT_LIST = new ArrayList<DbTableCount>();
                DBTABLE_COUNT_LIST.addAll(BatchData.DBTABLE_COUNT_LIST);
                BatchData.DBTABLE_COUNT_LIST.clear();
                dbTableCountService.saveRecord(DBTABLE_COUNT_LIST);
            }
            if (BatchData.SNMP_STATE_LIST.size() > 0) {
                List<SnmpState> SNMP_STATE_LIST = new ArrayList<SnmpState>();
                SNMP_STATE_LIST.addAll(BatchData.SNMP_STATE_LIST);
                BatchData.SNMP_STATE_LIST.clear();
                snmpStateService.saveRecord(SNMP_STATE_LIST);
            }
            if (BatchData.DOCKER_STATE_LIST.size() > 0) {
                List<DockerState> DOCKER_STATE_LIST = new ArrayList<DockerState>();
                DOCKER_STATE_LIST.addAll(BatchData.DOCKER_STATE_LIST);
                BatchData.DOCKER_STATE_LIST.clear();
                dockerStateService.saveRecord(DOCKER_STATE_LIST);
            }
            if (BatchData.CPU_STATE_LIST.size() > 0) {
                List<CpuState> CPU_STATE_LIST = new ArrayList<CpuState>();
                CPU_STATE_LIST.addAll(BatchData.CPU_STATE_LIST);
                BatchData.CPU_STATE_LIST.clear();
                cpuStateService.saveRecord(CPU_STATE_LIST);
            }
            if (BatchData.MEM_STATE_LIST.size() > 0) {
                List<MemState> MEM_STATE_LIST = new ArrayList<MemState>();
                MEM_STATE_LIST.addAll(BatchData.MEM_STATE_LIST);
                BatchData.MEM_STATE_LIST.clear();
                memStateService.saveRecord(MEM_STATE_LIST);
            }
            if (BatchData.NETIO_STATE_LIST.size() > 0) {
                List<NetIoState> NETIO_STATE_LIST = new ArrayList<NetIoState>();
                NETIO_STATE_LIST.addAll(BatchData.NETIO_STATE_LIST);
                BatchData.NETIO_STATE_LIST.clear();
                netIoStateService.saveRecord(NETIO_STATE_LIST);
            }
            if (BatchData.SYSLOAD_STATE_LIST.size() > 0) {
                List<SysLoadState> SYSLOAD_STATE_LIST = new ArrayList<SysLoadState>();
                SYSLOAD_STATE_LIST.addAll(BatchData.SYSLOAD_STATE_LIST);
                BatchData.SYSLOAD_STATE_LIST.clear();
                sysLoadStateService.saveRecord(SYSLOAD_STATE_LIST);
            }
            if (BatchData.LOG_INFO_LIST.size() > 0) {
                List<LogInfo> LOG_INFO_LIST = new ArrayList<LogInfo>();
                LOG_INFO_LIST.addAll(BatchData.LOG_INFO_LIST);
                BatchData.LOG_INFO_LIST.clear();
                logInfoService.saveRecord(LOG_INFO_LIST);
            }
            if (BatchData.DISK_STATE_LIST.size() > 0) {
                batchCommitDeskState();
            }
            if (BatchData.DESK_IO_LIST.size() > 0) {
                batchCommitDeskIo();
            }
            if (BatchData.DISK_SMART_LIST.size() > 0) {
                batchCommitDiskSmart();
            }
            if (BatchData.CPU_TEMPERATURES_LIST.size() > 0) {
                batchCommitCpuTemperatures();
            }
            if (BatchData.SYSTEM_INFO_LIST.size() > 0) {
                batchCommitSystemInfo();
            }
            if (BatchData.APP_INFO_LIST.size() > 0) {
                batchCommitAppInfo();
            }
            if (BatchData.CUSTOM_INFO_LIST.size() > 0) {
                batchCommitCustomInfo();
            }
            if (BatchData.FILEWARN_INFO_LIST.size() > 0) {
                batchCommitFileWarnInfo();
            }
            if (BatchData.PORT_INFO_LIST.size() > 0) {
                batchCommitPortInfo();
            }
            if (BatchData.FILE_SAFE_LIST.size() > 0) {
                batchCommitFileSafes();
            }
            if (BatchData.DOCKER_INFO_LIST.size() > 0) {
                batchCommitDockerInfo();
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            logger.error("批量提交监控数据错误", e);
            logInfoService.save("批量提交监控数据错误", e.toString(), StaticKeys.LOG_XTCZ);
        }
        logger.info("批量提交监控数据任务结束----------" + DateUtil.getCurrentDateTime());
    }

    /**
     * cpu温度数据保存
     *
     * @throws Exception
     */
    private void batchCommitCpuTemperatures() throws Exception {
        Map<String, Object> paramsDel = new HashMap<String, Object>();

        List<CpuTemperatures> CPU_TEMPERATURES_LIST = new ArrayList<CpuTemperatures>();
        CPU_TEMPERATURES_LIST.addAll(BatchData.CPU_TEMPERATURES_LIST);
        BatchData.CPU_TEMPERATURES_LIST.clear();
        List<String> hostnameList = new ArrayList<String>();
        for (CpuTemperatures deskState : CPU_TEMPERATURES_LIST) {
            if (!hostnameList.contains(deskState.getHostname())) {
                hostnameList.add(deskState.getHostname());
            }
        }
        if (!CollectionUtil.isEmpty(hostnameList)) {
            cpuTemperaturesService.deleteByAccHname(hostnameList);
        }
        cpuTemperaturesService.saveRecord(CPU_TEMPERATURES_LIST);
    }

    /**
     * 磁盘smart数据保存
     *
     * @throws Exception
     */
    private void batchCommitDiskSmart() throws Exception {
        List<DiskSmart> DISK_SMART_LIST = new ArrayList<DiskSmart>();
        DISK_SMART_LIST.addAll(BatchData.DISK_SMART_LIST);
        BatchData.DISK_SMART_LIST.clear();
        List<String> hostnameList = new ArrayList<String>();
        for (DiskSmart diskSmart : DISK_SMART_LIST) {
            if (!hostnameList.contains(diskSmart.getHostname())) {
                hostnameList.add(diskSmart.getHostname());
            }
        }
        if (!CollectionUtil.isEmpty(hostnameList)) {
            diskSmartService.deleteByAccHname(hostnameList);
        }
        diskSmartService.saveRecord(DISK_SMART_LIST);
    }

    /**
     * 磁盘io数据保存
     *
     * @throws Exception
     */
    private void batchCommitDeskIo() throws Exception {
        List<DeskIo> DESK_IO_LIST = new ArrayList<DeskIo>();
        DESK_IO_LIST.addAll(BatchData.DESK_IO_LIST);
        BatchData.DESK_IO_LIST.clear();
        List<String> hostnameList = new ArrayList<String>();
        for (DeskIo deskState : DESK_IO_LIST) {
            if (!hostnameList.contains(deskState.getHostname())) {
                hostnameList.add(deskState.getHostname());
            }
        }
        if (!CollectionUtil.isEmpty(hostnameList)) {
            deskIoService.deleteByAccHname(hostnameList);
        }
        deskIoService.saveRecord(DESK_IO_LIST);
    }


    /**
     * 磁盘空间数据保存
     *
     * @throws Exception
     */
    private void batchCommitDeskState() throws Exception {
        List<DiskState> DISK_STATE_LIST = new ArrayList<DiskState>();
        DISK_STATE_LIST.addAll(BatchData.DISK_STATE_LIST);
        BatchData.DISK_STATE_LIST.clear();
        List<String> hostnameList = new ArrayList<String>();
        for (DiskState diskState : DISK_STATE_LIST) {
            if (!hostnameList.contains(diskState.getHostname())) {
                hostnameList.add(diskState.getHostname());
            }
        }
        if (!CollectionUtil.isEmpty(hostnameList)) {
            diskStateService.deleteByAccHname(hostnameList);
        }
        diskStateService.saveRecord(DISK_STATE_LIST);
    }

    /**
     * docker监控数据保存
     *
     * @throws Exception
     */
    private void batchCommitDockerInfo() throws Exception {
        Map<String, Object> paramsDel = new HashMap<String, Object>();
        List<DockerInfo> DOCKER_INFO_LIST = new ArrayList<DockerInfo>();
        DOCKER_INFO_LIST.addAll(BatchData.DOCKER_INFO_LIST);
        BatchData.DOCKER_INFO_LIST.clear();

        dockerInfoService.updateRecord(DOCKER_INFO_LIST);
    }

    /**
     * 进程监控数据保存
     *
     * @throws Exception
     */
    private void batchCommitAppInfo() throws Exception {
        Map<String, Object> paramsDel = new HashMap<String, Object>();
        List<AppInfo> APP_INFO_LIST = new ArrayList<AppInfo>();
        APP_INFO_LIST.addAll(BatchData.APP_INFO_LIST);
        BatchData.APP_INFO_LIST.clear();

        appInfoService.updateRecord(APP_INFO_LIST);
    }

    /**
     * 自定义监控项数据保存
     *
     * @throws Exception
     */
    private void batchCommitCustomInfo() throws Exception {
        Map<String, Object> paramsDel = new HashMap<String, Object>();
        List<CustomInfo> CUSTOM_INFO_LIST = new ArrayList<CustomInfo>();
        CUSTOM_INFO_LIST.addAll(BatchData.CUSTOM_INFO_LIST);
        BatchData.CUSTOM_INFO_LIST.clear();

        customInfoService.updateRecord(CUSTOM_INFO_LIST);
    }

    /**
     * 日志文件监控数据保存
     *
     * @throws Exception
     */
    private void batchCommitFileWarnInfo() throws Exception {
        Map<String, Object> paramsDel = new HashMap<String, Object>();
        List<FileWarnInfo> FILEWARN_INFO_LIST = new ArrayList<FileWarnInfo>();
        FILEWARN_INFO_LIST.addAll(BatchData.FILEWARN_INFO_LIST);
        BatchData.FILEWARN_INFO_LIST.clear();

        fileWarnInfoService.updateRecord(FILEWARN_INFO_LIST);
    }

    /**
     * 端口监控数据保存
     *
     * @throws Exception
     */
    private void batchCommitPortInfo() throws Exception {
        Map<String, Object> paramsDel = new HashMap<String, Object>();
        List<PortInfo> PORT_INFO_LIST = new ArrayList<PortInfo>();
        PORT_INFO_LIST.addAll(BatchData.PORT_INFO_LIST);
        BatchData.PORT_INFO_LIST.clear();

        portInfoService.updateRecord(PORT_INFO_LIST);
    }

    /**
     * 文件防篡改信息监测数据保存
     *
     * @throws Exception
     */
    private void batchCommitFileSafes() throws Exception {
        Map<String, Object> params = new HashMap<String, Object>();
        List<FileSafe> FILE_SAFE_LIST = new ArrayList<FileSafe>();
        FILE_SAFE_LIST.addAll(BatchData.FILE_SAFE_LIST);
        BatchData.FILE_SAFE_LIST.clear();

        fileSafeService.updateRecord(FILE_SAFE_LIST);
    }

    /**
     * 主机监控数据保存
     *
     * @throws Exception
     */
    private void batchCommitSystemInfo() throws Exception {
        Map<String, Object> paramsDel = new HashMap<String, Object>();
        List<SystemInfo> SYSTEM_INFO_LIST = new ArrayList<SystemInfo>();
        SYSTEM_INFO_LIST.addAll(BatchData.SYSTEM_INFO_LIST);
        BatchData.SYSTEM_INFO_LIST.clear();
        List<SystemInfo> updateList = new ArrayList<SystemInfo>();
        List<SystemInfo> insertList = new ArrayList<SystemInfo>();
        List<SystemInfo> savedList = systemInfoService.selectAllByParams(paramsDel);
        for (SystemInfo systemInfo : SYSTEM_INFO_LIST) {
            if (StringUtils.isEmpty(systemInfo.getHostname())) {
                continue;
            }
            boolean issaved = false;
            //之前若保存过，更新主机
            for (SystemInfo systemInfoS : savedList) {
                if (systemInfoS.getHostname().equals(systemInfo.getHostname())) {
                    systemInfo.setId(systemInfoS.getId());
                    updateList.add(systemInfo);
                    issaved = true;
                    break;
                }
            }
            //之前未保存过，新增主机
            if (!issaved) {
                insertList.add(systemInfo);
            }
        }
        //更新
        systemInfoService.updateRecord(updateList);
        //新增
        systemInfoService.saveRecord(insertList);

        //新加入主机发送通知 begin
        for (SystemInfo systemInfoNew : insertList) {
            Runnable runnable = () -> {
                WarnMailUtil.sendHostDown(systemInfoNew, false);
            };
            ThreadPoolUtil.executor.execute(runnable);
        }
        //新加入主机发送通知 end
    }

    /**
     * 所有主机都新增一条磁盘总使用率信息
     *
     * @throws Exception
     */
    private void addHostDiskPer() throws Exception {
        Date nowtime = DateUtil.getNowTime();
        List<HostDiskPer> hostDiskPerList = new ArrayList<>();
        Map<String, Object> params = new HashMap<String, Object>();
        List<SystemInfo> systemInfoList = systemInfoService.selectAllByParams(params);
        for (SystemInfo systemInfo1 : systemInfoList) {
            params.put("hostname", systemInfo1.getHostname());
            List<DiskState> deskStates = diskStateService.selectAllByParams(params);
            HostUtil.setDiskSumPer(deskStates, systemInfo1);
            HostDiskPer hostDiskPer = new HostDiskPer();
            hostDiskPer.setCreateTime(nowtime);
            hostDiskPer.setDiskSumPer(systemInfo1.getDiskPer());
            hostDiskPer.setHostname(systemInfo1.getHostname());
            hostDiskPerList.add(hostDiskPer);
        }
        hostDiskPerService.saveRecord(hostDiskPerList);
    }

    /**
     * 每天凌晨8:24:30执行
     * 清理历史数据过程即将结束时，将主机、端口、进程、docker的更新时间刷新为当前时间
     */
    @Scheduled(cron = "30 24 8 * * ?")
    public void refreshCommitDate() {
        try {
            taskUtilService.refreshCommitDate();
        } catch (Exception e) {
            logger.error("刷新监控数据更新时间错误", e);
        }
    }

    /**
     * 每天凌晨8:10执行
     * 删除历史趋势图数据，默认15天
     */
    @Scheduled(cron = "0 10 8 * * ?")
    public void clearHisdataTask() {
        if (!StaticKeys.NODE_MASTER.equals(commonConfig.getNodeType())) {
            logger.info("slave节点不执行清空历史趋势图数据任务");
            return;
        }
        logger.info("清空" + commonConfig.getHistoryDataOut() + "天前的监控历史趋势图数据");
        logger.info("定时清空历史趋势图数据任务开始----------" + DateUtil.getCurrentDateTime());

        //配置的历史数据保留时间，天
        String thrityDayBefore = DateUtil.getDateBefore(commonConfig.getHistoryDataOut());
        Map<String, Object> paramsDel = new HashMap<String, Object>();
        try {
            paramsDel.put(StaticKeys.SEARCH_END_TIME, thrityDayBefore);
            //执行删除操作begin
            if (paramsDel.get(StaticKeys.SEARCH_END_TIME) != null && !"".equals(paramsDel.get(StaticKeys.SEARCH_END_TIME))) {
                //删除历史cpu监控趋势图信息
                cpuStateService.deleteByAccountAndDate(paramsDel);
                //删除历史内存监控趋势图信息
                memStateService.deleteByAccountAndDate(paramsDel);
                //删除历史吞吐率监控趋势图信息
                netIoStateService.deleteByAccountAndDate(paramsDel);
                //删除历史负载状态监控趋势图信息
                sysLoadStateService.deleteByAccountAndDate(paramsDel);
                //删除历史进程趋势图数据
                appStateService.deleteByDate(paramsDel);
                //删除历史docker状态趋势图数据
                dockerStateService.deleteByDate(paramsDel);
                //删除历史磁盘监控信息
                diskStateService.deleteByAccountAndDate(paramsDel);
                //删除历史磁盘Io信息
                deskIoService.deleteByAccountAndDate(paramsDel);
                //删除历史磁盘smart信息
                diskSmartService.deleteByAccountAndDate(paramsDel);
                //删除历史cpu温度监控信息
                cpuTemperaturesService.deleteByAccountAndDate(paramsDel);
                //删除历史接口检测趋势图数据
                heathStateService.deleteByDate(paramsDel);
                //删除历史数通检测趋势图数据
                dceStateService.deleteByDate(paramsDel);
                //删除系统日志数据
                logInfoService.deleteByDate(paramsDel);
                //删除数据表历史统计趋势图信息数据
                dbTableCountService.deleteByDate(paramsDel);
                //删除日志监控数据记录
                fileWarnStateService.deleteByDate(paramsDel);
                //删除执行下发状态记录
                shellStateService.deleteByDate(paramsDel);
                //删除磁盘总使用率趋势图信息
                hostDiskPerService.deleteByAccountAndDate(paramsDel);
                //删除历史SNMP设备检测趋势图数据
                snmpStateService.deleteByDate(paramsDel);
                //删除自定义监控项趋势图数据
                customStateService.deleteByDate(paramsDel);

                //所有主机增加一条磁盘总使用率 begin
                addHostDiskPer();
                //所有主机增加一条磁盘总使用率 end

                //清空发告警邮件的记录
                logger.info("清空告警标记");
                WarnPools.clearOldData();

                //清空登录错误缓存记录
                logger.info("清空登录账号登录错误缓存记录");
                StaticKeys.LOGIN_BLOCK_MAP.clear();
                StaticKeys.LOGIN_ERROR_MAP.clear();

                //清空web ssh终端缓存
                logger.info("清空web ssh终端缓存");
                NettytHandler.clearOldData();

                //清空缓存主机备注信息
                HostUtil.clearCacheMap();

                //清空server-backup节点处理监控的各种数据ID集合
                ServerBackupUtil.clearCacheIdList();

                logInfoService.save("定时清空历史趋势图数据完成", "每天8:10清空" + commonConfig.getHistoryDataOut() +
                        "天前的监控历史趋势图数据，任务完成", StaticKeys.LOG_XTCZ);

            }
            //执行删除操作end

        } catch (Exception e) {
            logger.error("定时清空历史趋势图数据任务出错", e);
            logInfoService.save("定时清空历史趋势图数据错误", e.toString(), StaticKeys.LOG_XTCZ);
        }
        logger.info("定时清空历史趋势图数据任务结束----------" + DateUtil.getCurrentDateTime());
    }


}