/**

  * 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$

  */

 #define _WIN32_WINNT 0x0400

 #include "WinThreads.h"

 #include "ThreadWorker.h"

 IThreadWorker *WinThreader::MakeWorker(IThreadWorkerCallbacks *hooks, bool threaded)

 {

 	if (threaded)

 	{

 		return new ThreadWorker(hooks, this, DEFAULT_THINK_TIME_MS);

 	} else {

 		return new BaseWorker(hooks);

 	}

 }

 void WinThreader::DestroyWorker(IThreadWorker *pWorker)

 {

 	delete pWorker;

 }

 void WinThreader::ThreadSleep(unsigned int ms)

 {

 	Sleep((DWORD)ms);

 }

 IMutex *WinThreader::MakeMutex()

 {

 	WinMutex *pMutex = new WinMutex();

 	return pMutex;

 }

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

 {

 	ThreadParams defparams;

 	defparams.flags = flags;

 	defparams.prio = ThreadPrio_Normal;

 	return MakeThread(pThread, &defparams);

 }

 void WinThreader::MakeThread(IThread *pThread)

 {

 	ThreadParams defparams;

 	defparams.flags = Thread_AutoRelease;

 	defparams.prio = ThreadPrio_Normal;

 	MakeThread(pThread, &defparams);

 }

 DWORD WINAPI Win32_ThreadGate(LPVOID param)

 {

 	WinThreader::ThreadHandle *pHandle = 

 		reinterpret_cast<WinThreader::ThreadHandle *>(param);

 	pHandle->m_run->RunThread(pHandle);

 	ThreadParams params;

 	EnterCriticalSection(&pHandle->m_crit);

 	pHandle->m_state = Thread_Done;

 	pHandle->GetParams(&params);

 	LeaveCriticalSection(&pHandle->m_crit);

 	pHandle->m_run->OnTerminate(pHandle, false);

 	if (params.flags & Thread_AutoRelease)

 		delete pHandle;

 	return 0;

 }

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

 {

 	max = ThreadPrio_Maximum;

 	min = ThreadPrio_Minimum;

 }

 ThreadParams g_defparams;

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

 {

 	if (params == NULL)

 		params = &g_defparams;

 	WinThreader::ThreadHandle *pHandle = 

 		new WinThreader::ThreadHandle(this, NULL, pThread, params);

 	DWORD tid;

 	pHandle->m_thread = 

 		CreateThread(NULL, 0, &Win32_ThreadGate, (LPVOID)pHandle, CREATE_SUSPENDED, &tid);

 	if (!pHandle->m_thread)

 	{

 		delete pHandle;

 		return NULL;

 	}

 	if (pHandle->m_params.prio != ThreadPrio_Normal)

 	{

 		pHandle->SetPriority(pHandle->m_params.prio);

 	}

 	if (!(pHandle->m_params.flags & Thread_CreateSuspended))

 	{

 		pHandle->Unpause();

 	}

 	return pHandle;

 }

 IEventSignal *WinThreader::MakeEventSignal()

 {

 	HANDLE event = CreateEventA(NULL, FALSE, FALSE, NULL);

 	if (!event)

 		return NULL;

 	WinEvent *pEvent = new WinEvent(event);

 	return pEvent;

 }

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

  **** Mutexes ****

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

 WinThreader::WinMutex::WinMutex()

 {

 	InitializeCriticalSection(&m_crit);

 }

 WinThreader::WinMutex::~WinMutex()

 {

 	DeleteCriticalSection(&m_crit);

 }

 bool WinThreader::WinMutex::TryLock()

 {

 	return (TryEnterCriticalSection(&m_crit) != FALSE);

 }

 void WinThreader::WinMutex::Lock()

 {

 	EnterCriticalSection(&m_crit);

 }

 void WinThreader::WinMutex::Unlock()

 {

 	LeaveCriticalSection(&m_crit);

 }

 void WinThreader::WinMutex::DestroyThis()

 {

 	delete this;

 }

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

  * Thread Handles *

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

 WinThreader::ThreadHandle::ThreadHandle(IThreader *parent, HANDLE hthread, IThread *run, const ThreadParams *params) : 

 	m_parent(parent), m_thread(hthread), m_run(run), m_params(*params),

 	m_state(Thread_Paused)

 {

 	InitializeCriticalSection(&m_crit);

 }

 WinThreader::ThreadHandle::~ThreadHandle()

 {

 	if (m_thread)

 	{

 		CloseHandle(m_thread);

 		m_thread = NULL;

 	}

 	DeleteCriticalSection(&m_crit);

 }

 bool WinThreader::ThreadHandle::WaitForThread()

 {

 	if (m_thread == NULL)

 		return false;

 	if (WaitForSingleObject(m_thread, INFINITE) != 0)

 		return false;

 	return true;

 }

 ThreadState WinThreader::ThreadHandle::GetState()

 {

 	ThreadState state;

 	EnterCriticalSection(&m_crit);

 	state = m_state;

 	LeaveCriticalSection(&m_crit);

 	return state;

 }

 IThreadCreator *WinThreader::ThreadHandle::Parent()

 {

 	return m_parent;

 }

 void WinThreader::ThreadHandle::DestroyThis()

 {

 	if (m_params.flags & Thread_AutoRelease)

 		return;

 	delete this;

 }

 void WinThreader::ThreadHandle::GetParams(ThreadParams *ptparams)

 {

 	if (!ptparams)

 		return;

 	*ptparams = m_params;

 }

 ThreadPriority WinThreader::ThreadHandle::GetPriority()

 {

 	return m_params.prio;

 }

 bool WinThreader::ThreadHandle::SetPriority(ThreadPriority prio)

 {

 	if (!m_thread)

 		return false;

 	BOOL res = FALSE;

 	if (prio >= ThreadPrio_Maximum)

 		res = SetThreadPriority(m_thread, THREAD_PRIORITY_HIGHEST);

 	else if (prio <= ThreadPrio_Minimum)

 		res = SetThreadPriority(m_thread, THREAD_PRIORITY_LOWEST);

 	else if (prio == ThreadPrio_Normal)

 		res = SetThreadPriority(m_thread, THREAD_PRIORITY_NORMAL);

 	else if (prio == ThreadPrio_High)

 		res = SetThreadPriority(m_thread, THREAD_PRIORITY_ABOVE_NORMAL);

 	else if (prio == ThreadPrio_Low)

 		res = SetThreadPriority(m_thread, THREAD_PRIORITY_BELOW_NORMAL);

 	m_params.prio = prio;

 	return (res != FALSE);

 }

 bool WinThreader::ThreadHandle::Unpause()

 {

 	if (!m_thread)

 		return false;

 	if (m_state != Thread_Paused)

 		return false;

 	m_state = Thread_Running;

 	if (ResumeThread(m_thread) == -1)

 	{

 		m_state = Thread_Paused;

 		return false;

 	}

 	return true;

 }

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

  * EVENT SIGNALS *

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

 WinThreader::WinEvent::~WinEvent()

 {

 	CloseHandle(m_event);

 }

 void WinThreader::WinEvent::Wait()

 {

 	WaitForSingleObject(m_event, INFINITE);

 }

 void WinThreader::WinEvent::Signal()

 {

 	SetEvent(m_event);

 }

 void WinThreader::WinEvent::DestroyThis()

 {

 	delete this;

 }