/**
 * WinPR: Windows Portable Runtime
 * WinPR Logger
 *
 * Copyright 2013 Marc-Andre Moreau <marcandre.moreau@gmail.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <winpr/config.h>

#include <assert.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>

#include <winpr/crt.h>
#include <winpr/assert.h>
#include <winpr/print.h>
#include <winpr/debug.h>
#include <winpr/environment.h>
#include <winpr/wlog.h>

#if defined(ANDROID)
#include <android/log.h>
#include "../log.h"
#endif

#include "wlog.h"

typedef struct
{
	DWORD Level;
	LPSTR* Names;
	size_t NameCount;
} wLogFilter;

#define WLOG_FILTER_NOT_FILTERED (-1)
#define WLOG_FILTER_NOT_INITIALIZED (-2)
/**
 * References for general logging concepts:
 *
 * Short introduction to log4j:
 * http://logging.apache.org/log4j/1.2/manual.html
 *
 * logging - Logging facility for Python:
 * http://docs.python.org/2/library/logging.html
 */

LPCSTR WLOG_LEVELS[7] = { "TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL", "OFF" };

static INIT_ONCE g_WLogInitialized = INIT_ONCE_STATIC_INIT;
static DWORD g_FilterCount = 0;
static wLogFilter* g_Filters = NULL;
static wLog* g_RootLog = NULL;

static wLog* WLog_New(LPCSTR name, wLog* rootLogger);
static void WLog_Free(wLog* log);
static LONG WLog_GetFilterLogLevel(wLog* log);
static int WLog_ParseLogLevel(LPCSTR level);
static BOOL WLog_ParseFilter(wLog* root, wLogFilter* filter, LPCSTR name);
static BOOL WLog_ParseFilters(wLog* root);
static wLog* WLog_Get_int(wLog* root, LPCSTR name);

#if !defined(_WIN32)
static void WLog_Uninit_(void) __attribute__((destructor));
#endif

static void WLog_Uninit_(void)
{
	wLog* child = NULL;
	wLog* root = g_RootLog;

	if (!root)
		return;

	for (DWORD index = 0; index < root->ChildrenCount; index++)
	{
		child = root->Children[index];
		WLog_Free(child);
	}

	WLog_Free(root);
	g_RootLog = NULL;
}

static void WLog_Lock(wLog* log)
{
	WINPR_ASSERT(log);
	EnterCriticalSection(&log->lock);
}

static void WLog_Unlock(wLog* log)
{
	WINPR_ASSERT(log);
	LeaveCriticalSection(&log->lock);
}

static BOOL CALLBACK WLog_InitializeRoot(PINIT_ONCE InitOnce, PVOID Parameter, PVOID* Context)
{
	char* env = NULL;
	DWORD nSize = 0;
	DWORD logAppenderType = 0;
	LPCSTR appender = "WLOG_APPENDER";

	WINPR_UNUSED(InitOnce);
	WINPR_UNUSED(Parameter);
	WINPR_UNUSED(Context);

	if (!(g_RootLog = WLog_New("", NULL)))
		return FALSE;

	g_RootLog->IsRoot = TRUE;
	logAppenderType = WLOG_APPENDER_CONSOLE;
	nSize = GetEnvironmentVariableA(appender, NULL, 0);

	if (nSize)
	{
		env = (LPSTR)malloc(nSize);

		if (!env)
			goto fail;

		if (GetEnvironmentVariableA(appender, env, nSize) != nSize - 1)
		{
			(void)fprintf(stderr, "%s environment variable modified in my back", appender);
			free(env);
			goto fail;
		}

		if (_stricmp(env, "CONSOLE") == 0)
			logAppenderType = WLOG_APPENDER_CONSOLE;
		else if (_stricmp(env, "FILE") == 0)
			logAppenderType = WLOG_APPENDER_FILE;
		else if (_stricmp(env, "BINARY") == 0)
			logAppenderType = WLOG_APPENDER_BINARY;

#ifdef WINPR_HAVE_SYSLOG_H
		else if (_stricmp(env, "SYSLOG") == 0)
			logAppenderType = WLOG_APPENDER_SYSLOG;

#endif /* WINPR_HAVE_SYSLOG_H */
#ifdef WINPR_HAVE_JOURNALD_H
		else if (_stricmp(env, "JOURNALD") == 0)
			logAppenderType = WLOG_APPENDER_JOURNALD;

#endif
		else if (_stricmp(env, "UDP") == 0)
			logAppenderType = WLOG_APPENDER_UDP;

		free(env);
	}

	if (!WLog_SetLogAppenderType(g_RootLog, logAppenderType))
		goto fail;

	if (!WLog_ParseFilters(g_RootLog))
		goto fail;

	(void)atexit(WLog_Uninit_);

	return TRUE;
fail:
	WLog_Uninit_();
	return FALSE;
}

static BOOL log_recursion(LPCSTR file, LPCSTR fkt, size_t line)
{
	BOOL status = FALSE;
	char** msg = NULL;
	size_t used = 0;
	void* bt = winpr_backtrace(20);
#if defined(ANDROID)
	LPCSTR tag = WINPR_TAG("utils.wlog");
#endif

	if (!bt)
		return FALSE;

	msg = winpr_backtrace_symbols(bt, &used);

	if (!msg)
		goto out;

#if defined(ANDROID)

	if (__android_log_print(ANDROID_LOG_FATAL, tag, "Recursion detected!!!") < 0)
		goto out;

	if (__android_log_print(ANDROID_LOG_FATAL, tag, "Check %s [%s:%zu]", fkt, file, line) < 0)
		goto out;

	for (size_t i = 0; i < used; i++)
		if (__android_log_print(ANDROID_LOG_FATAL, tag, "%zu: %s", i, msg[i]) < 0)
			goto out;

#else

	if (fprintf(stderr, "[%s]: Recursion detected!\n", fkt) < 0)
		goto out;

	if (fprintf(stderr, "[%s]: Check %s:%" PRIuz "\n", fkt, file, line) < 0)
		goto out;

	for (size_t i = 0; i < used; i++)
		if (fprintf(stderr, "%s: %" PRIuz ": %s\n", fkt, i, msg[i]) < 0)
			goto out;

#endif
	status = TRUE;
out:
	free((void*)msg);
	winpr_backtrace_free(bt);
	return status;
}

static BOOL WLog_Write(wLog* log, wLogMessage* message)
{
	BOOL status = FALSE;
	wLogAppender* appender = NULL;
	appender = WLog_GetLogAppender(log);

	if (!appender)
		return FALSE;

	if (!appender->active)
		if (!WLog_OpenAppender(log))
			return FALSE;

	EnterCriticalSection(&appender->lock);

	if (appender->WriteMessage)
	{
		if (appender->recursive)
			status = log_recursion(message->FileName, message->FunctionName, message->LineNumber);
		else
		{
			appender->recursive = TRUE;
			status = appender->WriteMessage(log, appender, message);
			appender->recursive = FALSE;
		}
	}

	LeaveCriticalSection(&appender->lock);
	return status;
}

static BOOL WLog_WriteData(wLog* log, wLogMessage* message)
{
	BOOL status = 0;
	wLogAppender* appender = NULL;
	appender = WLog_GetLogAppender(log);

	if (!appender)
		return FALSE;

	if (!appender->active)
		if (!WLog_OpenAppender(log))
			return FALSE;

	if (!appender->WriteDataMessage)
		return FALSE;

	EnterCriticalSection(&appender->lock);

	if (appender->recursive)
		status = log_recursion(message->FileName, message->FunctionName, message->LineNumber);
	else
	{
		appender->recursive = TRUE;
		status = appender->WriteDataMessage(log, appender, message);
		appender->recursive = FALSE;
	}

	LeaveCriticalSection(&appender->lock);
	return status;
}

static BOOL WLog_WriteImage(wLog* log, wLogMessage* message)
{
	BOOL status = 0;
	wLogAppender* appender = NULL;
	appender = WLog_GetLogAppender(log);

	if (!appender)
		return FALSE;

	if (!appender->active)
		if (!WLog_OpenAppender(log))
			return FALSE;

	if (!appender->WriteImageMessage)
		return FALSE;

	EnterCriticalSection(&appender->lock);

	if (appender->recursive)
		status = log_recursion(message->FileName, message->FunctionName, message->LineNumber);
	else
	{
		appender->recursive = TRUE;
		status = appender->WriteImageMessage(log, appender, message);
		appender->recursive = FALSE;
	}

	LeaveCriticalSection(&appender->lock);
	return status;
}

static BOOL WLog_WritePacket(wLog* log, wLogMessage* message)
{
	BOOL status = 0;
	wLogAppender* appender = NULL;
	appender = WLog_GetLogAppender(log);

	if (!appender)
		return FALSE;

	if (!appender->active)
		if (!WLog_OpenAppender(log))
			return FALSE;

	if (!appender->WritePacketMessage)
		return FALSE;

	EnterCriticalSection(&appender->lock);

	if (appender->recursive)
		status = log_recursion(message->FileName, message->FunctionName, message->LineNumber);
	else
	{
		appender->recursive = TRUE;
		status = appender->WritePacketMessage(log, appender, message);
		appender->recursive = FALSE;
	}

	LeaveCriticalSection(&appender->lock);
	return status;
}

BOOL WLog_PrintMessageVA(wLog* log, DWORD type, DWORD level, size_t line, const char* file,
                         const char* function, va_list args)
{
	BOOL status = FALSE;
	wLogMessage message = { 0 };
	message.Type = type;
	message.Level = level;
	message.LineNumber = line;
	message.FileName = file;
	message.FunctionName = function;

	switch (type)
	{
		case WLOG_MESSAGE_TEXT:
			message.FormatString = va_arg(args, const char*);

			if (!strchr(message.FormatString, '%'))
			{
				message.TextString = message.FormatString;
				status = WLog_Write(log, &message);
			}
			else
			{
				char formattedLogMessage[WLOG_MAX_STRING_SIZE] = { 0 };

				WINPR_PRAGMA_DIAG_PUSH
				WINPR_PRAGMA_DIAG_IGNORED_FORMAT_NONLITERAL
				if (vsnprintf(formattedLogMessage, WLOG_MAX_STRING_SIZE - 1, message.FormatString,
				              args) < 0)
					return FALSE;
				WINPR_PRAGMA_DIAG_POP

				message.TextString = formattedLogMessage;
				status = WLog_Write(log, &message);
			}

			break;

		case WLOG_MESSAGE_DATA:
			message.Data = va_arg(args, void*);
			message.Length = va_arg(args, size_t);
			status = WLog_WriteData(log, &message);
			break;

		case WLOG_MESSAGE_IMAGE:
			message.ImageData = va_arg(args, void*);
			message.ImageWidth = va_arg(args, size_t);
			message.ImageHeight = va_arg(args, size_t);
			message.ImageBpp = va_arg(args, size_t);
			status = WLog_WriteImage(log, &message);
			break;

		case WLOG_MESSAGE_PACKET:
			message.PacketData = va_arg(args, void*);
			message.PacketLength = va_arg(args, size_t);
			message.PacketFlags = va_arg(args, unsigned);
			status = WLog_WritePacket(log, &message);
			break;

		default:
			break;
	}

	return status;
}

BOOL WLog_PrintMessage(wLog* log, DWORD type, DWORD level, size_t line, const char* file,
                       const char* function, ...)
{
	BOOL status = 0;
	va_list args;
	va_start(args, function);
	status = WLog_PrintMessageVA(log, type, level, line, file, function, args);
	va_end(args);
	return status;
}

DWORD WLog_GetLogLevel(wLog* log)
{
	if (!log)
		return WLOG_OFF;

	if (log->FilterLevel <= WLOG_FILTER_NOT_INITIALIZED)
		log->FilterLevel = WLog_GetFilterLogLevel(log);

	if (log->FilterLevel > WLOG_FILTER_NOT_FILTERED)
		return (DWORD)log->FilterLevel;
	else if (log->Level == WLOG_LEVEL_INHERIT)
		log->Level = WLog_GetLogLevel(log->Parent);

	return log->Level;
}

BOOL WLog_IsLevelActive(wLog* _log, DWORD _log_level)
{
	DWORD level = 0;

	if (!_log)
		return FALSE;

	level = WLog_GetLogLevel(_log);

	if (level == WLOG_OFF)
		return FALSE;

	return _log_level >= level;
}

BOOL WLog_SetStringLogLevel(wLog* log, LPCSTR level)
{
	int lvl = 0;

	if (!log || !level)
		return FALSE;

	lvl = WLog_ParseLogLevel(level);

	if (lvl < 0)
		return FALSE;

	return WLog_SetLogLevel(log, (DWORD)lvl);
}

static BOOL WLog_reset_log_filters(wLog* log)
{
	if (!log)
		return FALSE;

	log->FilterLevel = WLOG_FILTER_NOT_INITIALIZED;

	for (DWORD x = 0; x < log->ChildrenCount; x++)
	{
		wLog* child = log->Children[x];

		if (!WLog_reset_log_filters(child))
			return FALSE;
	}

	return TRUE;
}

static BOOL WLog_AddStringLogFilters_int(wLog* root, LPCSTR filter)
{
	LPSTR p = NULL;
	LPCSTR filterStr = NULL;

	if (!filter)
		return FALSE;

	DWORD count = 1;
	LPCSTR cpp = filter;

	while ((cpp = strchr(cpp, ',')) != NULL)
	{
		count++;
		cpp++;
	}

	DWORD pos = g_FilterCount;
	DWORD size = g_FilterCount + count;
	wLogFilter* tmp = (wLogFilter*)realloc(g_Filters, size * sizeof(wLogFilter));

	if (!tmp)
		return FALSE;

	g_Filters = tmp;
	LPSTR cp = (LPSTR)_strdup(filter);

	if (!cp)
		return FALSE;

	p = cp;
	filterStr = cp;

	do
	{
		p = strchr(p, ',');

		if (p)
			*p = '\0';

		if (pos < size)
		{
			if (!WLog_ParseFilter(root, &g_Filters[pos++], filterStr))
			{
				free(cp);
				return FALSE;
			}
		}
		else
			break;

		if (p)
		{
			filterStr = p + 1;
			p++;
		}
	} while (p != NULL);

	g_FilterCount = size;
	free(cp);
	return WLog_reset_log_filters(root);
}

BOOL WLog_AddStringLogFilters(LPCSTR filter)
{
	/* Ensure logger is initialized */
	wLog* root = WLog_GetRoot();
	return WLog_AddStringLogFilters_int(root, filter);
}

static BOOL WLog_UpdateInheritLevel(wLog* log, DWORD logLevel)
{
	if (!log)
		return FALSE;

	if (log->inherit)
	{
		log->Level = logLevel;

		for (DWORD x = 0; x < log->ChildrenCount; x++)
		{
			wLog* child = log->Children[x];

			if (!WLog_UpdateInheritLevel(child, logLevel))
				return FALSE;
		}
	}

	return TRUE;
}

BOOL WLog_SetLogLevel(wLog* log, DWORD logLevel)
{
	if (!log)
		return FALSE;

	if ((logLevel > WLOG_OFF) && (logLevel != WLOG_LEVEL_INHERIT))
		logLevel = WLOG_OFF;

	log->Level = logLevel;
	log->inherit = (logLevel == WLOG_LEVEL_INHERIT) ? TRUE : FALSE;

	for (DWORD x = 0; x < log->ChildrenCount; x++)
	{
		wLog* child = log->Children[x];

		if (!WLog_UpdateInheritLevel(child, logLevel))
			return FALSE;
	}

	return WLog_reset_log_filters(log);
}

int WLog_ParseLogLevel(LPCSTR level)
{
	int iLevel = -1;

	if (!level)
		return -1;

	if (_stricmp(level, "TRACE") == 0)
		iLevel = WLOG_TRACE;
	else if (_stricmp(level, "DEBUG") == 0)
		iLevel = WLOG_DEBUG;
	else if (_stricmp(level, "INFO") == 0)
		iLevel = WLOG_INFO;
	else if (_stricmp(level, "WARN") == 0)
		iLevel = WLOG_WARN;
	else if (_stricmp(level, "ERROR") == 0)
		iLevel = WLOG_ERROR;
	else if (_stricmp(level, "FATAL") == 0)
		iLevel = WLOG_FATAL;
	else if (_stricmp(level, "OFF") == 0)
		iLevel = WLOG_OFF;

	return iLevel;
}

BOOL WLog_ParseFilter(wLog* root, wLogFilter* filter, LPCSTR name)
{
	const char* pc = NULL;
	char* p = NULL;
	char* q = NULL;
	size_t count = 0;
	LPSTR names = NULL;
	int iLevel = 0;
	count = 1;

	WINPR_UNUSED(root);

	if (!name)
		return FALSE;

	pc = name;

	if (pc)
	{
		while ((pc = strchr(pc, '.')) != NULL)
		{
			count++;
			pc++;
		}
	}

	names = _strdup(name);

	if (!names)
		return FALSE;

	filter->NameCount = count;
	filter->Names = (LPSTR*)calloc((count + 1UL), sizeof(LPSTR));

	if (!filter->Names)
	{
		free(names);
		filter->NameCount = 0;
		return FALSE;
	}

	filter->Names[count] = NULL;
	count = 0;
	p = (char*)names;
	filter->Names[count++] = p;
	q = strrchr(p, ':');

	if (!q)
	{
		free(names);
		free((void*)filter->Names);
		filter->Names = NULL;
		filter->NameCount = 0;
		return FALSE;
	}

	*q = '\0';
	q++;
	iLevel = WLog_ParseLogLevel(q);

	if (iLevel < 0)
	{
		free(names);
		free((void*)filter->Names);
		filter->Names = NULL;
		filter->NameCount = 0;
		return FALSE;
	}

	filter->Level = (DWORD)iLevel;

	while ((p = strchr(p, '.')) != NULL)
	{
		if (count < filter->NameCount)
			filter->Names[count++] = p + 1;

		*p = '\0';
		p++;
	}

	return TRUE;
}

BOOL WLog_ParseFilters(wLog* root)
{
	LPCSTR filter = "WLOG_FILTER";
	BOOL res = FALSE;
	char* env = NULL;
	DWORD nSize = 0;
	free(g_Filters);
	g_Filters = NULL;
	g_FilterCount = 0;
	nSize = GetEnvironmentVariableA(filter, NULL, 0);

	if (nSize < 1)
		return TRUE;

	env = (LPSTR)malloc(nSize);

	if (!env)
		return FALSE;

	if (GetEnvironmentVariableA(filter, env, nSize) == nSize - 1)
		res = WLog_AddStringLogFilters_int(root, env);

	free(env);
	return res;
}

LONG WLog_GetFilterLogLevel(wLog* log)
{
	BOOL match = FALSE;

	if (log->FilterLevel >= 0)
		return log->FilterLevel;

	log->FilterLevel = WLOG_FILTER_NOT_FILTERED;
	for (DWORD i = 0; i < g_FilterCount; i++)
	{
		const wLogFilter* filter = &g_Filters[i];
		for (DWORD j = 0; j < filter->NameCount; j++)
		{
			if (j >= log->NameCount)
				break;

			if (_stricmp(filter->Names[j], "*") == 0)
			{
				match = TRUE;
				assert(filter->Level <= INT32_MAX);
				log->FilterLevel = (LONG)filter->Level;
				break;
			}

			if (_stricmp(filter->Names[j], log->Names[j]) != 0)
				break;

			if (j == (log->NameCount - 1))
			{
				match = log->NameCount == filter->NameCount;
				if (match)
				{
					assert(filter->Level <= INT32_MAX);
					log->FilterLevel = (LONG)filter->Level;
				}
				break;
			}
		}

		if (match)
			break;
	}

	return log->FilterLevel;
}

static BOOL WLog_ParseName(wLog* log, LPCSTR name)
{
	const char* cp = name;
	char* p = NULL;
	size_t count = 1;
	LPSTR names = NULL;

	while ((cp = strchr(cp, '.')) != NULL)
	{
		count++;
		cp++;
	}

	names = _strdup(name);

	if (!names)
		return FALSE;

	log->NameCount = count;
	log->Names = (LPSTR*)calloc((count + 1UL), sizeof(LPSTR));

	if (!log->Names)
	{
		free(names);
		return FALSE;
	}

	log->Names[count] = NULL;
	count = 0;
	p = (char*)names;
	log->Names[count++] = p;

	while ((p = strchr(p, '.')) != NULL)
	{
		if (count < log->NameCount)
			log->Names[count++] = p + 1;

		*p = '\0';
		p++;
	}

	return TRUE;
}

wLog* WLog_New(LPCSTR name, wLog* rootLogger)
{
	wLog* log = NULL;
	char* env = NULL;
	DWORD nSize = 0;
	int iLevel = 0;
	log = (wLog*)calloc(1, sizeof(wLog));

	if (!log)
		return NULL;

	log->Name = _strdup(name);

	if (!log->Name)
		goto out_fail;

	if (!WLog_ParseName(log, name))
		goto out_fail;

	log->Parent = rootLogger;
	log->ChildrenCount = 0;
	log->ChildrenSize = 16;
	log->FilterLevel = WLOG_FILTER_NOT_INITIALIZED;

	if (!(log->Children = (wLog**)calloc(log->ChildrenSize, sizeof(wLog*))))
		goto out_fail;

	log->Appender = NULL;

	if (rootLogger)
	{
		log->Level = WLOG_LEVEL_INHERIT;
		log->inherit = TRUE;
	}
	else
	{
		LPCSTR level = "WLOG_LEVEL";
		log->Level = WLOG_INFO;
		nSize = GetEnvironmentVariableA(level, NULL, 0);

		if (nSize)
		{
			env = (LPSTR)malloc(nSize);

			if (!env)
				goto out_fail;

			if (GetEnvironmentVariableA(level, env, nSize) != nSize - 1)
			{
				(void)fprintf(stderr, "%s environment variable changed in my back !\n", level);
				free(env);
				goto out_fail;
			}

			iLevel = WLog_ParseLogLevel(env);
			free(env);

			if (iLevel >= 0)
			{
				if (!WLog_SetLogLevel(log, (DWORD)iLevel))
					goto out_fail;
			}
		}
	}

	iLevel = WLog_GetFilterLogLevel(log);

	if (iLevel >= 0)
	{
		if (!WLog_SetLogLevel(log, (DWORD)iLevel))
			goto out_fail;
	}

	InitializeCriticalSectionAndSpinCount(&log->lock, 4000);

	return log;
out_fail:
	WLog_Free(log);
	return NULL;
}

void WLog_Free(wLog* log)
{
	if (log)
	{
		if (log->Appender)
		{
			WLog_Appender_Free(log, log->Appender);
			log->Appender = NULL;
		}

		free(log->Name);

		/* The first element in this array is allocated, the rest are indices into this variable */
		if (log->Names)
			free(log->Names[0]);
		free((void*)log->Names);
		free((void*)log->Children);
		DeleteCriticalSection(&log->lock);
		free(log);
	}
}

wLog* WLog_GetRoot(void)
{
	if (!InitOnceExecuteOnce(&g_WLogInitialized, WLog_InitializeRoot, NULL, NULL))
		return NULL;

	return g_RootLog;
}

static BOOL WLog_AddChild(wLog* parent, wLog* child)
{
	BOOL status = FALSE;

	WLog_Lock(parent);

	if (parent->ChildrenCount >= parent->ChildrenSize)
	{
		wLog** tmp = NULL;
		parent->ChildrenSize *= 2;

		if (!parent->ChildrenSize)
		{
			free((void*)parent->Children);
			parent->Children = NULL;
		}
		else
		{
			tmp = (wLog**)realloc((void*)parent->Children, sizeof(wLog*) * parent->ChildrenSize);

			if (!tmp)
			{
				free((void*)parent->Children);
				parent->Children = NULL;
				goto exit;
			}

			parent->Children = tmp;
		}
	}

	if (!parent->Children)
		goto exit;

	parent->Children[parent->ChildrenCount++] = child;
	child->Parent = parent;

	WLog_Unlock(parent);

	status = TRUE;
exit:
	return status;
}

static wLog* WLog_FindChild(wLog* root, LPCSTR name)
{
	wLog* child = NULL;
	BOOL found = FALSE;

	if (!root)
		return NULL;

	WLog_Lock(root);

	for (DWORD index = 0; index < root->ChildrenCount; index++)
	{
		child = root->Children[index];

		if (strcmp(child->Name, name) == 0)
		{
			found = TRUE;
			break;
		}
	}

	WLog_Unlock(root);

	return (found) ? child : NULL;
}

static wLog* WLog_Get_int(wLog* root, LPCSTR name)
{
	wLog* log = NULL;

	if (!(log = WLog_FindChild(root, name)))
	{
		if (!root)
			return NULL;

		if (!(log = WLog_New(name, root)))
			return NULL;

		if (!WLog_AddChild(root, log))
		{
			WLog_Free(log);
			return NULL;
		}
	}

	return log;
}

wLog* WLog_Get(LPCSTR name)
{
	wLog* root = WLog_GetRoot();
	return WLog_Get_int(root, name);
}

#if defined(WITH_WINPR_DEPRECATED)
BOOL WLog_Init(void)
{
	return WLog_GetRoot() != NULL;
}

BOOL WLog_Uninit(void)
{
	wLog* root = g_RootLog;

	if (!root)
		return FALSE;

	WLog_Lock(root);

	for (DWORD index = 0; index < root->ChildrenCount; index++)
	{
		wLog* child = root->Children[index];
		WLog_Free(child);
	}

	WLog_Unlock(root);

	WLog_Free(root);
	g_RootLog = NULL;

	return TRUE;
}
#endif

BOOL WLog_SetContext(wLog* log, const char* (*fkt)(void*), void* context)
{
	WINPR_ASSERT(log);

	log->custom = fkt;
	log->context = context;
	return TRUE;
}
