using Task = std::function<void()>;

template<typename Func,typename... Args> //右值引用，引用折疊，可變參

auto submitTask(Func&& func, Args&&... args) -> std::future<decltype(func(args...))>
{
	//打包任務(wù) 放入任務(wù)隊列里面
	using RType = decltype(func(args...));  //返回值類型
	auto task = std::make_shared<std::packaged_task<RType()>>(
		std::bind(std::forward<Func>(func), std::forward<Args>(args)...)); //forward保持左值或者右值特性
	std::future<RType> result = task->get_future(); //把參數(shù)全部綁定到函數(shù)上


	//獲取鎖
	std::unique_lock<std::mutex> lock(taskQueMtx_);


	if (!notFull_.wait_for(lock, std::chrono::seconds(1),
		[&]()->bool {return taskQue_.size() < (size_t)taskQueMaxThresHold_; }))
	{

		std::cerr << "task queue is full,submit task fail." << std::endl;
		auto task = std::make_shared<std::packaged_task<RType()>>(
			[]()->RType { return RType(); }); 
		(*task)(); 
		return task->get_future();;
	}

	taskQue_.emplace([task]() {
		(*task)(); }); 
		
	taskSize_++;


	notEmpty_.notify_all();


	if (poolMode_ == PoolMode::MODE_CACHED
		&& taskSize_ > idleThreadSize_
		&& curThreadSize_ < threadSizeThresHold_)
	{

		std::cout << ">>> create new thread" << std::endl;

		//創(chuàng)建thread線程對象
		auto ptr = std::make_unique<Thread>(std::bind(&ThreadPool::threadFunc, this, std::placeholders::_1));
		//threads_.emplace_back(std::move(ptr)); //資源轉(zhuǎn)移
		int threadId = ptr->getId();
		threads_.emplace(threadId, std::move(ptr));
		threads_[threadId]->start(); //啟動線程

		//修改線程個數(shù)相關(guān)的變量
		curThreadSize_++;
		idleThreadSize_++;
	}

	//返回任務(wù)的Result對象
	return result;


}

void threadFunc(int threadid)
{
	auto lastTime = std::chrono::high_resolution_clock().now();
	for (;;)
	{
		Task task;
		{
			//獲取鎖
			std::unique_lock<std::mutex> lock(taskQueMtx_);
			std::cout << "tid:" << std::this_thread::get_id()<< "嘗試獲取任務(wù)..." << std::endl;

			while (taskQue_.size() == 0)
			{

				if (!isPoolRuning_)
				{
					threads_.erase(threadid);
					std::cout << "threadid:" << std::this_thread::get_id()
						<< "exit!" << std::endl;

					exitCond_.notify_all();
					return;
				}

				if (poolMode_ == PoolMode::MODE_CACHED)
				{	//超時返回std::cv_status::timeout
					if (std::cv_status::timeout ==
						notEmpty_.wait_for(lock, std::chrono::seconds(1)))
					{
						auto now = std::chrono::high_resolution_clock().now();
						auto dur = std::chrono::duration_cast<std::chrono::seconds>(now - lastTime);
						if (dur.count() >= THREAD_MAX_IDLE_TIME&& curThreadSize_ > initThreadSize_)
						{
							threads_.erase(threadid);
							curThreadSize_--;
							idleThreadSize_--;

							std::cout << "threadid:" << std::this_thread::get_id()<< "exit!" << std::endl;
							return;
						}
					}
				}
				else
				{
					//等待notEmpty_條件
					notEmpty_.wait(lock);
				}
			}

			idleThreadSize_--;

			std::cout << "tid:" << std::this_thread::get_id()
				<< "獲取任務(wù)成功..." << std::endl;

			//從任務(wù)隊列中取一個任務(wù)出來
			task = taskQue_.front();
			taskQue_.pop();
			taskSize_--;

			//若依然有剩余任務(wù)，繼續(xù)通知其他線程執(zhí)行任務(wù)
			if (taskQue_.size() > 0)
			{
				notEmpty_.notify_all();
			}
			notFull_.notify_all();
		}

		if (task != nullptr)
		{
			task(); //執(zhí)行std::function<void()>;
		}
		idleThreadSize_++;

		auto lastTime = std::chrono::high_resolution_clock().now();
	}
}

#include <iostream>
#include <functional>
#include <thread>
#include <future>
#include <chrono>

#include "threadpool.h"

using namespace std;


int sum1(int a, int b)
{
	std::this_thread::sleep_for(std::chrono::seconds(5));
	return a + b;
}

int sum2(int a, int b,int c)
{
	std::this_thread::sleep_for(std::chrono::seconds(5));
	return a + b + c;
}

int main()
{
	ThreadPool pool;

	//pool.setMode(PoolMode::MODE_CACHED);

	pool.start(2);

	future<int> res1 = pool.submitTask(sum1, 1, 2);
	future<int> res2 = pool.submitTask(sum2, 1, 2,3);
	future<int> res3 = pool.submitTask([](int d, int e)->int {
		int sum = 0;
		for (int i = d; i < e; i++)
			sum += i;
		return sum;
		},1, 100);

	future<int> res4 = pool.submitTask([](int d, int e)->int {
		int sum = 0;
		for (int i = d; i < e; i++)
			sum += i;
		return sum;
		}, 1, 100);

	future<int> res5 = pool.submitTask([](int d, int e)->int {
		int sum = 0;
		for (int i = d; i < e; i++)
			sum += i;
		return sum;
		}, 1, 100);

	cout << res1.get() << endl;
	cout << res2.get() << endl;
	cout << res3.get() << endl;
	cout << res4.get() << endl;
	cout << res5.get() << endl;
}