const robot = require('./robot')
const web = require('./web')
const {logger} = require("./utils/logger");
const {tr} = require("date-fns/locale");
const path = require("path");
const file = require("./utils/file");
const {getRustConfig} = require("./config");
const http = require("./utils/http");


/*******
 * 定时任务
 * **** */
function init() {
    // reportNodeStatus()
    reportDel()
    reportSearchPositions()
    reportAmount()
    cacheLogs()
    cachePredictorState()
    logger.info('--定时任务 启动');
}

function reportNodeStatus() {
    const intervalInMilliseconds = 5000;
    setInterval(() => {
        // logger.info('当前1',robot.appMap);
        web.robotNodeStatus()
    }, intervalInMilliseconds);
}


//定时清理机器人
function reportDel() {
    const intervalInMilliseconds = 2000;
    setInterval(() => {
        // logger.info('当前1',robot.appMap);
        robot.appMap.forEach((value, key) => {
            if (value.id !== -1) {
                // logger.info(`清理没用机器人开始111！`,value);
                robot.delRobot(value)
            }
        });
    }, intervalInMilliseconds);
}


// 定时扫描，如果发现机器人关闭或者错误，并且停止时间超过1分钟以上了，就进行清仓检查
function reportSearchPositions() {//DOTO node 代码修改完毕，待测试
    const intervalInMilliseconds = 1000 * 60;
    setInterval(() => {
        // logger.info('--当前 定时检查清仓');
        robot.appMap.forEach((value, key) => {
            logger.info('发起清仓检查：' + value.id + "停机时间：" + value.closeTime + "当前时间：" + new Date().getTime());

            let isStartTime = value.closeTime + (1000 * 60)
            if (value.id !== -1
                && isStartTime <= new Date().getTime()
                && (value.threadStatus === robot.RobotStatus.STOPPED || value.threadStatus === robot.RobotStatus.ERROR)
                // && value.isClearance === false
            ) {
                logger.info('--发起清仓' + value.id);

                robot.searchPositions({
                    "id": value.id,
                    "callPort": value.port,
                    "path": value.path,
                    "programName": value.programName,
                    "strategyName": value.strategyName,
                })
                // value.isClearance = true
            }
        });
    }, intervalInMilliseconds);
}


// 2秒一次对正在运行的,服务器进行余额比对，发生变化则上报
function reportAmount() {
    // 设置定时器，每隔一定时间（比如每隔5秒）发送一次GET请求
    const intervalInMilliseconds = 1000;
    setInterval(() => {
        // logger.info('当前2',robot.appMap);
        robot.appMap.forEach((value, key) => {
            var thisTime = new Date().getTime()
            if (value.threadStatus === robot.RobotStatus.RUNNING &&
                (thisTime - value.threadStartTime) > (1000 * 10)
            ) {
                robot.robotAmount(value)
            }
        });
    }, intervalInMilliseconds);
}

// 2024年10月28日
// 问题： http请求过多，加上请求耗时，容易造成拥堵，所以开启线程异步缓存 机器人程序日志，机器人状态详情信息，http直接返回数据
function cacheLogs() {
    // 设置定时器，每隔一定时间（比如每隔5秒）发送一次GET请求
    const intervalInMilliseconds = 1000 * 2;
    setInterval(() => {
        // logger.info('当前2',robot.appMap);
        robot.appMap.forEach((value, key) => {
            new Promise((resolve, reject) => {
                var thisTime = new Date().getTime()
                let port = value.port
                let n = 200
                let messlist = value.messlist
                if (value.id !== -1 && port !== -1) {

                    logger.info(`~~~缓存日志${value.id}`)
                    try {
                        var logPath = "./logs" + port
                        logger.info(`访问-日志相对目录：${logPath}`)
                        const directoryPath = path.resolve(logPath);
                        file.checkPathSync(directoryPath)
                        file.getLastFile(logPath, 5, async (fileNameList, _) => {
                            logger.info('-----文件：', fileNameList);
                            let result = await file.getLatestLogEntries(logPath, fileNameList.reverse(), n);
                            if (messlist.length === 0) {
                                value.messlist = result
                            } else {
                                if (messlist[0] !== result[0]) {
                                    value.messlist = result
                                }
                            }
                        });
                    } catch (e) {
                        logger.info('异步缓存日志异常~~', e);
                    }

                }
                resolve()
            }).then(r => {
                logger.info('异步缓存日志异常~~失败');
            });
        });
    }, intervalInMilliseconds);
}

function cachePredictorState() {
    // 设置定时器，每隔一定时间（比如每隔5秒）发送一次GET请求
    const intervalInMilliseconds = 1500;
    setInterval(() => {
        // logger.info('当前2',robot.appMap);
        var config = getRustConfig()
        robot.appMap.forEach((value, key) => {
            var thisTime = new Date().getTime()
            let port = value.port
            let predictorState = value.predictorState
            if (value.id !== -1 && port !== -1 && value.threadStatus === robot.RobotStatus.RUNNING) {
                logger.info(`~~~缓存机器人状态详情${value.id}`)
                var accUrl = "http://127.0.0.1:" + port
                http.request_get(`${accUrl}/predictor_state`, {...config.headers})
                    .then((data) => {
                        let result = JSON.parse(data);
                        if (predictorState.length === 0) {
                            value.predictorState = result
                        } else {
                            if (predictorState[0] !== predictorState[0]) {
                                value.predictorState = result
                            }
                        }
                    }).catch((error) => {
                    logger.info(`异步缓存predictorState异常~~ ${error.message}`)
                });
            }
        });
    }, intervalInMilliseconds);
}

module.exports = {
    init
};