/**
 * WinPR: Windows Portable Runtime
 * Process Environment Functions
 *
 * Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
 * Copyright 2013 Thincast Technologies GmbH
 * Copyright 2013 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 <winpr/crt.h>
#include <winpr/platform.h>
#include <winpr/error.h>
#include <winpr/file.h>
#include <winpr/string.h>
#include <winpr/wlog.h>

#include <winpr/environment.h>

#include "../log.h"

#define TAG WINPR_TAG("environment")

#ifndef _WIN32

#include <errno.h>

#ifdef WINPR_HAVE_UNISTD_H
#include <unistd.h>
#endif

#if defined(__IOS__)

#elif defined(__MACOSX__)
#include <crt_externs.h>
#define environ (*_NSGetEnviron())
#endif

DWORD GetCurrentDirectoryA(DWORD nBufferLength, LPSTR lpBuffer)
{
	size_t length = 0;
	char* cwd = nullptr;
	char* ccwd = nullptr;

	do
	{
		length += MAX_PATH;
		char* tmp = realloc(cwd, length);
		if (!tmp)
		{
			free(cwd);
			return 0;
		}
		cwd = tmp;

		ccwd = getcwd(cwd, length);
	} while (!ccwd && (errno == ERANGE));

	if (!ccwd)
	{
		free(cwd);
		return 0;
	}

	length = strnlen(cwd, length);

	if ((nBufferLength == 0) && (lpBuffer == nullptr))
	{
		free(cwd);
		return (DWORD)length;
	}
	else
	{
		if (lpBuffer == nullptr)
		{
			free(cwd);
			return 0;
		}

		if ((length + 1) > nBufferLength)
		{
			free(cwd);
			return (DWORD)(length + 1);
		}

		memcpy(lpBuffer, cwd, length + 1);
		free(cwd);
		return (DWORD)length;
	}
}

DWORD GetCurrentDirectoryW(WINPR_ATTR_UNUSED DWORD nBufferLength, WINPR_ATTR_UNUSED LPWSTR lpBuffer)
{
	WLog_ERR(TAG, "TODO: not implemented");
	return 0;
}

BOOL SetCurrentDirectoryA(WINPR_ATTR_UNUSED LPCSTR lpPathName)
{
	WLog_ERR(TAG, "TODO: not implemented");
	return TRUE;
}

BOOL SetCurrentDirectoryW(WINPR_ATTR_UNUSED LPCWSTR lpPathName)
{
	WLog_ERR(TAG, "TODO: not implemented");
	return TRUE;
}

DWORD SearchPathA(WINPR_ATTR_UNUSED LPCSTR lpPath, WINPR_ATTR_UNUSED LPCSTR lpFileName,
                  WINPR_ATTR_UNUSED LPCSTR lpExtension, WINPR_ATTR_UNUSED DWORD nBufferLength,
                  WINPR_ATTR_UNUSED LPSTR lpBuffer, WINPR_ATTR_UNUSED LPSTR* lpFilePart)
{
	WLog_ERR(TAG, "TODO: not implemented");
	return 0;
}

DWORD SearchPathW(WINPR_ATTR_UNUSED LPCWSTR lpPath, WINPR_ATTR_UNUSED LPCWSTR lpFileName,
                  WINPR_ATTR_UNUSED LPCWSTR lpExtension, WINPR_ATTR_UNUSED DWORD nBufferLength,
                  WINPR_ATTR_UNUSED LPWSTR lpBuffer, WINPR_ATTR_UNUSED LPWSTR* lpFilePart)
{
	WLog_ERR(TAG, "TODO: not implemented");
	return 0;
}

LPSTR GetCommandLineA(VOID)
{
	WLog_ERR(TAG, "TODO: not implemented");
	return nullptr;
}

LPWSTR GetCommandLineW(VOID)
{
	WLog_ERR(TAG, "TODO: not implemented");
	return nullptr;
}

BOOL NeedCurrentDirectoryForExePathA(WINPR_ATTR_UNUSED LPCSTR ExeName)
{
	WLog_ERR(TAG, "TODO: not implemented");
	return TRUE;
}

BOOL NeedCurrentDirectoryForExePathW(WINPR_ATTR_UNUSED LPCWSTR ExeName)
{
	WLog_ERR(TAG, "TODO: not implemented");
	return TRUE;
}

#endif

#if !defined(_WIN32) || defined(_UWP)

DWORD GetEnvironmentVariableA(LPCSTR lpName, LPSTR lpBuffer, DWORD nSize)
{
#if !defined(_UWP)
	size_t length = 0;

	// NOLINTNEXTLINE(concurrency-mt-unsafe)
	char* env = getenv(lpName);

	if (!env)
	{
		SetLastError(ERROR_ENVVAR_NOT_FOUND);
		return 0;
	}

	length = strlen(env);

	if ((length + 1 > nSize) || (!lpBuffer))
		return (DWORD)length + 1;

	CopyMemory(lpBuffer, env, length);
	lpBuffer[length] = '\0';

	return (DWORD)length;
#else
	SetLastError(ERROR_ENVVAR_NOT_FOUND);
	return 0;
#endif
}

DWORD GetEnvironmentVariableW(WINPR_ATTR_UNUSED LPCWSTR lpName, WINPR_ATTR_UNUSED LPWSTR lpBuffer,
                              WINPR_ATTR_UNUSED DWORD nSize)
{
	WLog_ERR(TAG, "TODO: not implemented");
	SetLastError(ERROR_ENVVAR_NOT_FOUND);
	return 0;
}

BOOL SetEnvironmentVariableA(LPCSTR lpName, LPCSTR lpValue)
{
#if !defined(_UWP)
	if (!lpName)
		return FALSE;

	if (lpValue)
	{
		// NOLINTNEXTLINE(concurrency-mt-unsafe)
		if (0 != setenv(lpName, lpValue, 1))
			return FALSE;
	}
	else
	{
		// NOLINTNEXTLINE(concurrency-mt-unsafe)
		if (0 != unsetenv(lpName))
			return FALSE;
	}

	return TRUE;
#else
	return FALSE;
#endif
}

BOOL SetEnvironmentVariableW(WINPR_ATTR_UNUSED LPCWSTR lpName, WINPR_ATTR_UNUSED LPCWSTR lpValue)
{
	WLog_ERR(TAG, "TODO: not implemented");
	return FALSE;
}

/**
 * GetEnvironmentStrings function:
 * http://msdn.microsoft.com/en-us/library/windows/desktop/ms683187/
 *
 * The GetEnvironmentStrings function returns a pointer to a block of memory
 * that contains the environment variables of the calling process (both the
 * system and the user environment variables). Each environment block contains
 * the environment variables in the following format:
 *
 * Var1=Value1\0
 * Var2=Value2\0
 * Var3=Value3\0
 * ...
 * VarN=ValueN\0\0
 */

extern char** environ;

WINPR_ATTR_MALLOC(FreeEnvironmentStringsA, 1)
static LPCH GetEnvironmentStringsAN(size_t* pLen)
{
#if !defined(_UWP)
	size_t offset = 0;
	char** envp = environ;
	const size_t blocksize = 128;
	size_t cchEnvironmentBlock = blocksize;
	LPCH lpszEnvironmentBlock = (LPCH)calloc(cchEnvironmentBlock, sizeof(CHAR));

	if (pLen)
		*pLen = 0;

	if (!lpszEnvironmentBlock)
		return nullptr;

	while (*envp)
	{
		const size_t length = strlen(*envp);
		const size_t required = offset + length + 8ull;
		if (required > UINT32_MAX)
		{
			WLog_ERR(TAG, "Environment block too large: %" PRIuz, required);

			free(lpszEnvironmentBlock);
			return nullptr;
		}

		if (required > cchEnvironmentBlock)
		{
			size_t new_size = cchEnvironmentBlock;
			do
			{
				new_size += blocksize;
			} while (new_size <= required);
			LPCH new_blk = (LPCH)realloc(lpszEnvironmentBlock, new_size * sizeof(CHAR));
			if (!new_blk)
			{
				free(lpszEnvironmentBlock);
				return nullptr;
			}

			const size_t diff = new_size - cchEnvironmentBlock;
			const size_t old = cchEnvironmentBlock;
			lpszEnvironmentBlock = new_blk;
			cchEnvironmentBlock = new_size;

			memset(&lpszEnvironmentBlock[old], 0, diff);
		}

		char* p = &(lpszEnvironmentBlock[offset]);

		CopyMemory(p, *envp, length * sizeof(CHAR));
		p[length] = '\0';

		offset += (length + 1ull);
		envp++;
	}

	lpszEnvironmentBlock[offset] = '\0';
	if (pLen)
		*pLen = cchEnvironmentBlock;

	return lpszEnvironmentBlock;
#else
	if (pLen)
		*pLen = 0;
	return nullptr;
#endif
}

LPCH GetEnvironmentStringsA(VOID)
{
	return GetEnvironmentStringsAN(nullptr);
}

LPWCH GetEnvironmentStringsW(VOID)
{
	size_t len = 0;
	LPCH env = GetEnvironmentStringsAN(&len);
	if (!env)
		return nullptr;
	LPWCH envW = ConvertMszUtf8NToWCharAlloc(env, len, nullptr);
	FreeEnvironmentStringsA(env);
	return envW;
}

BOOL SetEnvironmentStringsA(WINPR_ATTR_UNUSED LPCH NewEnvironment)
{
	WLog_ERR(TAG, "TODO: not implemented");
	return TRUE;
}

BOOL SetEnvironmentStringsW(WINPR_ATTR_UNUSED LPWCH NewEnvironment)
{
	WLog_ERR(TAG, "TODO: not implemented");
	return TRUE;
}

DWORD ExpandEnvironmentStringsA(WINPR_ATTR_UNUSED LPCSTR lpSrc, WINPR_ATTR_UNUSED LPSTR lpDst,
                                WINPR_ATTR_UNUSED DWORD nSize)
{
	WLog_ERR(TAG, "TODO: not implemented");
	return 0;
}

DWORD ExpandEnvironmentStringsW(WINPR_ATTR_UNUSED LPCWSTR lpSrc, WINPR_ATTR_UNUSED LPWSTR lpDst,
                                WINPR_ATTR_UNUSED DWORD nSize)
{
	WLog_ERR(TAG, "TODO: not implemented");
	return 0;
}

BOOL FreeEnvironmentStringsA(LPCH lpszEnvironmentBlock)
{
	free(lpszEnvironmentBlock);

	return TRUE;
}

BOOL FreeEnvironmentStringsW(LPWCH lpszEnvironmentBlock)
{
	free(lpszEnvironmentBlock);

	return TRUE;
}

#endif

LPCH MergeEnvironmentStrings(PCSTR original, PCSTR merge)
{
	const char* cp = nullptr;
	char* p = nullptr;
	size_t offset = 0;
	size_t length = 0;
	const char* envp = nullptr;
	DWORD cchEnvironmentBlock = 0;
	LPCH lpszEnvironmentBlock = nullptr;
	const char** mergeStrings = nullptr;
	size_t mergeStringLength = 0;
	size_t mergeArraySize = 128;
	size_t mergeLength = 0;
	size_t foundMerge = 0;
	char* foundEquals = nullptr;

	mergeStrings = (LPCSTR*)calloc(mergeArraySize, sizeof(char*));

	if (!mergeStrings)
		return nullptr;

	mergeStringLength = 0;

	cp = merge;

	while (*cp && *(cp + 1))
	{
		length = strlen(cp);

		if (mergeStringLength == mergeArraySize)
		{
			const char** new_str = nullptr;

			mergeArraySize += 128;
			new_str = (const char**)realloc((void*)mergeStrings, mergeArraySize * sizeof(char*));

			if (!new_str)
			{
				free((void*)mergeStrings);
				return nullptr;
			}
			mergeStrings = new_str;
		}

		mergeStrings[mergeStringLength] = cp;
		cp += length + 1;
		mergeStringLength++;
	}

	offset = 0;

	cchEnvironmentBlock = 128;
	lpszEnvironmentBlock = (LPCH)calloc(cchEnvironmentBlock, sizeof(CHAR));

	if (!lpszEnvironmentBlock)
	{
		free((void*)mergeStrings);
		return nullptr;
	}

	envp = original;

	while ((original != nullptr) && (*envp && *(envp + 1)))
	{
		size_t old_offset = offset;
		length = strlen(envp);

		while ((offset + length + 8) > cchEnvironmentBlock)
		{
			cchEnvironmentBlock *= 2;
			LPCH tmp = (LPCH)realloc(lpszEnvironmentBlock, cchEnvironmentBlock * sizeof(CHAR));

			if (!tmp)
			{
				free((void*)lpszEnvironmentBlock);
				free((void*)mergeStrings);
				return nullptr;
			}
			lpszEnvironmentBlock = tmp;
		}

		p = &(lpszEnvironmentBlock[offset]);

		// check if this value is in the mergeStrings
		foundMerge = 0;
		for (size_t run = 0; run < mergeStringLength; run++)
		{
			if (!mergeStrings[run])
				continue;

			mergeLength = strlen(mergeStrings[run]);
			foundEquals = strstr(mergeStrings[run], "=");

			if (!foundEquals)
				continue;

			const intptr_t len = foundEquals - mergeStrings[run] + 1;
			if (strncmp(envp, mergeStrings[run], WINPR_ASSERTING_INT_CAST(size_t, len)) == 0)
			{
				// found variable in merge list ... use this ....
				if (*(foundEquals + 1) == '\0')
				{
					// check if the argument is set ... if not remove variable ...
					foundMerge = 1;
				}
				else
				{
					while ((offset + mergeLength + 8) > cchEnvironmentBlock)
					{
						cchEnvironmentBlock *= 2;
						LPCH tmp =
						    (LPCH)realloc(lpszEnvironmentBlock, cchEnvironmentBlock * sizeof(CHAR));

						if (!tmp)
						{
							free((void*)lpszEnvironmentBlock);
							free((void*)mergeStrings);
							return nullptr;
						}
						lpszEnvironmentBlock = tmp;
						p = &(lpszEnvironmentBlock[old_offset]);
					}

					foundMerge = 1;
					CopyMemory(p, mergeStrings[run], mergeLength);
					mergeStrings[run] = nullptr;
					p[mergeLength] = '\0';
					offset += (mergeLength + 1);
				}
			}
		}

		if (foundMerge == 0)
		{
			CopyMemory(p, envp, length * sizeof(CHAR));
			p[length] = '\0';
			offset += (length + 1);
		}

		envp += (length + 1);
	}

	// now merge the not already merged env
	for (size_t run = 0; run < mergeStringLength; run++)
	{
		if (!mergeStrings[run])
			continue;

		mergeLength = strlen(mergeStrings[run]);

		while ((offset + mergeLength + 8) > cchEnvironmentBlock)
		{
			cchEnvironmentBlock *= 2;
			LPCH tmp = (LPCH)realloc(lpszEnvironmentBlock, cchEnvironmentBlock * sizeof(CHAR));

			if (!tmp)
			{
				free((void*)lpszEnvironmentBlock);
				free((void*)mergeStrings);
				return nullptr;
			}

			lpszEnvironmentBlock = tmp;
		}

		p = &(lpszEnvironmentBlock[offset]);

		CopyMemory(p, mergeStrings[run], mergeLength);
		mergeStrings[run] = nullptr;
		p[mergeLength] = '\0';
		offset += (mergeLength + 1);
	}

	lpszEnvironmentBlock[offset] = '\0';

	free((void*)mergeStrings);

	return lpszEnvironmentBlock;
}

DWORD GetEnvironmentVariableEBA(LPCSTR envBlock, LPCSTR lpName, LPSTR lpBuffer, DWORD nSize)
{
	size_t vLength = 0;
	char* env = nullptr;
	char* foundEquals = nullptr;
	const char* penvb = envBlock;
	size_t nLength = 0;
	size_t fLength = 0;
	size_t lpNameLength = 0;

	if (!lpName || nullptr == envBlock)
		return 0;

	lpNameLength = strlen(lpName);

	if (lpNameLength < 1)
		return 0;

	while (*penvb && *(penvb + 1))
	{
		fLength = strlen(penvb);
		foundEquals = strstr(penvb, "=");

		if (!foundEquals)
		{
			/* if no = sign is found the envBlock is broken */
			return 0;
		}

		nLength = WINPR_ASSERTING_INT_CAST(size_t, (foundEquals - penvb));

		if (nLength != lpNameLength)
		{
			penvb += (fLength + 1);
			continue;
		}

		if (strncmp(penvb, lpName, nLength) == 0)
		{
			env = foundEquals + 1;
			break;
		}

		penvb += (fLength + 1);
	}

	if (!env)
		return 0;

	vLength = strlen(env);
	if (vLength >= UINT32_MAX)
		return 0;

	if ((vLength + 1 > nSize) || (!lpBuffer))
		return (DWORD)vLength + 1;

	CopyMemory(lpBuffer, env, vLength + 1);

	return (DWORD)vLength;
}

BOOL SetEnvironmentVariableEBA(LPSTR* envBlock, LPCSTR lpName, LPCSTR lpValue)
{
	size_t length = 0;
	char* envstr = nullptr;
	char* newEB = nullptr;

	if (!lpName)
		return FALSE;

	if (lpValue)
	{
		length = (strlen(lpName) + strlen(lpValue) + 2); /* +2 because of = and \0 */
		envstr = (char*)malloc(length + 1);              /* +1 because of closing \0 */

		if (!envstr)
			return FALSE;

		(void)sprintf_s(envstr, length, "%s=%s", lpName, lpValue);
	}
	else
	{
		length = strlen(lpName) + 2;        /* +2 because of = and \0 */
		envstr = (char*)malloc(length + 1); /* +1 because of closing \0 */

		if (!envstr)
			return FALSE;

		(void)sprintf_s(envstr, length, "%s=", lpName);
	}

	envstr[length] = '\0';

	newEB = MergeEnvironmentStrings((LPCSTR)*envBlock, envstr);

	free(envstr);
	free(*envBlock);

	*envBlock = newEB;

	return TRUE;
}

char** EnvironmentBlockToEnvpA(LPCH lpszEnvironmentBlock)
{
	char* p = nullptr;
	SSIZE_T index = 0;
	size_t count = 0;
	size_t length = 0;
	char** envp = nullptr;

	count = 0;
	if (!lpszEnvironmentBlock)
		return nullptr;

	p = (char*)lpszEnvironmentBlock;

	while (p[0] && p[1])
	{
		length = strlen(p);
		p += (length + 1);
		count++;
	}

	index = 0;
	p = (char*)lpszEnvironmentBlock;

	envp = (char**)calloc(count + 1, sizeof(char*));
	if (!envp)
		return nullptr;
	envp[count] = nullptr;

	while (p[0] && p[1])
	{
		length = strlen(p);
		envp[index] = _strdup(p);
		if (!envp[index])
		{
			for (index -= 1; index >= 0; --index)
			{
				free(envp[index]);
			}
			free((void*)envp);
			return nullptr;
		}
		p += (length + 1);
		index++;
	}

	return envp;
}

#ifdef _WIN32

// https://devblogs.microsoft.com/oldnewthing/20100203-00/?p=15083
#define WINPR_MAX_ENVIRONMENT_LENGTH 2048

DWORD GetEnvironmentVariableX(const char* lpName, char* lpBuffer, DWORD nSize)
{
	DWORD result = 0;
	DWORD nSizeW = 0;
	LPWSTR lpNameW = nullptr;
	LPWSTR lpBufferW = nullptr;
	LPSTR lpBufferA = lpBuffer;

	lpNameW = ConvertUtf8ToWCharAlloc(lpName, nullptr);
	if (!lpNameW)
		goto cleanup;

	if (!lpBuffer)
	{
		char lpBufferMaxA[WINPR_MAX_ENVIRONMENT_LENGTH] = WINPR_C_ARRAY_INIT;
		WCHAR lpBufferMaxW[WINPR_MAX_ENVIRONMENT_LENGTH] = WINPR_C_ARRAY_INIT;
		LPSTR lpTmpBuffer = lpBufferMaxA;

		nSizeW = ARRAYSIZE(lpBufferMaxW);

		result = GetEnvironmentVariableW(lpNameW, lpBufferMaxW, nSizeW);

		SSIZE_T rc =
		    ConvertWCharNToUtf8(lpBufferMaxW, nSizeW, lpTmpBuffer, ARRAYSIZE(lpBufferMaxA));
		if ((rc < 0) || (rc >= UINT32_MAX))
			goto cleanup;

		result = (DWORD)rc + 1;
	}
	else
	{
		nSizeW = nSize;
		lpBufferW = calloc(nSizeW + 1, sizeof(WCHAR));

		if (!lpBufferW)
			goto cleanup;

		result = GetEnvironmentVariableW(lpNameW, lpBufferW, nSizeW);

		if (result == 0)
			goto cleanup;

		SSIZE_T rc = ConvertWCharNToUtf8(lpBufferW, nSizeW, lpBufferA, nSize);
		if ((rc < 0) || (rc > UINT32_MAX))
			goto cleanup;

		result = (DWORD)rc;
	}

cleanup:
	free(lpBufferW);
	free(lpNameW);

	return result;
}

#else

DWORD GetEnvironmentVariableX(const char* lpName, char* lpBuffer, DWORD nSize)
{
	return GetEnvironmentVariableA(lpName, lpBuffer, nSize);
}

#endif
