#include "TaskManager.h"

#include "Logger.h"
#include "Common.h"
#include "Util.h"
#include "ConfigFile.h"

#include <time.h>

#include "tasks/SpoolTask.h"


TaskManager::TaskManager()
		: _lastExecuted(0)
{
}

TaskManager::~TaskManager()
{
	//delete any temporary tasks still in the list
	std::list<Task*>::iterator it;
	for (it = _temp_tasks.begin(); it != _temp_tasks.end(); ++it)
	{
		delete (*it);
	}
}

Task* TaskManager::CreateTask(const std::string& taskName, const std::map<std::string, std::string>& arguments)
{
	if (taskName =="spool")
		return new SpoolTask();

	return 0;
}

void TaskManager::DestroyTasks()
{
	std::map<std::string, Task*>::iterator it;
	for (it = _persistant_tasks.begin(); it != _persistant_tasks.end(); ++it)
	{
		delete it->second;
	}
	_persistant_tasks.clear();
}

void TaskManager::LoadTasks()
{

	Logger::logMessage("--------  TaskList  --------");
	std::vector<Value> tasklist = Common::instance()->GetConfigfile()->GetValues("smsdaemon", "task");

	for (unsigned i=0; i<tasklist.size(); i++)
	{
		std::string current = tasklist[i];

		std::string name;
		unsigned pos = current.find(' ');
		std::map<std::string,std::string> args;

		std::string argstr;

		if (pos == std::string::npos)
		{
			name = current;
		}
		else
		{
			name = Util::str_trim(current.substr(0,pos));
			argstr = Util::str_trim(current.substr(pos+1,1024));
			args = ConfigHelper::ParseArguments(argstr);
		}

		Task* task = 0;
		try
		{
			task = CreateTask(name, args );
		}
		catch (std::exception& e)
		{
			Logger::logMessage(std::string("Failed to load task ") + name + " with args: " + argstr);
			Logger::logMessage(std::string("Reason: ") + e.what());
			continue;
		}

		if (task)
			AddPersistantTask(task);
		else
			Logger::logMessage( std::string("Unknown task: ")+name);

	}

	//print the loaded tasks
	std::map<std::string, Task*>::iterator it;
	for (it = _persistant_tasks.begin(); it != _persistant_tasks.end(); ++it)
	{
		Task* tsk = (*it).second;
		if (tsk != 0)
			Logger::logMessage( std::string("Loaded task \"") + tsk->GetName() + "\"" );
	}
}


void TaskManager::AddPersistantTask(Task* task)
{

	if (task != 0)
	{
		std::string name = task->GetName();

		if ( _persistant_tasks[ name ] == 0)
			_persistant_tasks[ name ] = task;
		else
			Logger::logMessage( std::string("AddTask() -- already have a task called ") + name);
	}
	else
	{
		Logger::logMessage("AddTask() -- cannot register a null pointer");
	}
}

void TaskManager::AddTemporaryTask(Task* task)
{
	_temp_tasks.push_back(task);
}


void TaskManager::ExecuteTasks(ISmsTransceiver& modem)
{
	const int SLEEP_TIME = 2; //wait this long between task executions
	int now = time(0);

	if (now < (_lastExecuted + SLEEP_TIME) )
		return;

	_lastExecuted = now;

	//execute real tasks

	std::map<std::string, Task*>::iterator m_it;

	for (m_it = _persistant_tasks.begin(); m_it != _persistant_tasks.end(); ++m_it)
	{
		Task* tsk = (*m_it).second;
		tsk->ExecuteTask(modem);
	}

	//execute temporary tasks

	std::list<Task*>::iterator l_it;
	for (l_it = _temp_tasks.begin(); l_it != _temp_tasks.end(); ++l_it)
	{
		Task* tsk = (*l_it);
		tsk->ExecuteTask(modem);

		if ( tsk->IsFinished() )
		{
			delete tsk;
			l_it = _temp_tasks.erase(l_it);

			//now l_it points to the next element in the list,
			//but since the for() loop will increment it before next iteration we will decrease it here
			--l_it;
		}
	}


}


Task* TaskManager::GetPersistantTask(const std::string& taskname)
{
	return _persistant_tasks[ taskname ];
}