//
// Created by huli on 2020/7/20.
//

#include "dispatch_manager.h"
#include <cstdlib>

Dispatch_manager::Dispatch_manager()
{
	m_dispatch_manager_status = E_DISPATCH_MANAGER_UNKNOW;
	m_dispatch_id = -1;

	m_catcher_size = 0;
	m_carrier_size = 0;
	m_passageway_size = 0;

	m_process_thread_queue = nullptr;
	m_dispatch_manager_thread = nullptr;

}

Dispatch_manager::~Dispatch_manager()
{
	dispatch_manager_uninit();
}



//调度管理 初始化
Error_manager Dispatch_manager::dispatch_manager_init(int dispatch_id)
{
	m_dispatch_id = dispatch_id;

	m_catcher_size = 2;
	for (int i = 0; i < m_catcher_size; ++i)
	{
		std::shared_ptr<Catcher> tp_catcher(new Catcher);
		tp_catcher->dispatch_device_base_init(i);
		m_catcher_map[i] = tp_catcher;
	}

	m_carrier_size = 3;
	for (int i = 0; i < m_carrier_size; ++i)
	{
		std::shared_ptr<Carrier> tp_carrier(new Carrier);
		tp_carrier->dispatch_device_base_init(i);
		m_carrier_map[i] = tp_carrier;
	}

	m_passageway_size = 8;
	for (int i = 0; i < m_passageway_size; ++i)
	{
		std::shared_ptr<Passageway> tp_passageway(new Passageway);
		tp_passageway->dispatch_device_base_init(i);
		m_passageway_map[i] = tp_passageway;
	}

	//创建线程池
	if (m_process_thread_queue == nullptr) {
		m_process_thread_queue = tq::TQFactory::CreateDefaultQueue();
		m_process_thread_queue->Start(48);
	}

	
	m_dispatch_manager_status = E_DISPATCH_MANAGER_READY;
	return Error_code::SUCCESS;
}
//调度管理 反初始化
Error_manager Dispatch_manager::dispatch_manager_uninit()
{
	if (m_dispatch_manager_thread)
	{
		m_dispatch_manager_condition.kill_all();
	}
	if (m_dispatch_manager_thread)
	{
		m_dispatch_manager_thread->join();
		delete m_dispatch_manager_thread;
		m_dispatch_manager_thread = NULL;
	}

	//等待线程池完成
	if(m_process_thread_queue!=nullptr) {
		m_process_thread_queue->WaitForFinish();
		m_process_thread_queue->Stop();
		m_process_thread_queue = nullptr;
	}

	m_dispatch_manager_status = E_DISPATCH_MANAGER_UNKNOW;
	m_dispatch_id = -1;


//	for (int i = 0; i < m_catcher_size; ++i)
//	{
//		m_catcher_vector[i]->dispatch_device_base_uninit();
//		delete(m_catcher_vector[i]);
//	}
//	m_catcher_size = 0;
//	m_catcher_vector.clear();
//
//	for (int i = 0; i < m_carrier_size; ++i)
//	{
//		m_carrier_vector[i]->dispatch_device_base_uninit();
//		delete(m_carrier_vector[i]);
//	}
//	m_carrier_size = 0;
//	m_carrier_vector.clear();
//
//	for (int i = 0; i < m_passageway_size; ++i)
//	{
//		m_passageway_vector[i]->dispatch_device_base_uninit();
//		delete(m_passageway_vector[i]);
//	}
//	m_passageway_size = 0;
//	m_passageway_vector.clear();


	return Error_code::SUCCESS;
}

//对外的接口函数，负责接受并处理任务单，
Error_manager Dispatch_manager::execute_task(Dispatch_manager::Dispatch_motion_direction dispatch_motion_direction)
{
return Error_code::SUCCESS;
//	std::this_thread::sleep_for(std::chrono::seconds(rand()%3+3));

	if ( dispatch_motion_direction == E_PICKUP_CAR )
	{
		return Error_code::SUCCESS;
	}

//	return Error_code::SUCCESS;

//	srand(0);
	unsigned int t_probability = rand();

	if ( t_probability%100 >=20 )
	{
	    return Error_code::SUCCESS;
	}
	else
	{
	    return Error_manager(Error_code::ERROR, Error_level::MINOR_ERROR,
	    					" Dispatch_manager::execute_task() error ");
	}
}

//检查状态
Error_manager Dispatch_manager::check_status()
{
	if ( m_dispatch_manager_status == E_DISPATCH_MANAGER_READY )
	{
		return Error_code::SUCCESS;
	}
	else if ( m_dispatch_manager_status == E_DISPATCH_MANAGER_STORE || m_dispatch_manager_status == E_DISPATCH_MANAGER_STORE )
	{
		return Error_manager(Error_code::DISPATCH_MANAGER_STATUS_BUSY, Error_level::NEGLIGIBLE_ERROR,
							 " Dispatch_manager::check_status() error ");
	}
	else
	{
		return Error_manager(Error_code::DISPATCH_MANAGER_STATUS_ERROR, Error_level::MINOR_ERROR,
							 " Dispatch_manager::check_status() error ");
	}
	return Error_code::SUCCESS;
}

//在流程的map 里面释放指定的流程
Error_manager Dispatch_manager::release_dispatch_process(std::string command_key)
{
	std::unique_lock<std::mutex> t_lock(m_lock);

	auto iter1 = m_key_to_dispatch_process_store_map.find(command_key);
	if ( iter1 != m_key_to_dispatch_process_store_map.end())
	{
		m_key_to_dispatch_process_store_map.erase(iter1);
	}

	auto iter2 = m_key_to_dispatch_process_pickup_map.find(command_key);
	if ( iter2 != m_key_to_dispatch_process_pickup_map.end())
	{
		m_key_to_dispatch_process_pickup_map.erase(iter2);
	}
	return Error_code::SUCCESS;
}








Dispatch_manager::Dispatch_manager_status Dispatch_manager::get_dispatch_manager_status()
{
	return m_dispatch_manager_status;
}

int Dispatch_manager::get_dispatch_id()
{
	return m_dispatch_id;
}
void Dispatch_manager::set_dispatch_id(int dispatch_id)
{
	m_dispatch_id = dispatch_id;
}