#include "BaseApplication.h"

void ApplicationTask(void *arg);

#if BASEAPPLICATION_USING_EVENT
void EventTask(void *arg);
#endif

/**
 * @brief 启动或从暂停状态继续运行程序
 */
void BaseApplication::Run(void)
{
    if (ApplicationRunFlag != true) // 程序未运行
    {
        ApplicationRunFlag = true;
        ApplicationExitFlag = false;
        ApplicationPauseFlag = false;

#if BASEAPPLICATION_USING_EVENT
        // 创建队列
        eventQueue = xQueueCreate(BASEAPPLICATION_EVENT_QUEUE_LENGTH, sizeof(int));
#endif

        xTaskCreate(
            ApplicationTask,
            "app task",
            _stackDepth,
            (void *)this,
            2,
            &taskHandle); // 创建线程
    }
    else if (ApplicationPauseFlag == true) // 程序已运行但被挂起
    {
        ApplicationPauseFlag = false;
        vTaskResume(taskHandle); // 解挂任务
    }
}

/**
 * @brief 暂停程序运行
 */
void BaseApplication::Pause(void)
{
    if (ApplicationRunFlag == true && ApplicationPauseFlag != true) // 程序已运行但未被挂起
    {
        ApplicationPauseFlag = true;
        vTaskSuspend(taskHandle); // 挂起任务
    }
}

/**
 * @brief 添加子程序
 */
void BaseApplication::AddChild(BaseApplication *child)
{
    if (child == nullptr)
        return;

    if (childList == nullptr)
        childList = new std::vector<BaseApplication *>();

    child->parent = this; // 设置子程序的父对象为当前对象
    childList->push_back(child);
}

/**
 * @brief 运行某个子程序并暂停自身
 */
void BaseApplication::RunChild(int index)
{
    if (childList == nullptr) // 空列表
        return;

    if ((size_t)index >= childList->size()) // 索引过大
        return;

    this->Pause(); // 暂停当前程序

    (*childList)[index]->Run(); // 运行新的程序
}

BaseApplication::BaseApplication(uint32_t stackDepth)
{
    childList = nullptr;
    parent = nullptr;
    ApplicationRunFlag = false;
    ApplicationExitFlag = false;
    ApplicationPauseFlag = false;
    _stackDepth = stackDepth;

#if BASEAPPLICATION_USING_EVENT
    eventTaskStackDepth = defaultEventTaskStackDepth;
#endif
}

BaseApplication::~BaseApplication()
{
    if (ApplicationRunFlag == true) // 程序未调用Stop结束
    {
        this->Stop();

        if (ApplicationPauseFlag == true) // 程序已被挂起
        {
            ApplicationPauseFlag = false;
            vTaskResume(taskHandle); // 解挂任务
        }
    }

    while (ApplicationExitFlag != true)
        vTaskDelay(1); // 等待线程退出

    if (childList != nullptr)
        delete childList;
}

#if BASEAPPLICATION_USING_EVENT
/**
 * @brief 向应用程序发送事件
 * @param event 事件
 * @note 会检查并发送给当前程序树正在运行的程序
 */
bool BaseApplication::SendEvent(int event)
{
    if (ApplicationRunFlag && !ApplicationPauseFlag) // 当前程序正在运行
        return xQueueSend(eventQueue, &event, 0);
    else if (childList != nullptr) // 遍历子程序列表
    {
        for (auto &child : *childList)
        {
            bool ret = child->SendEvent(event);
            if (ret)
                return ret;
        }
    }

    return false;
}
#endif

/**
 * @brief 程序线程
 */
void ApplicationTask(void *arg)
{
    auto base = static_cast<BaseApplication *>(arg);

#if BASEAPPLICATION_USING_EVENT
    xTaskCreate(
        EventTask,
        "event task",
        base->eventTaskStackDepth,
        (void *)base,
        2,
        nullptr); // 创建事件处理线程
#endif

    base->Setup();

    while (base->ApplicationRunFlag)
    {
        base->Loop();
    }

    base->Exit();

    if (base->parent != nullptr)
        base->parent->Run(); // 恢复父对象运行

#if BASEAPPLICATION_USING_EVENT
    xQueueSend(base->eventQueue, &BaseApplication::quitEvent, portMAX_DELAY); // 发送事件，令事件处理线程退出
#endif

    base->ApplicationExitFlag = true;
    vTaskDelete(nullptr); // 删除任务
}

#if BASEAPPLICATION_USING_EVENT

/**
 * @brief 程序事件接收处理线程
 */
void EventTask(void *arg)
{
    auto base = static_cast<BaseApplication *>(arg);

    while (1)
    {
        int event;
        if (xQueueReceive(base->eventQueue, &event, portMAX_DELAY) == pdTRUE)
            base->EventHandler(event);

        if (event == BaseApplication::quitEvent) // 收到退出事件
            break;
    }

    vTaskDelete(nullptr); // 删除任务
}

#endif