//
// Created by Ht on 2020/8/13.
//

#ifndef LIBDEVCPP_QTASKMANAGER_H
#define LIBDEVCPP_QTASKMANAGER_H

#include <qlibc/QPObjectHolder.h>
#include <qlibc/QTimerEngine.h>
#include <mgbus/ChannelOperator.h>

/**
 *      任务队列管理器
 *          (1) 可以load预定义内置的Task
 *          （2）可从json文件加载任务
 *          （3）任务生命周期管理：
 *              ·加载/卸载任务
 *              ·触发任务：创建线程、并执行任务，任务在执行周期中，可能处于等待状态、需要被消息激活。
 *              ·终止任务：
 *              ·任务休眠、任务激活、任务超时
 *         （4）管理结构：
 *              ·可用任务表
 *              ·激活任务表
 *
 */

namespace jedge {
    /**
     *  任务类：
     *      虚类，需要被继承实现
     */
    class JE_API QBaseTask :
        public qlibc::QData {
    protected:
        std::string name_;

    public:
        explicit QBaseTask() : qlibc::QData () {
            name_ = StringUtils::randomChars(16);
            putString("name", name_);
        }

        explicit QBaseTask(qlibc::QData& data) : qlibc::QData(data){
            name_ = data.getString("name");
            if(name_.empty())
                name_ = StringUtils::randomChars(16);
        }

        const string& taskName() {
            return name_;
        }

    };

    /**
     *  用户定义任务，用于加载Json文件定义的外部任务
     *
     */
    class JE_API QUserTask :
            public QBaseTask {


    };

    using QTaskID = unsigned long;

    class JE_API QTaskRunner :
            public QBaseTask {
        //需要记录Context及Stack
    protected:
        QBaseTask&     task_temp_;
        QTaskID        task_id_;

    public:
        explicit QTaskRunner(QBaseTask& task, QTaskID id) : task_temp_(task), task_id_(id) {}

        virtual bool cancel() {
            return true;
        }

        virtual bool suspend() {
            return true;
        }

        virtual bool resume() {
            return true;
        }

        virtual bool finish() {
            return true;
        }

    };

    using QTaskDefs = qlibc::QPObjectHolder<QBaseTask> ;

    using QTaskPool = qlibc::QPObjectHolder<QTaskRunner> ;

    class JE_API QTaskManager {
    protected:
        ChannelOperator& operator_;

        qlibc::QTimerEngine& timers_;

    protected:
        QTaskDefs    task_defs_;
        QTaskPool    active_task_;

    public:
        explicit QTaskManager(ChannelOperator &opr, qlibc::QTimerEngine& engine) : operator_(opr) , timers_(engine) {
        }

        virtual ~QTaskManager() = default;

        void clearTasks();

    public:
        bool loadTask(const std::string& name, const QBaseTask& task){
            return true;
        }

        bool loadUserDefinedTask(const std::string& taskFile){
            return true;
        }

        bool loadUserDefinedTasks(const std::string& tasksDir){
            return true;
        }

        void unloadTask(const std::string& key){

        }

        //激活一个任务
        int activateTask(const std::string& key) {
            return 0;
        }

        //取消一个任务
        bool cancelTask(const int task_id){
            return true;
        }

        //保存任务
        bool saveActiveTask(const int task_id){
            return true;
        }

        //恢复任务
        bool resumeTask(const int task_id){
            return true;
        }

        //任务日志管理
        void saveTaskLog(const int task_id){

        }

    protected:

        void checkTaskStatus(){

        }

        void clearTimeoutTasks() {

        }

        void pauseActiveTasks(){

        }

        void resumeActiveTasks(){

        }
    };

}

#endif //LIBDEVCPP_QTASKMANAGER_H
