/**

  * vim: set ts=4 :

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

  * SourceMod

  * Copyright (C) 2004-2008 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 "ThreadWorker.h"

 ThreadWorker::ThreadWorker(IThreadWorkerCallbacks *hooks) : BaseWorker(hooks),

 	m_Threader(NULL),

 	me(NULL),

 	m_think_time(DEFAULT_THINK_TIME_MS)

 {

 	m_state = Worker_Invalid;

 }

 ThreadWorker::ThreadWorker(IThreadWorkerCallbacks *hooks, IThreader *pThreader, unsigned int thinktime) : 

 	BaseWorker(hooks),

 	m_Threader(pThreader),

 	me(NULL),

 	m_think_time(thinktime)

 {

 	m_state = m_Threader ? Worker_Stopped : Worker_Invalid;

 }

 ThreadWorker::~ThreadWorker()

 {

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

 		Stop(true);

 	if (m_ThreadQueue.size())

 		Flush(true);

 }

 void ThreadWorker::OnTerminate(IThreadHandle *pHandle, bool cancel)

 {

 	//we don't particularly care

 	return;

 }

 void ThreadWorker::RunThread(IThreadHandle *pHandle)

 {

 	if (m_pHooks)

 		m_pHooks->OnWorkerStart(this);

 	ke::AutoLock lock(&monitor_);

 	while (true)

 	{

 		if (m_state == Worker_Paused)

 		{

 			// Wait until we're told to wake up.

 			monitor_.Wait();

 			continue;

 		}

 		if (m_state == Worker_Stopped)

 		{

 			// We've been told to stop entirely. If we've also been told to

 			// flush the queue, do that now.

 			while (!m_ThreadQueue.empty())

 			{

 				// Release the lock since PopThreadFromQueue() will re-acquire it. The

 				// main thread is blocking anyway.

 				ke::AutoUnlock unlock(&monitor_);

 				RunFrame();

 			}

 			assert(m_state == Worker_Stopped);

 			return;

 		}

 		assert(m_state == Worker_Running);

 		// Process one frame.

 		WorkerState oldstate = m_state;

 		{

 			ke::AutoUnlock unlock(&monitor_);

 			RunFrame();

 		}

 		// If the state changed, loop back and process the new state.

 		if (m_state != oldstate)

 			continue;

 		// If the thread queue is now empty, wait for a signal. Otherwise, if

 		// we're on a delay, wait for either a notification or a timeout to

 		// process the next item. If the queue has items and we don't have a

 		// delay, then we just loop around and keep processing.

 		if (m_ThreadQueue.empty())

 			monitor_.Wait();

 		else if (m_think_time)

 			monitor_.Wait(m_think_time);

 	}

 	{

 		ke::AutoUnlock unlock(&monitor_);

 		if (m_pHooks)

 			m_pHooks->OnWorkerStop(this);

 	}

 }

 SWThreadHandle *ThreadWorker::PopThreadFromQueue()

 {

 	ke::AutoLock lock(&monitor_);

 	if (m_state <= Worker_Stopped)

 		return NULL;

 	return BaseWorker::PopThreadFromQueue();

 }

 void ThreadWorker::AddThreadToQueue(SWThreadHandle *pHandle)

 {

 	ke::AutoLock lock(&monitor_);

 	if (m_state <= Worker_Stopped)

 		return;

 	BaseWorker::AddThreadToQueue(pHandle);

 	monitor_.Notify();

 }

 WorkerState ThreadWorker::GetStatus(unsigned int *threads)

 {

 	ke::AutoLock lock(&monitor_);

 	return BaseWorker::GetStatus(threads);

 }

 void ThreadWorker::SetThinkTimePerFrame(unsigned int thinktime)

 {

 	m_think_time = thinktime;

 }

 bool ThreadWorker::Start()

 {

 	if (m_state == Worker_Invalid && m_Threader == NULL)

 		return false;

 	if (m_state != Worker_Stopped)

 		return false;

 	m_state = Worker_Running;

 	ThreadParams pt;

 	pt.flags = Thread_Default;

 	pt.prio = ThreadPrio_Normal;

 	me = m_Threader->MakeThread(this, &pt);

 	return true;

 }

 bool ThreadWorker::Stop(bool flush_cancel)

 {

 	// Change the state to signal a stop, and then trigger a notify.

 	{

 		ke::AutoLock lock(&monitor_);

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

 			return false;

 		m_state = Worker_Stopped;

 		m_FlushType = flush_cancel;

 		monitor_.Notify();

 	}

 	me->WaitForThread();

 	//destroy it

 	me->DestroyThis();

 	//flush all remaining events

 	Flush(true);

 	me = NULL;

 	return true;

 }

 bool ThreadWorker::Pause()

 {

 	if (m_state != Worker_Running)

 		return false;

 	ke::AutoLock lock(&monitor_);

 	m_state = Worker_Paused;

 	monitor_.Notify();

 	return true;

 }

 bool ThreadWorker::Unpause()

 {

 	if (m_state != Worker_Paused)

 		return false;

 	ke::AutoLock lock(&monitor_);

 	m_state = Worker_Running;

 	monitor_.Notify();

 	return true;

 }