#include "tthread.h"

#define _WIN32_WINNT 0x0400

#include <windows.h></windows.h>

using std::list<tthread *="">;</tthread>

class TThreadGroupImp;

//---------------------------------------------------------------------------

//    TMutex & TMutexImp

//---------------------------------------------------------------------------

class TMutexImp

{

	HANDLE id;

public:

	TMutexImp();

	~TMutexImp();

	void lock();

	void unlock();

};

//---------------------------------------------------------------------------

class TThreadGroupImp

{

	list<tthread *=""> threads;</tthread>

public:

	TThreadGroupImp();

	~TThreadGroupImp();

	void add(TThread *);

	void remove(TThread *);

	void wait();

};

//---------------------------------------------------------------------------

TMutexImp::TMutexImp()

{

	id = CreateMutex(NULL, FALSE, NULL);

}

//---------------------------------------------------------------------------

TMutexImp::~TMutexImp()

{

	BOOL rc = CloseHandle(id);

}

//---------------------------------------------------------------------------

void TMutexImp::lock()

{

	DWORD rc = WaitForSingleObject(id, INFINITE);

}

//---------------------------------------------------------------------------

void TMutexImp::unlock()

{

	BOOL rc = ReleaseMutex(id);

}

//---------------------------------------------------------------------------

TMutex::TMutex()

	: m_imp(new TMutexImp())

{

}

//---------------------------------------------------------------------------

TMutex::~TMutex()

{

	delete m_imp;

}

//---------------------------------------------------------------------------

void TMutex::lock()

{

	m_imp->lock();

}

//---------------------------------------------------------------------------

void TMutex::unlock()

{

	m_imp->unlock();

}

//---------------------------------------------------------------------------

//---------------------------------------------------------------------------

//    TThread & TThreadImp

//---------------------------------------------------------------------------

class TThreadImp

{

public:

	friend class TThreadGroupImp;

	HANDLE threadId;

	HANDLE mainThread;

	int m_refCount;

	TMutex secureLock;

	bool isRunning;

	TThreadGroupImp *owner;

	TThread *thread;

	//some static stuff

	static TUINT32 nThreads;

	static TMutex mutex;

	TThreadImp();

	~TThreadImp();

	void start();

	bool setThreadPriority(TThread::TThreadPriority p);

	bool setPreferredProcessor(int processorId);

	static void incNThreads()

	{

		mutex.lock();

		nThreads++;

		mutex.unlock();

	}

	static void decNThreads()

	{

		mutex.lock();

		nThreads--;

		mutex.unlock();

	}

	void setOwner(TThreadGroupImp *_owner) { owner = _owner; }

};

TUINT32 TThreadImp::nThreads = 0;

TMutex TThreadImp::mutex = TMutex();

//---------------------------------------------------------------------------

TThreadImp::TThreadImp()

	: isRunning(false), threadId(0), owner(0), mainThread(0), thread(0), secureLock(), m_refCount(0)

{

}

//---------------------------------------------------------------------------

TThreadImp::~TThreadImp()

{

	if (threadId)

		CloseHandle(threadId);

}

//---------------------------------------------------------------------------

static TUINT32 __stdcall fun(void *data)

{

	TThreadImp *t = (TThreadImp *)data;

	t->secureLock.lock();

	if (t->isRunning) {

		t->secureLock.unlock();

		assert(!"thread is already running");

		return 0;

	}

	t->isRunning = true;

	t->secureLock.unlock();

	t->thread->run();

	t->decNThreads();

	if (t->owner)

		t->owner->remove(t->thread);

	t->thread->release();

	return 0;

}

//---------------------------------------------------------------------------

void TThreadImp::start()

{

	TThreadImp::incNThreads();

	threadId = CreateThread(0, 0, fun, this, 0, 0);

}

//---------------------------------------------------------------------------

bool TThreadImp::setThreadPriority(TThread::TThreadPriority p)

{

	int priority;

	switch (p) {

	case TThread::TIME_CRITICAL:

		priority = THREAD_PRIORITY_TIME_CRITICAL;

		break;

	case TThread::HIGHEST:

		priority = THREAD_PRIORITY_HIGHEST;

		break;

	case TThread::ABOVE_NORMAL:

		priority = THREAD_PRIORITY_ABOVE_NORMAL;

		break;

	case TThread::NORMAL:

		priority = THREAD_PRIORITY_NORMAL;

		break;

	case TThread::BELOW_NORMAL:

		priority = THREAD_PRIORITY_BELOW_NORMAL;

		break;

	case TThread::LOWEST:

		priority = THREAD_PRIORITY_LOWEST;

		break;

	case TThread::IDLE:

		priority = THREAD_PRIORITY_IDLE;

		break;

	default:

		priority = THREAD_PRIORITY_NORMAL;

		break;

	}

	return !!SetThreadPriority(threadId, priority);

}

//---------------------------------------------------------------------------

bool TThreadImp::setPreferredProcessor(int processorId)

{

	DWORD rc = SetThreadIdealProcessor(threadId, processorId);

	return (rc != -1);

}

//---------------------------------------------------------------------------

TThread::TThread()

	: m_imp(new TThreadImp())

{

	m_imp->thread = this;

}

//---------------------------------------------------------------------------

TThread::~TThread()

{

	delete m_imp;

}

//---------------------------------------------------------------------------

void TThread::start()

{

	addRef();

	m_imp->start();

}

//---------------------------------------------------------------------------

void TThread::addRef()

{

	m_imp->mutex.lock();

	m_imp->m_refCount++;

	m_imp->mutex.unlock();

}

//---------------------------------------------------------------------------

void TThread::release()

{

	bool kill = false;

	m_imp->mutex.lock();

	m_imp->m_refCount--;

	if (m_imp->m_refCount <= 0)

		kill = true;

	m_imp->mutex.unlock();

	if (kill)

		delete this;

}

//---------------------------------------------------------------------------

int TThread::getRefCount()

{

	return m_imp->m_refCount;

}

//---------------------------------------------------------------------------

bool TThread::setPreferredProcessor(int processorId)

{

	return m_imp->setPreferredProcessor(processorId);

}

//---------------------------------------------------------------------------

bool TThread::setThreadPriority(TThread::TThreadPriority p)

{

	return m_imp->setThreadPriority(p);

}

//=======================

//    TThreadGroupImp

//---------------------------------------------------------------------------

TThreadGroupImp::TThreadGroupImp()

{

}

//---------------------------------------------------------------------------

TThreadGroupImp::~TThreadGroupImp()

{

}

//---------------------------------------------------------------------------

void TThreadGroupImp::add(TThread *t)

{

	threads.push_back(t);

	t->m_imp->setOwner(this);

}

//---------------------------------------------------------------------------

void TThreadGroupImp::remove(TThread *t)

{

	threads.remove(t);

	t->m_imp->setOwner(0);

}

//---------------------------------------------------------------------------

void TThreadGroupImp::wait()

{

	DWORD count = threads.size();

	if (count == 0)

		return;

	HANDLE *hThreads = new HANDLE[count];

	int id = 0;

	for (list<tthread *="">::iterator it = threads.begin(); it != threads.end(); it++, id++) {</tthread>

		TThread *t = *it;

		if (t->m_imp->threadId == 0)

			t->start();

		hThreads[id] = t->m_imp->threadId;

	}

	DWORD rc = WaitForMultipleObjects(count, hThreads, FALSE, INFINITE);

	if (rc >= WAIT_OBJECT_0 && rc <= (WAIT_OBJECT_0 + count - 1)) {

		// cout << "obj #" << rc << endl;

	}

	if (rc >= WAIT_ABANDONED_0 && rc <= (WAIT_ABANDONED_0 + count - 1)) {

		// cout << "obj #" << rc << " abandoned" << endl;

	}

	if (rc == WAIT_TIMEOUT) {

		// cout << "timeout" << endl;

	}

	if (rc == WAIT_FAILED) {

		// cout << "failed" << endl;

	}

	delete[] hThreads;

	wait();

}

//---------------------------------------------------------------------------

TThreadGroup::TThreadGroup()

	: m_imp(new TThreadGroupImp())

{

}

//---------------------------------------------------------------------------

TThreadGroup::~TThreadGroup()

{

	delete m_imp;

}

//---------------------------------------------------------------------------

void TThreadGroup::add(TThread *t)

{

	m_imp->add(t);

}

//---------------------------------------------------------------------------

void TThreadGroup::wait()

{

	m_imp->wait();

}