#pragma once

#include <assert.h>

#include "String.DString.hpp"

#include "Log4CPP.TLSLog.hpp"


#define  __AB_LOG_LOG4CPP__


//-----------------------------------------------------------------------------
//	abLog 是对 gLogger 的简单封装, 可以同时写到两个 Logger 中
//-----------------------------------------------------------------------------

namespace abLog
{
	extern Log4CPP::Logger * aLogger;
	extern Log4CPP::Logger * bLogger;

	inline void NewLine ()
	{
		if (aLogger)  aLogger->NewLine ();
		if (bLogger)  bLogger->NewLine ();
	}

	inline bool Decide (int Level)
	{
		if (! aLogger)  return false;
		return (aLogger->Decide (Level));
	}

	template <typename... Args>
	inline void DoLog (int Level, const char * fmt, Args && ... args)
	{
		auto tbuf = Log4CPP::ThreadContext::TLSMessage::Get  ();
		auto size = Log4CPP::ThreadContext::TLSMessage::Size () - 4;

		if (tbuf [0])
			return;

		auto cch = 0;
			
		if (sizeof...(args) == 0)
		{
			cch = (int) strlen (fmt);
			cch = min (cch, size);
			memcpy (tbuf, fmt, cch);
			tbuf [cch] = 0;
		}
		else
		{
			cch = ECOM::Utility::String::StringFormat (tbuf, size).Format (fmt, std::forward <Args> (args)...);
			tbuf [cch] = 0;
		}

		if (aLogger) if (aLogger->GetLevel () <= Level)  aLogger->Flush (Level, cch, tbuf, true);
		if (bLogger) if (bLogger->GetLevel () <= Level)  bLogger->Flush (Level, cch, tbuf, true);

		tbuf [0] = 0;
	}

	template <typename... Args>
	inline void Force (const char * fmt, Args && ... args)
	{
		DoLog ((int)Log4CPP::enLogLevel::enTrace, fmt, std::forward <Args> (args)...);
	}

	template <typename... Args>
	inline void Verbose (const char * fmt, Args && ... args)
	{
		DoLog ((int)Log4CPP::enLogLevel::enVerbose, fmt, std::forward <Args> (args)...);
	}

	template <typename... Args>
	inline void Trace (const char * fmt, Args && ... args)
	{
		DoLog ((int)Log4CPP::enLogLevel::enTrace, fmt, std::forward <Args> (args)...);
	}

	template <typename... Args>
	inline void Debug (const char * fmt, Args && ... args)
	{
		DoLog ((int)Log4CPP::enLogLevel::enDebug, fmt, std::forward <Args> (args)...);
	}

	template <typename... Args>
	inline void Info (const char * fmt, Args && ... args)
	{
		DoLog ((int)Log4CPP::enLogLevel::enInfo, fmt, std::forward <Args> (args)...);
	}

	template <typename... Args>
	inline void Notice (const char * fmt, Args && ... args)
	{
		DoLog ((int)Log4CPP::enLogLevel::enNotice, fmt, std::forward <Args> (args)...);
	}

	template <typename... Args>
	inline void Warn (const char * fmt, Args && ... args)
	{
		DoLog ((int)Log4CPP::enLogLevel::enWarn, fmt, std::forward <Args> (args)...);
	}

	template <typename... Args>
	inline void Error (const char * fmt, Args && ... args)
	{
		DoLog ((int)Log4CPP::enLogLevel::enError, fmt, std::forward <Args> (args)...);
	}

	template <typename... Args>
	inline void Fatal (const char * fmt, Args && ... args)
	{
		DoLog ((int)Log4CPP::enLogLevel::enFatal, fmt, std::forward <Args> (args)...);
	}

	inline void Flush (const eSTR::DStringView & str)
	{
		if (aLogger)  aLogger->LogNoFormat (Log4CPP::enInfo, str, str.GetLength (), false);
		if (bLogger)  bLogger->LogNoFormat (Log4CPP::enInfo, str, str.GetLength (), false);
	}

	inline void Flush (const eSTR::DString & str)
	{
		if (aLogger)  aLogger->LogNoFormat (Log4CPP::enInfo, str, str.GetLength (), false);
		if (bLogger)  bLogger->LogNoFormat (Log4CPP::enInfo, str, str.GetLength (), false);
	}

	inline void LogNoFormat (int Level, const eSTR::DString & str, bool bWithLayout = false)
	{
		if (aLogger)  aLogger->LogNoFormat (Level, str, str.GetLength (), bWithLayout);
		if (bLogger)  bLogger->LogNoFormat (Level, str, str.GetLength (), bWithLayout);
	}

	inline void LogNoFormat (int Level, const char * buf, int len, bool bWithLayout = false)
	{
		if (aLogger)  aLogger->LogNoFormat (Level, buf, len, bWithLayout);
		if (bLogger)  bLogger->LogNoFormat (Level, buf, len, bWithLayout);
	}


	inline void Close ()
	{
		if (aLogger)  aLogger->Close ();
		if (bLogger)  bLogger->Close ();
	}

	inline eSTR::DString ErrorCodeToString (DWORD errorCode)
	{
		return Log4CPP::Logger::ErrorCodeToString (errorCode);
	}

	inline int  CurrentLevel ()
	{
		if (aLogger)  return aLogger->GetLevel ();
		if (bLogger)  return bLogger->GetLevel ();
		return 0;
	}

	inline eSTR::DString CurrentLevelName ()
	{
		if (aLogger)  return aLogger->LogLevelToString (aLogger->GetLevel ());
		if (bLogger)  return bLogger->LogLevelToString (bLogger->GetLevel ());
		return eSTR::DString ();
	}
};