#ifndef HXTASK_H
#define HXTASK_H

#include "HxTrace.h"
#include <QtConcurrent>

class HxTask
{
public:
    /**
     * @brief 停止
     * @param uuid 任务唯一编码
     */
    static void stop(QString uuid)
    {
        if (dispatchers.contains(uuid))
        {
            dispatchers[uuid] = false;
        }
    }

    /**
     * @brief 等待结果
     * @param functor 函数, 返回值为 bool
     * @param millisecond 最大等待时长
     */
    template <typename Functor>
    static bool wait(Functor functor, int millisecond)
    {
        auto timestamp = QDateTime::currentDateTime();

        while(!functor())
        {
            if (QDateTime::currentDateTime() > timestamp.addMSecs(millisecond))
                return false;

            QThread::msleep(10);
        }

        return true;
    }

    template <typename Functor, typename Arg1>
    static QFuture<void> invoke(Functor functor, const Arg1 &arg1) { return QtConcurrent::run(functor, arg1); }

    template <typename Functor, typename Arg1, typename Arg2>
    static QFuture<void> invoke(Functor functor, const Arg1 &arg1, const Arg2 &arg2) { return QtConcurrent::run(functor, arg1, arg2); }

    template <typename Functor, typename Arg1, typename Arg2, typename Arg3>
    static QFuture<void> invoke(Functor functor, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3) { return QtConcurrent::run(functor, arg1, arg2, arg3); }

    /**
     * @brief 异步执行
     * @param functor 函数
     */
    template <typename Functor>
    static QFuture<void> invoke(Functor functor) { return QtConcurrent::run(functor); }

    /**
     * @brief 异步执行
     * @param functor 函数
     * @param millisecond 函数执行间隔频率，单位毫秒
     * @param uuid 任务唯一编码
     */
    template <typename Functor>
    static void run(Functor functor, int millisecond, QString uuid)
    {
        dispatchers.insert(uuid, true);

        QtConcurrent::run(
            [=](Functor functor, int _millisecond, QString _uuid)
            {
                HxTrace::debug_write_line("HxTask", QString("Thread: %1, start").arg(_uuid));

                while (dispatchers[_uuid])
                {
                    functor();

                    QThread::msleep(_millisecond);
                }

                HxTrace::debug_write_line("HxTask", QString("Thread: %1, stop").arg(_uuid));

                dispatchers.remove(_uuid);
            },
            functor, millisecond, uuid);
    }

    /**
     * @brief 异步执行
     * @param object 操作对象类
     * @param fn 操作对象类中的成员函数
     */
    template <typename T, typename Class>
    static void run(Class *object, T (Class::*fn)())
    {
        QtConcurrent::run(
            [=](Class *_object, T (Class::*_fn)())
            {
                (_object->*_fn)();
            },
            object, fn);
    }

    /**
     * @brief 异步执行线程
     * @param object 操作对象类
     * @param fn 操作对象类中的成员函数
     * @param millisecond 函数执行间隔频率，单位毫秒
     * @param uuid 任务唯一编码
     */
    template <typename T, typename Class>
    static void run(Class *object, T (Class::*fn)(), int millisecond, QString uuid)
    {
        dispatchers.insert(uuid, true);

        QtConcurrent::run(
            [=](Class *_object, T (Class::*_fn)(), int _millisecond, QString _uuid)
            {
                HxTrace::debug_write_line("HxTask", QString("Thread: %1, start").arg(_uuid));

                while (dispatchers[_uuid])
                {
                    (_object->*_fn)();

                    QThread::msleep(_millisecond);
                }

                HxTrace::debug_write_line("HxTask", QString("Thread: %1, stop").arg(_uuid));

                dispatchers.remove(_uuid);
            },
            object, fn, millisecond, uuid);
    }

    /**
     * @brief 任务并行
     * @param object 操作对象类
     * @param fn1 操作对象类中的成员函数1
     * @param millisecond1 函数1执行间隔频率，单位毫秒
     * @param fn2 操作对象类中的成员函数2
     * @param millisecond2 函数2执行间隔频率，单位毫秒
     * @return 任务唯一编码
     */
    template <typename T, typename Class>
    static QUuid invoke(Class *object, T (Class::*fn1)(), int millisecond1, T (Class::*fn2)(), int millisecond2)
    {
        QUuid uuid = QUuid::createUuid();

        HxTask::run(uuid, object, fn1, millisecond1);
        HxTask::run(uuid, object, fn2, millisecond2);

        return uuid;
    }

    /**
     * @brief 任务并行
     * @param uuid 任务唯一编码
     * @param object 操作对象类
     * @param fn1 操作对象类中的成员函数1
     * @param millisecond1 函数1执行间隔频率，单位毫秒
     * @param fn2 操作对象类中的成员函数2
     * @param millisecond2 函数2执行间隔频率，单位毫秒
     * @return 任务唯一编码
     */
    template <typename T, typename Class>
    static void invoke(QUuid uuid, Class *object, T (Class::*fn1)(), int millisecond1, T (Class::*fn2)(), int millisecond2)
    {
        HxTask::run(uuid, object, fn1, millisecond1);
        HxTask::run(uuid, object, fn2, millisecond2);
    }

    /**
     * @brief 任务并行
     * @param object 操作对象类
     * @param fn1 操作对象类中的成员函数1
     * @param millisecond1 函数1执行间隔频率，单位毫秒
     * @param fn2 操作对象类中的成员函数2
     * @param millisecond2 函数2执行间隔频率，单位毫秒
     * @param fn3 操作对象类中的成员函数3
     * @param millisecond3 函数3执行间隔频率，单位毫秒
     * @return 任务唯一编码
     */
    template <typename T, typename Class>
    static QUuid invoke(Class *object, T (Class::*fn1)(), int millisecond1, T (Class::*fn2)(), int millisecond2, T (Class::*fn3)(), int millisecond3)
    {
        QUuid uuid = QUuid::createUuid();

        HxTask::run(uuid, object, fn1, millisecond1);
        HxTask::run(uuid, object, fn2, millisecond2);
        HxTask::run(uuid, object, fn3, millisecond3);

        return uuid;
    }

    /**
     * @brief 任务并行
     * @param uuid 任务唯一编码
     * @param object 操作对象类
     * @param fn1 操作对象类中的成员函数1
     * @param millisecond1 函数1执行间隔频率，单位毫秒
     * @param fn2 操作对象类中的成员函数2
     * @param millisecond2 函数2执行间隔频率，单位毫秒
     * @param fn3 操作对象类中的成员函数3
     * @param millisecond3 函数3执行间隔频率，单位毫秒
     * @return 任务唯一编码
     */
    template <typename T, typename Class>
    static void invoke(QUuid uuid, Class *object, T (Class::*fn1)(), int millisecond1, T (Class::*fn2)(), int millisecond2, T (Class::*fn3)(), int millisecond3)
    {
        HxTask::run(uuid, object, fn1, millisecond1);
        HxTask::run(uuid, object, fn2, millisecond2);
        HxTask::run(uuid, object, fn3, millisecond3);
    }

private:
    /**
     * @brief mutex
     */
    static QMutex mutex;

    /**
     * @brief dispatchers
     */
    static QMap<QString, bool> dispatchers;
};

#endif // HXTASK_H