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


		#include <cstdio>
		#include <cstring>
		#include <iostream>
		#include "log/log.h"
		#include "nstring/nstring.h"
		#include "thread/mutex.h"
		#include "platform_config.h"
		#include "alloc/ialloc.h"

		using namespace GS;

		template<> LogSystem *Singleton <LogSystem> ::i = NULL;


//------------------------------------------------------------------------------
LogSystem::LogSystem()
{	SetLog();	}
void				LogSystem::SetLog(Log *l)
{
	static Log s_log;
	log = l ? l : &s_log;
}
Log					&LogSystem::GetLog()
{	return *log;	}
//------------------------------------------------------------------------------

#if	__PLATFORM_LOG_SUPPORT__

//------------------------------------------------------------------------------
void				Log::NewLog(const char *log, char)
{
//	std::cout << log;
}
void				Log::LogProcessed()
{
	full_a[0] = 0;
	full_b[0] = 0;
}
//------------------------------------------------------------------------------

#define	_FORMAT_LOG(__F__, __V__)	\
{\
	Threading::MutexLock lock(mutex);\
	if	(a)\
	{\
		_snprintf(b, LOG_LINE_MAX_LEN - 1, __F__, a, __V__);\
		char *swp = a; a = b; b = swp;\
	}\
	return *this;\
}

//------------------------------------------------------------------------------
Log				&Log::operator << (const char v)
{	_FORMAT_LOG("%s%d", v)		}
Log				&Log::operator << (const short v)
{	_FORMAT_LOG("%s%d", v)		}
Log				&Log::operator << (const int v)
{	_FORMAT_LOG("%s%d", v)		}
Log				&Log::operator << (const uchar v)
{	_FORMAT_LOG("%s%d", v)		}
Log				&Log::operator << (const ushort v)
{	_FORMAT_LOG("%s%d", v)		}
Log				&Log::operator << (const uint v)
{	_FORMAT_LOG("%s%d", (int)v)	}
Log				&Log::operator << (const size_t v)
{	_FORMAT_LOG("%s%d", v)		}
Log				&Log::operator << (const float v)
{	_FORMAT_LOG("%s%.3f", v)	}
Log				&Log::operator << (const bool v)
{	_FORMAT_LOG("%s%s", v ? "True" : "False")	}
Log				&Log::operator << (const void *v)
{	_FORMAT_LOG("%s0x%p", v)	}
Log				&Log::operator << (const char *v)
{
	if	(a && v)
	{
		Threading::MutexLock lock(mutex);

		_snprintf(b, LOG_LINE_MAX_LEN - 1, "%s%s", a, v);
		char *swp = a; a = b; b = swp;

		// Look out for ENDL.
		for (const char *p = v; p[0]; ++p)
			if	(p[0] == '\n')
			{
				// Compute entry level.
				char entry_level = EngineLogStandard;

				if	((std::strlen(a) >= 3) && (a[0] == '[') && (a[2] == ']'))
					switch (a[1])
					{
						case '*':	entry_level |= EngineLogWarning;	break;
						case '!':	entry_level |= EngineLogError;		break;
						case 'H':	entry_level |= EngineLogHeader;		break;
						case 'V':	entry_level |= EngineLogVerbose;	break;
						case 'S':	entry_level |= EngineLogScript;		break;
					}

				// Process output.
				if	(entry_level & log_level)
					NewLog(a, entry_level);

				LogProcessed();
			}
	}
	return *this;
}
Log				&Log::operator << (const String &v)
{	return *this << v.toUtf8();	}
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
Log::Log()
{
	LogProcessed();
	a = full_a;
	b = full_b;
	log_level = (uint)EngineLogAll;

	mutex = new Threading::Mutex;
}
Log::~Log()
{
	_safe_delete(mutex);
}
//------------------------------------------------------------------------------

#else

//------------------------------------------------------------------------------
void				Log::NewLog(const char *, char)			{}
void				Log::LogProcessed()						{}
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
Log				&Log::operator << (const char)				{	return *this;	}
Log				&Log::operator << (const short)			{	return *this;	}
Log				&Log::operator << (const int)				{	return *this;	}
Log				&Log::operator << (const uchar)			{	return *this;	}
Log				&Log::operator << (const ushort)			{	return *this;	}
Log				&Log::operator << (const uint)				{	return *this;	}
Log				&Log::operator << (const size_t)			{	return *this;	}
Log				&Log::operator << (const float)			{	return *this;	}
Log				&Log::operator << (const bool)				{	return *this;	}
Log				&Log::operator << (const char *)			{	return *this;	}
Log				&Log::operator << (const String &)		{	return *this;	}
//------------------------------------------------------------------------------

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

#endif