#include "AutoCall.h"
#include "JdbcHelper.h"
#include "Log.h"
#include <thread>

AutoCall::AutoCall() :m_IsStop(false), fun(nullptr)
{
	
}

AutoCall::~AutoCall()
{
	m_IsStop = true;
}

void AutoCall::startTask()
{
	m_IsStop = false;
	std::thread(std::bind(&AutoCall::__threadFun, this)).detach();
}

void AutoCall::stopTask()
{
	m_IsStop = true;
}

void AutoCall::addTask()
{
	std::string sql = "select id,agent,number,type,content from task where state = 0";
	JdbcHelper::GetInstance()->jdbc_executeQuery(sql, [=](sql::PreparedStatement* stmt) {
	}, [&](sql::ResultSet* result) {
		while (result->next())  
		{
			Task task;
			task.id = result->getInt("id");
			task.agent = result->getString("agent");
			task.number = result->getString("number");
			task.type = result->getInt("type");
			task.content = result->getString("content");

			// 判断等待队列是否
			volatile bool isExist = false;
			if (task.type == 2)
			{
				std::unique_lock<std::mutex>lock(mutWait);
				auto it = m_WaitTasks.begin();
				while (it != m_WaitTasks.end())
				{
					if (it->second.agent == task.agent)  // 任务中已存在该坐席呼叫，则加入等待队列
					{
						m_WaitTasks.insert(std::make_pair(task.id, task));
						isExist = true;
						break;
					}
					++it;
				}
			}

			// 如果等待任务中不存在，再次判断任务中是否存在
			if(!isExist)
			{
				volatile bool isFirst = true;
				
				if (task.type == 2) // 如果指定坐席呼叫，只有第一个进入直接呼叫，之后的放入等待队列
				{
					{
						std::unique_lock<std::mutex>lock(mut);
						auto it = m_Tasks.begin();
						while (it != m_Tasks.end())
						{
							if (it->second.agent == task.agent)  // 任务中已存在该坐席呼叫，则加入等待队列
							{
								isFirst = false;
								break;
							}
							++it;
						}

						if (isFirst)
							m_Tasks.insert(std::make_pair(task.id, task));
					}
					
					if(!isFirst)
					{
						std::unique_lock<std::mutex>lock(mutWait);
						m_WaitTasks.insert(std::make_pair(task.id, task));
					}
				}
				
				if(task.type !=2 )
				{
					std::unique_lock<std::mutex>lock(mut);
					m_Tasks.insert(std::make_pair(task.id, task));
				}
				
			}
			
		}
	}, NULL);

	con.notify_one();
}

void AutoCall::waitTask(std::string agentId)
{
	Task task;
	{
		std::unique_lock<std::mutex>lock(mutWait);
		auto it = m_WaitTasks.begin();
		while (it != m_WaitTasks.end())
		{
			if (it->second.agent == agentId)
			{
				task = it->second;
				m_WaitTasks.erase(it);
				break;
			}
			++it;
		}
	}
	if (this->fun != nullptr && task.id != 0)
		this->fun(task);
}

void AutoCall::updateTask(std::string id)
{
	if (id.empty()) return;
	std::string sql = "update task set state = 1,op_time = now() where id = ";
	sql.append(id);
	JdbcHelper::GetInstance()->jdbc_executeUpdate(sql,NULL,NULL);

	{
		std::unique_lock<std::mutex>lock(mut);
		m_Tasks.erase(atoi(id.c_str()));
	}
	{
		std::unique_lock<std::mutex>lock(mutWait);
		m_WaitTasks.erase(atoi(id.c_str()));
	}
}

void AutoCall::__threadFun()
{
	while (!m_IsStop)
	{
		if(!__dealTask())
		{
			std::unique_lock<std::mutex>lock(mut);
			con.wait(lock);
		}
	}
}

bool AutoCall::__dealTask()
{
	Task task;
	{
		std::unique_lock<std::mutex>lock(mut);
		auto it = m_Tasks.begin();
		if (it == m_Tasks.end())
			return false;
		task = it->second;
		m_Tasks.erase(it);
	}
	if (this->fun != nullptr && task.id != 0)
		this->fun(task);
	return !m_Tasks.empty();
}