/*
 * @Author: xiewenji 527774126@qq.com
 * @Date: 2025-07-11 11:35:40
 * @LastEditors: xiewenji 527774126@qq.com
 * @LastEditTime: 2025-09-15 10:29:44
 * @FilePath: /BOE_Bounding/AIEngineModule/src/AIMulThreadRunBase.cpp
 * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
 */
#include "AI_Factory.h"
#include <iostream>
#include <chrono>
#include <sys/time.h>
long getcurTime4444()
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return ((long)tv.tv_sec) * 1000 + ((long)tv.tv_usec) / 1000;
}
AIMulThreadRunBase::AIMulThreadRunBase() : m_running_(false), m_processing_count_(0) {}

AIMulThreadRunBase::~AIMulThreadRunBase()
{
    Stop();
}

void AIMulThreadRunBase::Start(int num_threads)
{
    if (m_running_)
        return;
    m_running_ = true;
    m_detnum = 0;
    // num_threads = 2;
    // 仅启动1个线程
    for (int i = 0; i < num_threads; ++i)
    {
        m_workers_.emplace_back(&AIMulThreadRunBase::ThreadLoop, this);
    }
}

void AIMulThreadRunBase::Stop()
{
    m_running_ = false;
    m_task_cv_.notify_all();
    for (auto &t : m_workers_)
    {
        if (t.joinable())
            t.join();
    }
    m_workers_.clear();
}

void AIMulThreadRunBase::SubmitTask(std::shared_ptr<AITask> task)
{
    {
        std::lock_guard<std::mutex> lock(m_task_mutex_);
        m_tasks_.push(task);
    }
    m_processing_count_++;
    m_task_cv_.notify_one();
}

bool AIMulThreadRunBase::PopResult(std::shared_ptr<AITask> &result)
{
    std::lock_guard<std::mutex> lock(m_result_mutex_);
    if (m_results_.empty())
        return false;
    result = m_results_.front();
    m_results_.pop();
    return true;
}

void AIMulThreadRunBase::ThreadLoop()
{
    while (m_running_)
    {

        std::shared_ptr<AITask> task;
        {
            std::unique_lock<std::mutex> lock(m_task_mutex_);
            m_task_cv_.wait(lock, [this]()
                            { return !m_tasks_.empty() || !m_running_; });

            if (!m_running_ && m_tasks_.empty())
                return;

            task = std::move(m_tasks_.front());
            m_tasks_.pop();
        }
        if (task->bclass)
        {
            // 执行推理
            if (task->engine)
            {
                //   std::lock_guard<std::mutex> lock(m_AI_mutex_);
                // long t1 = getcurTime4444();
                task->cls_label = task->engine->AIClass(task->input, &task->cls_score);
                // long t2 = getcurTime4444();
                // printf("det time %d m_tasks_ size %ld\n", t2 - t1,m_tasks_.size());
            }
        }
        else
        {
            // 执行推理
            if (task->engine && task->output)
            {
                //   std::lock_guard<std::mutex> lock(m_AI_mutex_);
                // long t1 = getcurTime4444();
                task->engine->AIDet(task->input, *task->output);
                // long t2 = getcurTime4444();
                // printf("det time %d m_tasks_ size %ld\n", t2 - t1,m_tasks_.size());
            }
        }
        {
            std::lock_guard<std::mutex> lock(m_result_mutex_);
            m_results_.push(task);
        }
        // m_detnum++;
        m_processing_count_--;
    }
}