#ifndef _TTHERAD_H_
#define _TTHREAD_H_

#include "sysenv.h"
#if _OS_WIN
//#include <handleapi.h>
//#include <synchapi.h>
//#include <processthreadsapi.h>
//#define INFINITE            0xFFFFFFFF  // Infinite timeout
//#define WAIT_FAILED ((DWORD)0xFFFFFFFF)
//#include <WinBase.h>
#include <Windows.h>
typedef DWORD TID;
typedef HANDLE MUTEX;
typedef HANDLE COND;
#elif _OS_LINUX
#include <pthread.h>
#define TID pthread_t
#define MUTEX pthread_mutex_t
#define COND pthread_cond_t
#else
#error "Not Supported Operator System"
#endif

#ifdef __cplusplus
extern "C" {
#endif

enum {
	ERR_THREAD_SUCCESS,

	ERR_THREAD_CREATE,
	ERR_THREAD_JOIN,
	ERR_THREAD_WIN_CLOSE_HANDLE,
	ERR_THREAD_WIN_OPEN_THREAD,

	ERR_THREAD_MUTEX_INIT,
	ERR_THREAD_MUTEX_DESTROY,
	ERR_THREAD_MUTEX_LOCK,
	ERR_THREAD_MUTEX_UNLOCK,

	ERR_THREAD_COND_INIT,
	ERR_THREAD_COND_DESTROY,
	ERR_THREAD_COND_SINGAL,
	ERR_THREAD_COND_BROADCAST,
	ERR_THREAD_COND_WAIT,
	ERR_THREAD_COND_TIMEDWAIT,

	ERR_THREAD_ENUM_END
};

static inline int thread_create(TID* tid, void(*start_routine)(void*), void* arg);
static inline void thread_exit(void);
static inline int thread_join(TID tid);

static inline int thread_mutex_init(MUTEX* mutex);
static inline int thread_mutex_destory(MUTEX mutex);
static inline int thread_mutex_lock(MUTEX mutex);
static inline int thread_mutex_unlock(MUTEX mutex);

static inline int thread_create(TID* tid, void(*start_routine)(void*), void* arg) {
#if _OS_WIN
	HANDLE h = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)start_routine, arg, 0, tid);
	if (h == NULL) { return ERR_THREAD_CREATE; }
	if (!CloseHandle(h)) { return ERR_THREAD_WIN_CLOSE_HANDLE; }
#elif _OS_LINUX
	if (pthread_create(tid, NULL, start_routine, arg) != 0) { return ERR_THREAD_CREATE; }
#endif
	return ERR_THREAD_SUCCESS;
}

static inline void thread_exit(void) {
#if _OS_WIN
	ThreadExit(0);
#elif _OS_LINUX
	pthread_exit(NULL);
#endif
}

static inline int thread_join(TID tid) {
#if _OS_WIN
	HANDLE h = OpenThread(THREAD_ALL_ACCESS, 0, tid);
	if (h == NULL) { return ERR_THREAD_WIN_OPEN_THREAD; }
	if (WaitForSingleObject(h, INFINITE) == WAIT_FAILED) { return ERR_THREAD_JOIN; }
	if (!CloseHandle(h)) { return ERR_THREAD_WIN_CLOSE_HANDLE; }
#elif _OS_LINUX
	if (pthread_join(tid, NULL) != 0) { return ERR_THREAD_JOIN; }
#endif
	return ERR_THREAD_SUCCESS;
}

// mutex part
static inline int thread_mutex_init(MUTEX* mutex) {
#if _OS_WIN
	*mutex = CreateMutex(NULL, FALSE, NULL);
	if (*mutex == NULL) { return ERR_THREAD_MUTEX_INIT; }
#elif _OS_LINUX
	if (pthread_mutex_init() != 0) { return ERR_THREAD_MUTEX_INIT; }
#endif
	return ERR_THREAD_SUCCESS;
}

static inline int thread_mutex_destory(MUTEX mutex) {
#if _OS_WIN
	if (!CloseHandle(mutex)) { return ERR_THREAD_MUTEX_DESTROY; }
#elif _OS_LINUX
	if (pthread_mutex_destroy(mutex) != 0) { return ERR_THREAD_MUTEX_DESTROY; }
#endif
	ERR_THREAD_SUCCESS;
}

static inline int thread_mutex_lock(MUTEX mutex) {
#if _OS_WIN
	if (WaitForSingleObject(mutex, INFINITE) == WAIT_FAILED) { return ERR_THREAD_MUTEX_LOCK; }
#elif _OS_LINUX
	if (pthread_mutex_lock(mutex) != 0) { return ERR_THREAD_MUTEX_LOCK; }
#endif
	return ERR_THREAD_SUCCESS;
}

static inline int thread_mutex_unlock(MUTEX mutex) {
#if _OS_WIN
	ReleaseMutex(mutex);
#elif _OS_LINUX
	if (pthread_mutex_unlock(mutex) != 0) { return ERR_THREAD_MUTEX_UNLOCK; }
#endif
	return ERR_THREAD_SUCCESS;
}

#ifdef __cplusplus
}
#endif

#endif //_TTHREAD_H_