#include <vector>
#include <queue>
#include <future>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <stdexcept>

class ThreadPool 
{
public:
    //構造函數(shù)：根據(jù)輸入的線程數(shù)（默認硬件并發(fā)數(shù)）創(chuàng)建工作線程。
    //每個工作線程執(zhí)行一個循環(huán)，不斷從任務隊列中取出并執(zhí)行任務。
    //explicit關鍵字防止隱式類型轉(zhuǎn)換
    explicit ThreadPool(size_t threads = std::thread::hardware_concurrency())
        : stop(false) 
    {
        if (threads == 0) 
        {
            threads = 1;
        }

        for (size_t i = 0; i < threads; ++i) 
        {
            workers.emplace_back([this] 
            {
                for (;;) 
                {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(this->queue_mutex);
                        
                        //等待條件：線程通過條件變量等待任務到來或停止信號。(CPU使用率：休眠時接近0%，僅在任務到來時喚醒)
                        //lambda表達式作為謂詞，當條件(停止信號為true 或 任務隊列非空)為真時，才會解除阻塞。
                        this->condition.wait(lock, [this] {
                            return (this->stop || !this->tasks.empty());
                            });

                        /* 傳統(tǒng)忙等待：while (!(stop || !tasks.empty())) {} // 空循環(huán)消耗CPU */

                        if (this->stop && this->tasks.empty())
                        {
                            //如果線程池需要終止且任務隊列為空則直接return
                            return;
                        }

                        //任務提取：從隊列中取出任務并執(zhí)行，使用std::move避免拷貝開銷。
                        task = std::move(this->tasks.front());
                        this->tasks.pop();
                    }
                    //執(zhí)行任務
                    task();
                }
            });
        }
    }

    //任務提交（enqueue方法）
    template<class F, class... Args>
    auto enqueue(F&& f, Args&&... args)
        -> std::future<typename std::result_of<F(Args...)>::type> 
    {
        using return_type = typename std::result_of<F(Args...)>::type;

        //任務封裝：使用std::packaged_task包裝用戶任務，支持異步返回結果。
        //智能指針管理：shared_ptr確保任務對象的生命周期延續(xù)至執(zhí)行完畢。
        //完美轉(zhuǎn)發(fā)：通過std::forward保持參數(shù)的左值/右值特性。
        auto task = std::make_shared<std::packaged_task<return_type()>>(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
            );

        std::future<return_type> res = task->get_future();
        {
            std::unique_lock<std::mutex> lock(queue_mutex);

            if (stop)
            {
                throw std::runtime_error("enqueue on stopped ThreadPool");
            }  

            tasks.emplace([task]() { (*task)(); });
            /* push傳入的對象需要事先構造好，再復制過去插入容器中；
               而emplace則可以自己使用構造函數(shù)所需的參數(shù)構造出對象，并直接插入容器中。
               emplace相比于push省去了復制的步驟，則使用emplace會更加節(jié)省內(nèi)存。*/
        }
        condition.notify_one();
        return res;
    }

    ~ThreadPool() 
    {
        //設置stop標志，喚醒所有線程，等待任務隊列清空。
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread& worker : workers)
        {
            worker.join();
        }
    }

private:
    std::vector<std::thread> workers;        //存儲工作線程對象
    std::queue<std::function<void()>> tasks; //任務隊列，存儲待執(zhí)行的任務

    std::mutex queue_mutex;                  //保護任務隊列的互斥鎖
    std::condition_variable condition;       //線程間同步的條件變量
    bool stop;                               //線程池是否停止標志
};

std::vector<std::thread> workers;        // 工作線程容器
std::queue<std::function<void()>> tasks; // 任務隊列
std::mutex queue_mutex;                  // 隊列互斥鎖
std::condition_variable condition;       // 條件變量
bool stop;                               // 停機標志

explicit ThreadPool(size_t threads = std::thread::hardware_concurrency())
    : stop(false)
{
    if (threads == 0) 
    {
        threads = 1;
    }
        
    for (size_t i = 0; i < threads; ++i) 
    {
        workers.emplace_back([this] { /* 工作線程邏輯 */ });
    }
}

for (;;)
{
    std::function<void()> task;
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        condition.wait(lock, [this] {
            return stop || !tasks.empty();
        });

        if (stop && tasks.empty()) 
        {
           return; 
        }

        task = std::move(tasks.front());
        tasks.pop();
    }
    task();
}

template<class F, class... Args>
auto enqueue(F&& f, Args&&... args)
    -> std::future<typename std::result_of<F(Args...)>::type>

auto task = std::make_shared<std::packaged_task<return_type()>>
    (std::bind(std::forward<F>(f), std::forward<Args>(args)...));

tasks.emplace([task]() { (*task)(); });

~ThreadPool() 
{
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        stop = true;
    }
    condition.notify_all();
    for (auto& worker : workers)
    {
        worker.join();
    }  
}

std::bind(std::forward<F>(f), std::forward<Args>(args)...)

         [任務提交者]
             |
             v
       [packaged_task] <---- shared_ptr ---- [任務隊列]
             |
             v
         [future]

void adjust_workers(size_t new_size) 
{
    if (new_size > workers.size()) 
    {
     	// 擴容邏輯
    } 
    else 
    {
        // 縮容邏輯
    }
}

using Task = std::pair<int, std::function<void()>>; // 優(yōu)先級+任務
   std::priority_queue<Task> tasks;

moodycamel::ConcurrentQueue<std::function<void()>> tasks;

#include <iostream>

int main() 
{
    ThreadPool pool(4);
    
    // 提交普通函數(shù)
    auto future1 = pool.enqueue([](int a, int b) {
        return a + b;
    }, 2, 3);
    
    // 提交成員函數(shù)
    struct Calculator 
    {
        int multiply(int a, int b) 
        { 
            return a * b; 
        }
    } calc;
    auto future2 = pool.enqueue(std::bind(&Calculator::multiply, &calc, 
                                        std::placeholders::_1, 
                                        std::placeholders::_2), 4, 5);
    
    // 異常處理示例
    auto future3 = pool.enqueue([]() -> int {
        throw std::runtime_error("example error");
        return 1;
    });
    
    std::cout << "2+3=" << future1.get() << std::endl;
    std::cout << "4*5=" << future2.get() << std::endl;
    
    try 
    {
        future3.get();
    } 
    catch(const std::exception& e)
    {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }
    
    return 0;
}