/*
 * Copyright 2003-2013, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "DebugSupport.h"

#include <errno.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#ifdef __HAIKU__

#include <OS.h>


/*!
	\file Debug.cpp
	\brief Defines debug output function with printf() signature printing
		   into a file.

	\note The initialization is not thread safe!
*/


// locking support
static int32 init_counter = 0;
static sem_id dbg_printf_sem = -1;
static thread_id dbg_printf_thread = -1;
static int dbg_printf_nesting = 0;


#if DEBUG_PRINT
static int out = -1;
#endif


status_t
init_debugging()
{
	status_t error = B_OK;
	if (init_counter++ == 0) {
		// open the file
		#if DEBUG_PRINT
			out = open(DEBUG_PRINT_FILE, O_RDWR | O_CREAT | O_TRUNC);
			if (out < 0) {
				error = errno;
				init_counter--;
			}
		#endif	// DEBUG_PRINT
		// allocate the semaphore
		if (error == B_OK) {
			dbg_printf_sem = create_sem(1, "dbg_printf");
			if (dbg_printf_sem < 0)
				error = dbg_printf_sem;
		}
		if (error == B_OK) {
			#if DEBUG
				__out("##################################################\n");
			#endif
		} else
			exit_debugging();
	}
	return error;
}


status_t
exit_debugging()
{
	status_t error = B_OK;
	if (--init_counter == 0) {
		#if DEBUG_PRINT
			close(out);
			out = -1;
		#endif	// DEBUG_PRINT
		delete_sem(dbg_printf_sem);
	} else
		error = B_NO_INIT;
	return error;
}


static inline bool
dbg_printf_lock()
{
	thread_id thread = find_thread(NULL);
	if (thread != dbg_printf_thread) {
		if (acquire_sem(dbg_printf_sem) != B_OK)
			return false;
		dbg_printf_thread = thread;
	}
	dbg_printf_nesting++;
	return true;
}


static inline void
dbg_printf_unlock()
{
	thread_id thread = find_thread(NULL);
	if (thread != dbg_printf_thread)
		return;
	dbg_printf_nesting--;
	if (dbg_printf_nesting == 0) {
		dbg_printf_thread = -1;
		release_sem(dbg_printf_sem);
	}
}

#else

status_t
init_debugging()
{
	status_t error = B_OK;
	return error;
}
status_t
exit_debugging()
{
	status_t error = B_OK;
	return error;
}
static inline bool
dbg_printf_lock()
{
	return true;
}
static inline void
dbg_printf_unlock(){}

#endif


void
dbg_printf_begin()
{
	dbg_printf_lock();
}


void
dbg_printf_end()
{
	dbg_printf_unlock();
}


#if DEBUG_PRINT


void
dbg_vprintf(const char* format, va_list args)
{
	if (!dbg_printf_lock())
		return;

	char buffer[1024];
	vsnprintf(buffer, sizeof(buffer) - 1, format, args);
	write(out, buffer, strlen(buffer));

	dbg_printf_unlock();
}


void
dbg_printf(const char* format,...)
{
	va_list args;
	va_start(args, format);
	dbg_vprintf(format, args);
	va_end(args);
}


#endif	// DEBUG_PRINT