#include <kernel/OS.h>

#include <support/SupportDefs.h>

#include <errno.h>

/* ----------------------------------------------------------------------

 * Fast locking mechanism described by Benoit Schillings (benoit@be.com)

 * in the Be Developer's Newsletter, Issue #26 (http://www.be.com/).

 */

typedef struct benaphore {

	sem_id _sem;

	int32  _atom;

} benaphore_t;

static status_t benaphore_create( const char *name, benaphore_t *ben );

static status_t benaphore_destroy( benaphore_t *ben );

static status_t benaphore_lock( benaphore_t *ben );

static status_t benaphore_timedlock( benaphore_t *ben, bigtime_t micros );

static status_t benaphore_unlock( benaphore_t *ben );

static status_t benaphore_create( const char *name, benaphore_t *ben )

{

	if( ben != NULL ) {

		ben->_atom = 0;

		ben->_sem = create_sem( 0, name );

		if( ben->_sem < B_NO_ERROR ) {

			return B_BAD_SEM_ID;

		}

	} else {

		return EFAULT;

	}

	return EOK;

}

static status_t benaphore_destroy( benaphore_t *ben )

{

	if( ben->_sem >= B_NO_ERROR ) {

		status_t retval = benaphore_timedlock( ben, 0 );

		if( retval == EOK || retval == EWOULDBLOCK ) {

			status_t del_retval = delete_sem( ben->_sem );

			return del_retval;

		}

	}

	return B_BAD_SEM_ID;

}

static status_t benaphore_lock( benaphore_t *ben )

{

	int32 prev = atomic_add( &(ben->_atom), 1 );

	if( prev > 0 ) {

		return acquire_sem( ben->_sem );

	}

	return EOK;

}

static status_t benaphore_timedlock( benaphore_t *ben, bigtime_t micros )

{

	int32 prev = atomic_add( &(ben->_atom), 1 );

	if( prev > 0 ) {

		status_t retval = acquire_sem_etc( ben->_sem, 1, B_TIMEOUT, micros );

		switch( retval ) {

		case B_WOULD_BLOCK:	/* Fall through... */

		case B_TIMED_OUT:

			return EWOULDBLOCK;

			break;

		case B_OK:

			return EOK;

			break;

		default:

			return retval;

			break;

		}

	}

	return EOK;

}

static status_t benaphore_unlock( benaphore_t *ben )

{

	int32 prev = atomic_add( &(ben->_atom), -1 );

	if( prev > 1 ) {

		return release_sem( ben->_sem );

	}

	return EOK;

}

/* ----------------------------------------------------------------------

 * Initialization.

 */

static void PyThread__init_thread( void )

{

	/* Do nothing. */

	return;

}

/* ----------------------------------------------------------------------

 * Thread support.

 *

 * Only ANSI C, renamed functions here; you can't use K&R on BeOS,

 * and there's no legacy thread module to support.

 */

static int32 thread_count = 0;

long PyThread_start_new_thread( void (*func)(void *), void *arg )

{

	status_t success = 0;

	thread_id tid;

	char name[B_OS_NAME_LENGTH];

	int32 this_thread;

	dprintf(("PyThread_start_new_thread called\n"));

	/* We are so very thread-safe... */

	this_thread = atomic_add( &thread_count, 1 );

	PyOS_snprintf(name, sizeof(name),

		      "python thread (%d)", this_thread );

	tid = spawn_thread( (thread_func)func, name,

	                    B_NORMAL_PRIORITY, arg );

	if( tid > B_NO_ERROR ) {

		success = resume_thread( tid );

	}

	return ( success == B_NO_ERROR ? tid : -1 );

}

long PyThread_get_thread_ident( void )

{

	/* Presumed to return the current thread's ID... */

	thread_id tid;

	tid = find_thread( NULL );

	return ( tid != B_NAME_NOT_FOUND ? tid : -1 );

}

static void do_PyThread_exit_thread( int no_cleanup )

{

	int32 threads;

	dprintf(("PyThread_exit_thread called\n"));

	/* Thread-safe way to read a variable without a mutex: */

	threads = atomic_add( &thread_count, 0 );

	if( threads == 0 ) {

		/* No threads around, so exit main(). */

		if( no_cleanup ) {

			_exit(0);

		} else {

			exit(0);

		}

	} else {

		/* Oh, we're a thread, let's try to exit gracefully... */

		exit_thread( B_NO_ERROR );

	}

}

void PyThread_exit_thread( void )

{

	do_PyThread_exit_thread(0);

}

void PyThread__exit_thread( void )

{

	do_PyThread_exit_thread(1);

}

#ifndef NO_EXIT_PROG

static void do_PyThread_exit_prog( int status, int no_cleanup )

{

	dprintf(("PyThread_exit_prog(%d) called\n", status));

	/* No need to do anything, the threads get torn down if main() exits. */

	if (no_cleanup) {

		_exit(status);

	} else {

		exit(status);

	}

}

void PyThread_exit_prog( int status )

{

	do_PyThread_exit_prog(status, 0);

}

void PyThread__exit_prog( int status )

{

	do_PyThread_exit_prog(status, 1);

}

#endif /* NO_EXIT_PROG */

/* ----------------------------------------------------------------------

 * Lock support.

 */

static int32 lock_count = 0;

PyThread_type_lock PyThread_allocate_lock( void )

{

	benaphore_t *lock;

	status_t retval;

	char name[B_OS_NAME_LENGTH];

	int32 this_lock;

	dprintf(("PyThread_allocate_lock called\n"));

	lock = (benaphore_t *)malloc( sizeof( benaphore_t ) );

	if( lock == NULL ) {

		/* TODO: that's bad, raise MemoryError */

		return (PyThread_type_lock)NULL;

	}

	this_lock = atomic_add( &lock_count, 1 );

	PyOS_snprintf(name, sizeof(name), "python lock (%d)", this_lock);

	retval = benaphore_create( name, lock );

	if( retval != EOK ) {

		/* TODO: that's bad, raise an exception */

		return (PyThread_type_lock)NULL;

	}

	dprintf(("PyThread_allocate_lock() -> %p\n", lock));

	return (PyThread_type_lock) lock;

}

void PyThread_free_lock( PyThread_type_lock lock )

{

	status_t retval;

	dprintf(("PyThread_free_lock(%p) called\n", lock));

	retval = benaphore_destroy( (benaphore_t *)lock );

	if( retval != EOK ) {

		/* TODO: that's bad, raise an exception */

		return;

	}

}

int PyThread_acquire_lock( PyThread_type_lock lock, int waitflag )

{

	int success;

	status_t retval;

	dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));

	if( waitflag ) {

		retval = benaphore_lock( (benaphore_t *)lock );

	} else {

		retval = benaphore_timedlock( (benaphore_t *)lock, 0 );

	}

	if( retval == EOK ) {

		success = 1;

	} else {

		success = 0;

		/* TODO: that's bad, raise an exception */

	}

	dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));

	return success;

}

void PyThread_release_lock( PyThread_type_lock lock )

{

	status_t retval;

	dprintf(("PyThread_release_lock(%p) called\n", lock));

	retval = benaphore_unlock( (benaphore_t *)lock );

	if( retval != EOK ) {

		/* TODO: that's bad, raise an exception */

		return;

	}

}