/* -----------------------------------------------------------------------------
	GSFramework
	Copyright 2001-2013 Emmanuel Julien. All Rights Reserved.
----------------------------------------------------------------------------- */


		#include "thread/thread_event.h"
		#include "time/ntime.h"

		using namespace GS;
		using namespace GS::Threading;
		

#if		__PLATFORM_WINDOWS__

		#define		WIN32_LEAN_AND_MEAN
		#include <windows.h>

//------------------------------------------------------------------------------
void				Event::Wait(Time *t)
{	WaitForSingleObject((HANDLE)event, t ? DWORD(t->toMs()) : INFINITE);	}
void				Event::Trigger()
{	SetEvent((HANDLE)event);	}
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
Event::Event()
{	event = (void *)CreateEvent(NULL, false, false, NULL);	}
Event::~Event()
{	if (event) CloseHandle(event);	}
//------------------------------------------------------------------------------

#elif	__PLATFORM_EMSCRIPTEN__

//------------------------------------------------------------------------------
void				Event::Wait(Time *t)
{}
void				Event::Trigger()
{}
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
Event::Event()
{}
Event::~Event()
{}
//------------------------------------------------------------------------------

#elif	__PLATFORM_POSIX__

		#include <errno.h>
		#include <pthread.h>
		#include <stdbool.h>
		#include <sys/time.h>

struct	pthread_event
{
	pthread_mutex_t	mutex;
	pthread_cond_t	cond;
	bool			triggered;
};

//------------------------------------------------------------------------------
void				Event::Wait(Time *t)
{
	pthread_event *ev = (pthread_event *)event;

	timespec time;

	if	(t)
	{
		timeval ctime;
		gettimeofday(&ctime, NULL);
		time.tv_sec = t->getSec() + ctime.tv_sec;
		time.tv_nsec = t->getNanoSec() + ctime.tv_usec * 1000;
	}

	pthread_mutex_lock(&ev->mutex);
	while (!ev->triggered)
	{
		if	(!t)
			pthread_cond_wait(&ev->cond, &ev->mutex);
		else
			if	(pthread_cond_timedwait(&ev->cond, &ev->mutex, &time) == ETIMEDOUT)
				break;
	}
	ev->triggered = false;
	pthread_mutex_unlock(&ev->mutex);
}
void				Event::Trigger()
{
	pthread_event *ev = (pthread_event *)event;

	pthread_mutex_lock(&ev->mutex);
	ev->triggered = true;
	pthread_cond_signal(&ev->cond);
	pthread_mutex_unlock(&ev->mutex);
}
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
Event::Event()
{
	pthread_event *ev = new pthread_event;
	event = (void *)ev;

    pthread_mutex_init(&ev->mutex, 0);
    pthread_cond_init(&ev->cond, 0);
    ev->triggered = false;
}
Event::~Event()
{
	pthread_event *ev = (pthread_event *)event;
	pthread_mutex_destroy(&ev->mutex);
	pthread_cond_destroy(&ev->cond);
	delete ev;
}
//------------------------------------------------------------------------------

#endif