#include "tthread.h"
#define _WIN32_WINNT 0x0400
#include <windows.h>

using std::list<TThread *>;

class TThreadGroupImp;
//---------------------------------------------------------------------------
//    TMutex & TMutexImp
//---------------------------------------------------------------------------

class TMutexImp
{
	HANDLE id;

public:
	TMutexImp();
	~TMutexImp();
	void lock();
	void unlock();
};

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

class TThreadGroupImp
{
	list<TThread *> threads;

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 *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();
}