/**

 * vim: set ts=4 :

 * ================================================================

 * SourceMod

 * Copyright (C) 2004-2007 AlliedModders LLC.  All rights reserved.

 * ================================================================

 *

 * This program is free software; you can redistribute it and/or 

 * modify it under the terms of the GNU General Public License, 

 * version 3.0, as published by the Free Software Foundation.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program.  If not, see <http://www.gnu.org/licenses/>.

 *

 * As a special exception, AlliedModders LLC gives you permission to 

 * link the code of this program (as well as its derivative works) to 

 * "Half-Life 2," the "Source Engine," the "SourcePawn JIT," and any 

 * Game MODs that run on software by the Valve Corporation.  You must 

 * obey the GNU General Public License in all respects for all other 

 * code used. Additionally, AlliedModders LLC grants this exception 

 * to all derivative works. AlliedModders LLC defines further 

 * exceptions, found in LICENSE.txt (as of this writing, version 

 * JULY-31-2007), or <http://www.sourcemod.net/license.php>.

 *

 * Version: $Id$

 */

#include "BaseWorker.h"

BaseWorker::BaseWorker(IThreadWorkerCallbacks *hooks) : 

	m_perFrame(SM_DEFAULT_THREADS_PER_FRAME),

	m_state(Worker_Stopped),

	m_pHooks(hooks)

{

}

BaseWorker::~BaseWorker()

{

	if (m_state != Worker_Stopped || m_state != Worker_Invalid)

		Stop(true);

	if (m_ThreadQueue.size())

		Flush(true);

}

void BaseWorker::MakeThread(IThread *pThread)

{

	ThreadParams pt;

	pt.flags = Thread_AutoRelease;

	pt.prio = ThreadPrio_Normal;

	MakeThread(pThread, &pt);

}

IThreadHandle *BaseWorker::MakeThread(IThread *pThread, ThreadFlags flags)

{

	ThreadParams pt;

	pt.flags = flags;

	pt.prio = ThreadPrio_Normal;

	return MakeThread(pThread, &pt);

}

IThreadHandle *BaseWorker::MakeThread(IThread *pThread, const ThreadParams *params)

{

	if (m_state != Worker_Running)

		return NULL;

	SWThreadHandle *swt = new SWThreadHandle(this, params, pThread);

	AddThreadToQueue(swt);

	return swt;

}

void BaseWorker::GetPriorityBounds(ThreadPriority &max, ThreadPriority &min)

{

	max = ThreadPrio_Normal;

	min = ThreadPrio_Normal;

}

unsigned int BaseWorker::Flush(bool flush_cancel)

{

	SWThreadHandle *swt;

	unsigned int num = 0;

	while ((swt=PopThreadFromQueue()) != NULL)

	{

		swt->m_state = Thread_Done;

		if (!flush_cancel)

			swt->pThread->RunThread(swt);

		swt->pThread->OnTerminate(swt, flush_cancel);

		if (swt->m_params.flags & Thread_AutoRelease)

			delete swt;

		num++;

	}

	return num;

}

SWThreadHandle *BaseWorker::PopThreadFromQueue()

{

	if (!m_ThreadQueue.size())

		return NULL;

	SourceHook::List<SWThreadHandle *>::iterator begin;

	SWThreadHandle *swt;

	begin = m_ThreadQueue.begin();

	swt = (*begin);

	m_ThreadQueue.erase(begin);

	return swt;

}

void BaseWorker::AddThreadToQueue(SWThreadHandle *pHandle)

{

	m_ThreadQueue.push_back(pHandle);

}

unsigned int BaseWorker::GetMaxThreadsPerFrame()

{

	return m_perFrame;

}

WorkerState BaseWorker::GetStatus(unsigned int *threads)

{

	if (threads)

		*threads = m_perFrame;

	return m_state;

}

unsigned int BaseWorker::RunFrame()

{

	unsigned int done = 0;

	unsigned int max = GetMaxThreadsPerFrame();

	SWThreadHandle *swt = NULL;

	IThread *pThread = NULL;

	while (done < max)

	{

		if ((swt=PopThreadFromQueue()) == NULL)

		{

			break;

		}

		pThread = swt->pThread;

		swt->m_state = Thread_Running;

		pThread->RunThread(swt);

		swt->m_state = Thread_Done;

		pThread->OnTerminate(swt, false);

		if (swt->m_params.flags & Thread_AutoRelease)

		{

			delete swt;

		}

		done++;

	}

	return done;

}

void BaseWorker::SetMaxThreadsPerFrame(unsigned int threads)

{

	m_perFrame = threads;

}

bool BaseWorker::Start()

{

	if (m_state != Worker_Invalid && m_state != Worker_Stopped)

	{

		return false;

	}

	m_state = Worker_Running;

	if (m_pHooks)

	{

		m_pHooks->OnWorkerStart(this);

	}

    return true;

}

bool BaseWorker::Stop(bool flush_cancel)

{

	if (m_state == Worker_Invalid || m_state == Worker_Stopped)

	{

		return false;

	}

	if (m_state == Worker_Paused)

	{

		if (!Unpause())

		{

			return false;

		}

	}

	m_state = Worker_Stopped;

	Flush(flush_cancel);

	if (m_pHooks)

	{

		m_pHooks->OnWorkerStop(this);

	}

	return true;

}

bool BaseWorker::Pause()

{

	if (m_state != Worker_Running)

	{

		return false;

	}

	m_state = Worker_Paused;

	return true;

}

bool BaseWorker::Unpause()

{

	if (m_state != Worker_Paused)

	{

		return false;

	}

	m_state = Worker_Running;

	return true;

}

/***********************

 * THREAD HANDLE STUFF *

 ***********************/

void SWThreadHandle::DestroyThis()

{

	delete this;

}

void SWThreadHandle::GetParams(ThreadParams *p)

{

	*p = m_params;

}

ThreadPriority SWThreadHandle::GetPriority()

{

	return m_params.prio;

}

ThreadState SWThreadHandle::GetState()

{

	return m_state;

}

IThreadCreator *SWThreadHandle::Parent()

{

	return m_parent;

}

bool SWThreadHandle::SetPriority(ThreadPriority prio)

{

	if (m_params.prio != ThreadPrio_Normal)

		return false;

	m_params.prio = prio;

	return true;

}

bool SWThreadHandle::Unpause()

{

	if (m_state != Thread_Paused)

		return false;

	m_state = Thread_Running;

	return true;

}

bool SWThreadHandle::WaitForThread()

{

	return false;

}

SWThreadHandle::SWThreadHandle(IThreadCreator *parent, const ThreadParams *p, IThread *thread) : 

	m_state(Thread_Paused), m_params(*p), m_parent(parent), pThread(thread)

{

}

IThread *SWThreadHandle::GetThread()

{

	return pThread;

}