/*! ========================================================================
** Extended Template and Library
** Thread Abstraction Class Implementation
** $Id$
**
** Copyright (c) 2002 Robert B. Quattlebaum Jr.
**
** This package is free software; you can redistribute it and/or
** modify it under the terms of the GNU General Public License as
** published by the Free Software Foundation; either version 2 of
** the License, or (at your option) any later version.
**
** This package 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.
**
** === N O T E S ===========================================================
**
** This is an internal header file, included by other ETL headers.
** You should not attempt to use it directly.
**
** ========================================================================= */

/* === S T A R T =========================================================== */

#ifndef __ETL__THREAD_H_
#define __ETL__THREAD_H_

/* === H E A D E R S ======================================================= */

#define __USE_GNU

#ifdef HAVE_PTHREAD_H
# include <pthread.h>
#endif

#ifdef HAVE_SCHED_H
# include <sched.h>
#endif

#ifdef HAVE_CREATETHREAD
# include <windows.h>
#endif

/* === M A C R O S ========================================================= */

#if ( defined (HAVE_PTHREAD_CREATE) || defined (HAVE_CLONE) || defined (HAVE_CREATETHREAD) ) && !defined (NO_THREADS)
# define CALLISTO_THREADS
#endif

#define THREAD_ENTRYPOINT

/* === C L A S S E S & S T R U C T S ======================================= */

#if defined(CALLISTO_THREADS) && defined(HAVE_PTHREAD_CREATE)
static inline void Yield(void)
{
	sched_yield();
	pthread_testcancel();
}
#else
#ifdef Yield
	#undef Yield
#endif
inline void Yield(void) { }
#endif

#ifdef CALLISTO_THREADS

#ifdef HAVE_PTHREAD_CREATE

class Thread
{
public:
	typedef void* entrypoint_return;
private:

	pthread_t thread;
	int *references;
	entrypoint_return (*entrypoint)(void *);
	void *context;
public:
	Thread(void *(*ep)(void *)=NULL,void *context=NULL):
		references(NULL),entrypoint(ep),context(context) { }
	Thread(const Thread &t)
	{
		thread=t.thread;
		references=t.references;
		entrypoint=t.entrypoint;
		context=t.context;
		if(references)
			(*references)++;
	}
	const Thread &operator=(const Thread &rhs)
	{
		if(references)
		{
			(*references)--;
			if(*references==0)
				stop();
		}
		thread=rhs.thread;
		references=rhs.references;
		entrypoint=rhs.entrypoint;
		context=rhs.context;
		if(references)
			(*references)++;
		return *this;
	}

	void start(void)
	{
		references = new int;
		*references = 1;
		pthread_create(&thread,NULL,entrypoint,context);
//		pthread_detach(thread);
	}

	void stop(void)
	{
		delete references;
		references=NULL;
		void *exit_status;
		pthread_cancel(thread);
		pthread_join(thread,&exit_status);
	}

	static void TestStop()
	{
		pthread_testcancel();
	}

	static void SyncStop()
	{
		int i;
		pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED,&i);
	}

	static void AsyncStop()
	{
		int i;
		pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,&i);
	}

	~Thread()
	{
		if(references)
		{
			(*references)--;
			if(*references==0)
				stop();
		}
	}
};

class Mutex
{
	pthread_mutex_t mutex;
	pthread_t locker;
	int depth;
public:

	Mutex()
	{
		pthread_mutexattr_t attr;
		pthread_mutexattr_init(&attr);
		//#ifdef PTHREAD_PRIO_INHERIT
		//pthread_mutexattr_setprioceiling(&attr,PTHREAD_PRIO_INHERIT);
		//#endif
		#ifdef PTHREAD_MUTEX_RECURSIVE
		pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
		#endif
		pthread_mutex_init(&mutex,&attr);
		pthread_mutexattr_destroy(&attr);
		locker=0;
		depth=0;
	}

	~Mutex()
	{ pthread_mutex_destroy(&mutex); }

	void Lock(void)
	{
		if(!locker || locker!=pthread_self())
		{
			pthread_mutex_lock(&mutex);
			locker=pthread_self();
			depth=0;
			return;
		}
		depth++;
	}

	bool TryLock(void)
	{ return !(bool) pthread_mutex_trylock(&mutex); }

	void UnLock(void)
	{
		if(depth)
		{
			depth--;
			return;
		}
		pthread_mutex_unlock(&mutex);
		locker=0;
	}
};

#ifdef HAVE_PTHREAD_RW_LOCK_INIT
class ReadWriteLock
{
	pthread_rwlock_t rwlock;
public:

	ReadWriteLock()
	{ pthread_rwlock_init(&rwlock,NULL); }

	~ReadWriteLock()
	{ pthread_rwlock_destroy(&rwlock); }

	void LockRead(void)
	{ pthread_rwlock_rdlock(&rwlock); }

	void LockWrite(void)
	{ pthread_rwlock_wrlock(&rwlock); }

	bool TryLockRead(void)
	{ return !(bool)pthread_rwlock_tryrdlock(&rwlock); }

	bool TryLockWrite(void)
	{ return !(bool)pthread_rwlock_trywrlock(&rwlock); }

	void UnLockWrite(void)
	{ pthread_rwlock_unlock(&rwlock); }

	void UnLockRead(void)
	{ pthread_rwlock_unlock(&rwlock); }
};
#else
//*
class ReadWriteLock : public Mutex
{
public:

	ReadWriteLock()
	{  }

	~ReadWriteLock()
	{  }

	void LockRead(void)
	{ Lock(); }

	void LockWrite(void)
	{ Lock(); }

	bool TryLockRead(void)
	{ return TryLock(); }

	bool TryLockWrite(void)
	{ return TryLock(); }

	void UnLockWrite(void)
	{ UnLock(); }

	void UnLockRead(void)
	{ UnLock(); }
};
#endif

/*
class Condition
{
	pthread_cond_t cond;
	pthread_mutex_t mutex;
public:
	Condition()
	{ pthread_cond_init(&cond,NULL); pthread_mutex_init(&mutex,NULL); }
	~Condition()
	{ pthread_cond_destroy(&cond); pthread_mutex_destroy(&mutex);}
	void operator()(void)
	{ pthread_cond_signal(&cond); }
	void Wait(void)
	{
		pthread_mutex_lock(&mutex);
		pthread_cond_wait(&cond,&mutex);
		pthread_mutex_unlock(&mutex);
	}
};
*/

#else // if defined HAVE_PTHREAD
#ifdef HAVE_CREATETHREAD


#ifdef THREAD_ENTRYPOINT
#undef THREAD_ENTRYPOINT
#endif
#define THREAD_ENTRYPOINT	__stdcall
class Thread
{
public:
	typedef unsigned long entrypoint_return;
private:

	unsigned long thread;
	HANDLE handle;
	int *references;

	entrypoint_return  (THREAD_ENTRYPOINT *entrypoint)(void *);

	void *context;

	HDC hdc;
	HGLRC hglrc;

	static entrypoint_return THREAD_ENTRYPOINT thread_prefix(void*data)
	{
		Thread *thread=(Thread *)data;

		if(thread->hglrc)
			wglMakeCurrent(thread->hdc, thread->hglrc);

		return thread->entrypoint(thread->context);
	}

public:
	Thread(entrypoint_return  (THREAD_ENTRYPOINT *ep)(void *)=NULL,void *context=NULL):
		references(NULL),entrypoint(ep),context(context) { }
	Thread(const Thread &t)
	{
		thread=t.thread;
		handle=t.handle;
		references=t.references;
		entrypoint=t.entrypoint;
		context=t.context;
		handle=NULL;
		if(references)
			(*references)++;
	}
	const Thread &operator=(const Thread &rhs)
	{
		if(references)
		{
			(*references)--;
			if(*references==0)
				stop();
		}
		thread=rhs.thread;
		handle=rhs.handle;
		references=rhs.references;
		entrypoint=rhs.entrypoint;
		context=rhs.context;
		if(references)
			(*references)++;
		return *this;
	}

	void start(void)
	{
		references = new int;
		*references = 1;

		hglrc=wglGetCurrentContext();
		hdc=wglGetCurrentDC();

		handle=CreateThread(
			NULL,		// Security stuff
			0,	// STACK
			thread_prefix,    // thread function
			(void*)this,                       // thread argument
			0,                    // creation option
			&thread                        // thread identifier
		);
	}

	void stop(void)
	{
		delete references;
		references=NULL;

		TerminateThread(handle, FALSE);
	}

	int wait(void)
	{
		if(handle)
		{
			WaitForSingleObject(handle, INFINITE);
			CloseHandle(handle);
		}
		return 0;
	}

	static void TestStop()
	{
	}

	static void SyncStop()
	{
	}

	static void AsyncStop()
	{
	}

	~Thread()
	{
		if(references)
		{
			(*references)--;
			if(*references==0)
				stop();
		}
	}
};

class Mutex
{
	HANDLE handle;
public:

	Mutex()
	{
		handle = CreateMutex(NULL, FALSE, NULL);
	}

	~Mutex()
	{
		CloseHandle(handle);
	}

	void Lock(void)
	{
		WaitForSingleObject(handle, INFINITE);
	}

	bool TryLock(void)
	{
		return WaitForSingleObject(handle, INFINITE)==WAIT_FAILED;
	}

	void UnLock(void)
	{
		ReleaseMutex(handle);
	}
};


#endif // if defined HAVE_CREATETHREAD
#endif // if defined HAVE_PTHREAD_CREATE
#endif // if defined CALLISTO_THREADS


#if !defined(CALLISTO_THREADS)
// Dummy object used when not threading
class ReadWriteLock
{
public:

	ReadWriteLock() {}
	~ReadWriteLock() {}
	void LockRead(void) {}
	void LockWrite(void) {}
	bool TryLockRead(void) {return true;}
	bool TryLockWrite(void) {return true;}
	void UnLockRead(void) {}
	void UnLockWrite(void) {}
};

class Mutex
{
public:

	Mutex(){}
	~Mutex(){}
	void Lock(void){}
	bool TryLock(void){return true;}
	void UnLock(void){}
};

#endif

class Condition : private Mutex
{
	bool flag;
public:
	Condition()
	{ flag=false; }
	~Condition()
	{ }
	void operator()(void)
	{ flag=true; }
	void Wait(void)
	{
		Lock();
		while(!flag)Yield();
		flag=false;
		UnLock();
	}
	void WaitNext(void)
	{
		Lock();
		flag=false;
		while(!flag)Yield();
		UnLock();
	}
};

/* === E X T E R N S ======================================================= */

/* === E N D =============================================================== */

#endif