/**
 * WinPR: Windows Portable Runtime
 * WinPR Logger
 *
 * Copyright 2013 Marc-Andre Moreau <marcandre.moreau@gmail.com>
 * Copyright 2015 Thincast Technologies GmbH
 * Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.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 "BinaryAppender.h"
#include <winpr/crt.h>
#include <winpr/assert.h>
#include <winpr/file.h>
#include <winpr/path.h>
#include <winpr/stream.h>

typedef struct
{
	wLogAppender common;

	char* FileName;
	char* FilePath;
	char* FullFileName;
	FILE* FileDescriptor;
} wLogBinaryAppender;

static BOOL WLog_BinaryAppender_Open(wLog* log, wLogAppender* appender)
{
	wLogBinaryAppender* binaryAppender = nullptr;
	if (!log || !appender)
		return FALSE;

	binaryAppender = (wLogBinaryAppender*)appender;
	if (!binaryAppender->FileName)
	{
		binaryAppender->FileName = (char*)malloc(MAX_PATH);
		if (!binaryAppender->FileName)
			return FALSE;
		(void)sprintf_s(binaryAppender->FileName, MAX_PATH, "%" PRIu32 ".wlog",
		                GetCurrentProcessId());
	}

	if (!binaryAppender->FilePath)
	{
		binaryAppender->FilePath = GetKnownSubPath(KNOWN_PATH_TEMP, "wlog");
		if (!binaryAppender->FilePath)
			return FALSE;
	}

	if (!binaryAppender->FullFileName)
	{
		binaryAppender->FullFileName =
		    GetCombinedPath(binaryAppender->FilePath, binaryAppender->FileName);
		if (!binaryAppender->FullFileName)
			return FALSE;
	}

	if (!winpr_PathFileExists(binaryAppender->FilePath))
	{
		if (!winpr_PathMakePath(binaryAppender->FilePath, nullptr))
			return FALSE;
		UnixChangeFileMode(binaryAppender->FilePath, 0xFFFF);
	}

	binaryAppender->FileDescriptor = winpr_fopen(binaryAppender->FullFileName, "a+");

	return binaryAppender->FileDescriptor != nullptr;
}

static BOOL WLog_BinaryAppender_Close(WINPR_ATTR_UNUSED wLog* log, wLogAppender* appender)
{
	wLogBinaryAppender* binaryAppender = nullptr;

	if (!appender)
		return FALSE;

	binaryAppender = (wLogBinaryAppender*)appender;
	if (!binaryAppender->FileDescriptor)
		return TRUE;

	if (binaryAppender->FileDescriptor)
		(void)fclose(binaryAppender->FileDescriptor);

	binaryAppender->FileDescriptor = nullptr;

	return TRUE;
}

static BOOL WLog_BinaryAppender_WriteMessage(wLog* log, wLogAppender* appender,
                                             const wLogMessage* message)
{
	FILE* fp = nullptr;
	wStream* s = nullptr;
	size_t MessageLength = 0;
	size_t FileNameLength = 0;
	size_t FunctionNameLength = 0;
	size_t TextStringLength = 0;
	BOOL ret = TRUE;
	wLogBinaryAppender* binaryAppender = nullptr;

	if (!log || !appender || !message)
		return FALSE;

	binaryAppender = (wLogBinaryAppender*)appender;

	fp = binaryAppender->FileDescriptor;

	if (!fp)
		return FALSE;

	FileNameLength = strnlen(message->FileName, INT_MAX);
	FunctionNameLength = strnlen(message->FunctionName, INT_MAX);
	TextStringLength = strnlen(message->TextString, INT_MAX);

	MessageLength =
	    16 + (4 + FileNameLength + 1) + (4 + FunctionNameLength + 1) + (4 + TextStringLength + 1);

	if ((MessageLength > UINT32_MAX) || (FileNameLength > UINT32_MAX) ||
	    (FunctionNameLength > UINT32_MAX) || (TextStringLength > UINT32_MAX))
		return FALSE;

	s = Stream_New(nullptr, MessageLength);
	if (!s)
		return FALSE;

	Stream_Write_UINT32(s, (UINT32)MessageLength);

	Stream_Write_UINT32(s, message->Type);
	Stream_Write_UINT32(s, message->Level);

	WINPR_ASSERT(message->LineNumber <= UINT32_MAX);
	Stream_Write_UINT32(s, (UINT32)message->LineNumber);

	Stream_Write_UINT32(s, (UINT32)FileNameLength);
	Stream_Write(s, message->FileName, FileNameLength + 1);

	Stream_Write_UINT32(s, (UINT32)FunctionNameLength);
	Stream_Write(s, message->FunctionName, FunctionNameLength + 1);

	Stream_Write_UINT32(s, (UINT32)TextStringLength);
	Stream_Write(s, message->TextString, TextStringLength + 1);

	Stream_SealLength(s);

	if (fwrite(Stream_Buffer(s), MessageLength, 1, fp) != 1)
		ret = FALSE;

	Stream_Free(s, TRUE);

	return ret;
}

static BOOL WLog_BinaryAppender_WriteDataMessage(WINPR_ATTR_UNUSED wLog* log,
                                                 WINPR_ATTR_UNUSED wLogAppender* appender,
                                                 WINPR_ATTR_UNUSED const wLogMessage* message)
{
	return TRUE;
}

static BOOL WLog_BinaryAppender_WriteImageMessage(WINPR_ATTR_UNUSED wLog* log,
                                                  WINPR_ATTR_UNUSED wLogAppender* appender,
                                                  WINPR_ATTR_UNUSED const wLogMessage* message)
{
	return TRUE;
}

static BOOL WLog_BinaryAppender_Set(wLogAppender* appender, const char* setting, void* value)
{
	wLogBinaryAppender* binaryAppender = (wLogBinaryAppender*)appender;

	/* Just check if the value string is longer than 0 */
	if (!value || (strnlen(value, 2) == 0))
		return FALSE;

	if (!strcmp("outputfilename", setting))
	{
		binaryAppender->FileName = _strdup((const char*)value);
		if (!binaryAppender->FileName)
			return FALSE;
	}
	else if (!strcmp("outputfilepath", setting))
	{
		binaryAppender->FilePath = _strdup((const char*)value);
		if (!binaryAppender->FilePath)
			return FALSE;
	}
	else
		return FALSE;

	return TRUE;
}

static void WLog_BinaryAppender_Free(wLogAppender* appender)
{
	wLogBinaryAppender* binaryAppender = nullptr;
	if (appender)
	{
		binaryAppender = (wLogBinaryAppender*)appender;
		free(binaryAppender->FileName);
		free(binaryAppender->FilePath);
		free(binaryAppender->FullFileName);
		free(binaryAppender);
	}
}

wLogAppender* WLog_BinaryAppender_New(WINPR_ATTR_UNUSED wLog* log)
{
	wLogBinaryAppender* BinaryAppender = (wLogBinaryAppender*)calloc(1, sizeof(wLogBinaryAppender));
	if (!BinaryAppender)
		return nullptr;

	BinaryAppender->common.Type = WLOG_APPENDER_BINARY;
	BinaryAppender->common.Open = WLog_BinaryAppender_Open;
	BinaryAppender->common.Close = WLog_BinaryAppender_Close;
	BinaryAppender->common.WriteMessage = WLog_BinaryAppender_WriteMessage;
	BinaryAppender->common.WriteDataMessage = WLog_BinaryAppender_WriteDataMessage;
	BinaryAppender->common.WriteImageMessage = WLog_BinaryAppender_WriteImageMessage;
	BinaryAppender->common.Free = WLog_BinaryAppender_Free;
	BinaryAppender->common.Set = WLog_BinaryAppender_Set;

	return &BinaryAppender->common;
}
