#include "osutils.h"
#include <fstream>

#ifdef __APPLE__
#include <CoreServices/CoreServices.h>
#include <CoreFoundation/CoreFoundation.h>
#include <dlfcn.h>
#elif defined(__unix__)
#include <dlfcn.h>
#include <sys/time.h>
#include <sys/uio.h>
#include <langinfo.h>
#include <pwd.h>
#else
#pragma warning( disable : 4091 )
#include <shlobj.h>
#pragma warning( default: 4091 )
#endif

#define FILE_OPEN_MODE(fm) ((fm) & 0xf)
#define FILE_SHARE_MODE(fm) ((fm) & 0xf0)

namespace os
{

static const uint8_t utf8_limits[5] = {0xC0, 0xE0, 0xF0, 0xF8, 0xFC};

unicode_string FromUTF8(const std::string &src)
{
	unicode_string dest;

	size_t pos = 0;
	size_t len = src.size();
	while (pos < len) {
		uint8_t c = src[pos++];

		if (c < 0x80) {
			dest += c;
			continue;
		}

		size_t val_len;
		for (val_len = 0; val_len < _countof(utf8_limits); val_len++) {
			if (c < utf8_limits[val_len])
				break;
		}

		if (val_len == 0)
			continue;

		uint32_t value = c - utf8_limits[val_len - 1];
		while (val_len) {
			if (pos == len)
				break;
			c = src[pos++];
			if (c < 0x80 || c >= 0xC0)
				break;
			value <<= 6;
			value |= (c - 0x80);
			val_len--;
		}

		if (value < 0x10000) {
			dest += static_cast<uint16_t>(value);
		} else if (value <= 0x10FFFF) {
			value -= 0x10000;
			dest += static_cast<uint16_t>(0xD800 + (value >> 10));
			dest += static_cast<uint16_t>(0xDC00 + (value & 0x3FF));
		}
	}

	return dest;
}

#ifdef VMP_GNU
std::wstring UCS4FromUTF8(const std::string &src)
{
	std::wstring dest;

	size_t pos = 0;
	size_t len = src.size();
	while (pos < len) {
		uint8_t c = src[pos++];

		if (c < 0x80) {
			dest += c;
			continue;
		}

		size_t val_len;
		for (val_len = 0; val_len < _countof(utf8_limits); val_len++) {
			if (c < utf8_limits[val_len])
				break;
		}

		if (val_len == 0)
			continue;

		uint32_t value = c - utf8_limits[val_len - 1];
		while (val_len) {
			if (pos == len)
				break;
			c = src[pos++];
			if (c < 0x80 || c >= 0xC0)
				break;
			value <<= 6;
			value |= (c - 0x80);
			val_len--;
		}

		dest += static_cast<wchar_t>(value);
	}

	return dest;
}
#endif

std::string ToUTF8(const unicode_string &src)
{
	std::string dest;

	size_t pos = 0;
	size_t len = src.size();
	while (pos < len) {
		uint16_t c = src[pos++];
		if (c < 0x80) {
			dest += static_cast<char>(c);
			continue;
		}

		uint32_t value;
		if (c >= 0xD800 && c < 0xE000) {
			value = 0xFFFD;
			if (c < 0xDC00 && pos + 1 < len) {
				uint16_t c2 = src[pos++];
				if (c2 >= 0xDC00 && c2 < 0xE000)
					value = 0x10000 + ((c & 0x3FF) << 10) + (c2 & 0x3FF);
			}
		} else {
			value = c;
		}

		size_t val_len;
	    for (val_len = 1; val_len < 5; val_len++) {
			if (value < (static_cast<uint32_t>(1) << (val_len * 5 + 6)))
				break;
		}
		dest += static_cast<char>(utf8_limits[val_len - 1] + (value >> (6 * val_len)));
		while (val_len) {
			val_len--;
			dest += static_cast<char>(0x80 + ((value >> (6 * val_len)) & 0x3F));
		}
	}

	return dest;
}

unicode_string StringToFileName(const char *name)
{
	unicode_string res = FromUTF8(name);
	for (size_t i = 0; i < res.size(); i++) {
		if (res[i] == L'/')
			res[i] = L'\\';
	}
	return res;
}

bool is_separator(char c)
{
    return c == '/'
#ifndef VMP_GNU
      || c == '\\'
#endif
      ;
}

static const char *GetFileName(const char *name)
{
	const char *res = name;
	while (*name) {
		if ((is_separator(name[0])
#ifndef VMP_GNU
			|| name[0] == ':'
#endif
			) && !is_separator(name[1]))
			res = name + 1;
		name++;
	}
	return res;
}

static const char *GetFileExt(const char *name)
{
	name = GetFileName(name);
	const char *res = NULL;
	while (*name) {
		if (*name == ' ')
			res = NULL;
		else if (*name == '.')
			res = name;
		name++;
	}
	return res ? res : name;
}

std::string ExtractFilePath(const char *name)
{
	if (!name)
		return std::string();
	return std::string(name, static_cast<size_t>(GetFileName(name) - name));
}

std::string ExtractFileName(const char *name)
{
	if (!name)
		return std::string();
	return std::string(GetFileName(name));
}

std::string ExtractFileExt(const char *name)
{
	if (!name)
		return std::string();
	return std::string(GetFileExt(name));
}

std::string ChangeFileExt(const char *name, const char *ext)
{
	if (!name)
		return std::string();
	std::string res = std::string(name, static_cast<size_t>(GetFileExt(name) - name));
	if (ext)
		res += ext;
	return res;
}

static bool IsRelative(const char *name)
{
	if (name && (is_separator(*name)
#ifndef VMP_GNU		
		|| (name[0] && name[1] == ':')
#endif
		))
		return false;
	return true;
}

std::string CombinePaths(const char *path, const char *file_name)
{
	if (!path || *path == 0 || !IsRelative(file_name))
		return std::string(file_name ? file_name : "");

	std::string res = path;
	if (!res.empty()) {
#ifdef VMP_GNU
		if (!is_separator(*(res.end() - 1)))
			res += '/';
#else
		if (!is_separator(res.back()))
			res += '\\';
#endif
	}

	return res + file_name;
}

std::string SubtractPath(const char *path, const char *file_name)
{
	if (!path || *path == 0 || !file_name || IsRelative(file_name))
		return std::string(file_name ? file_name : "");

	const char *name = file_name;
	while (*name) {
		char p = *path++;
		char f = *name++;
		if (p != f) {
			if (is_separator(f) && is_separator(p))
				continue;
			if (p == 0)
				return std::string(is_separator(f) ? name : name - 1);
			break;
		}
	}

	return std::string(file_name);
}

std::string GetCurrentPath()
{
#ifdef VMP_GNU
	char buff[PATH_MAX];
	if (!getcwd(buff, sizeof(buff)))
		buff[0] = 0;
	return std::string(buff);
#else
	wchar_t buff[MAX_PATH];
	DWORD size = GetCurrentDirectoryW(_countof(buff), buff);
	return ToUTF8(std::wstring(buff, size));
#endif
}

std::string GetExecutablePath()
{
	std::string res;
#ifdef __APPLE__
	CFURLRef url = CFBundleCopyExecutableURL(CFBundleGetMainBundle());
	if (url) {
		CFStringRef path = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);
		if (path) {
			char buffer[PATH_MAX];
			if (CFStringGetCString(path, buffer, sizeof(buffer), kCFStringEncodingUTF8))
				res = ExtractFilePath(buffer);
			CFRelease(path);
		}
		CFRelease(url);
	}
#elif defined(__unix__)
	char buff[PATH_MAX];
	ssize_t len = ::readlink("/proc/self/exe", buff, sizeof(buff)-1);
	if (len != -1) {
		buff[len] = '\0';
		res = ExtractFilePath(buff);
	}
#else
	wchar_t buff[MAX_PATH];
	DWORD size = GetModuleFileNameW(NULL, buff, _countof(buff));
	res = ExtractFilePath(ToUTF8(std::wstring(buff, size)).c_str());
#endif
	return res;
}

bool FileExists(const char *name)
{
	if (!name)
		return false;
#ifdef VMP_GNU
	struct stat s;
	int res = stat(name, &s);
	if (res == -1)
		return false;
	return true;
#else
	return GetFileAttributesW(FromUTF8(name).c_str()) != INVALID_FILE_ATTRIBUTES;
#endif
}

bool FileDelete(const char *name, bool toRecycleBin /*= false*/)
{
#ifdef VMP_GNU
	if(toRecycleBin)
	{
#ifdef __APPLE__
		if (0 == FSPathMoveObjectToTrashSync(name, NULL, kFSFileOperationDefaultOptions))
			return true;
#elif defined(__unix__)
		//using trash from apt-get install trash-cli
		system((std::string("trash \"") + name + "\"").c_str());
		if (!FileExists(name))
			return true;
#endif
	}
	return (remove(name) == 0);
#else
	unicode_string uname = FromUTF8(name);
	if(toRecycleBin)
	{
		SHFILEOPSTRUCTW operation = SHFILEOPSTRUCTW();
		operation.wFunc = FO_DELETE;
		wchar_t full_path[MAX_PATH + 1];
		DWORD lengNoTerm = GetFullPathNameW(uname.c_str(), MAX_PATH, full_path, NULL);
		if(lengNoTerm < MAX_PATH)
		{
			full_path[lengNoTerm + 1] = 0; //double terminated
			operation.pFrom = full_path;
			operation.fFlags = FOF_ALLOWUNDO | FOF_NO_UI;
			if(SHFileOperationW(&operation) == 0) 
				return true;
		}
	}
	return (DeleteFileW(uname.c_str()) != FALSE);
#endif
}

bool FileCopy(const char *src, const char *dest)
{
#ifdef __APPLE__
	return (copyfile(src, dest, NULL, COPYFILE_ALL) == 0);
#elif defined (__unix__)
	try
	{
		std::ifstream source(src, std::ios::binary);
		if (!source.is_open())
			return false;
		std::ofstream destination(dest, std::ios::binary);
		if (!destination.is_open())
			return false;
		destination << source.rdbuf();
		return true;
	} catch(std::ios_base::failure &)
	{
		FileDelete(dest);
		return false;
	}
#else
	return (CopyFileW(FromUTF8(src).c_str(), FromUTF8(dest).c_str(), false) != FALSE);
#endif
}

// fmCreate			Create a file with the given name. If a file with the given name exists, open the file in write mode.   
// fmOpenRead		Open the file for reading only.   
// fmOpenWrite		Open the file for writing only. Writing to the file completely replaces the current contents.   
// fmOpenReadWrite	Open the file to modify the current contents rather than replace them.   

HANDLE FileCreate(const char *name, uint32_t mode)
{
#ifdef VMP_GNU
	int flags;

	switch (FILE_OPEN_MODE(mode)) {
	case fmOpenRead:
		flags = O_RDONLY;
		break;
	case fmOpenWrite:
		flags = O_WRONLY | O_TRUNC;
		break;
	case fmOpenReadWrite:
		flags = O_RDWR;
		break;
	default:
		return INVALID_HANDLE_VALUE;
	}

	if (mode & fmCreate)
		flags |= (O_CREAT | O_TRUNC);

	return reinterpret_cast<HANDLE>(open(name, flags, (flags & O_CREAT) ? S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH : 0));
#else
	uint32_t desired_access, share_mode;

	switch (FILE_OPEN_MODE(mode)) {
	case fmOpenRead:
		desired_access = GENERIC_READ;
		break;
	case fmOpenWrite:
		desired_access = GENERIC_WRITE;
		break;
	case fmOpenReadWrite:
		desired_access = GENERIC_WRITE | GENERIC_READ;
		break;
	default:
		return INVALID_HANDLE_VALUE;
	}

	switch (FILE_SHARE_MODE(mode)) {
	case fmShareExclusive:
		share_mode = 0;
		break;
	case fmShareDenyWrite:
		share_mode = FILE_SHARE_READ;
		break;
	case fmShareDenyRead:
		share_mode = FILE_SHARE_WRITE;
		break;
	case fmShareDenyNone:
		share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE;
		break;
	default:
		return INVALID_HANDLE_VALUE;
	}

	return CreateFileW(FromUTF8(name).c_str(), desired_access, share_mode, NULL, (mode & fmCreate) ? CREATE_ALWAYS : OPEN_EXISTING, 0, NULL);
#endif
}

bool FileClose(HANDLE h)
{
#ifdef VMP_GNU
	return (close(h) == 0);
#else
	return (CloseHandle(h) != 0);
#endif
}

size_t FileRead(HANDLE h, void *buf, size_t size)
{
#ifdef VMP_GNU
	size_t res;
	res = read(h, buf, size);
#else
	size_t res = 0;
	DWORD portion;
	while(size > 0) {
		portion = (DWORD)-1;
		if (portion > size) 
			portion = (DWORD)size;
		if (ReadFile(h, (char *)buf + res, portion, &portion, NULL) == 0)
			return (size_t)-1;

		res += portion;
		size -= portion;
		if (portion == 0)
			break;
	}
#endif
	return res;
}

size_t FileWrite(HANDLE h, const void *buf, size_t size)
{
#ifdef VMP_GNU
	size_t res;
	res = write(h, buf, size);
#else
	size_t res = 0;
	DWORD portion;
	while(size > 0) {
		portion = (DWORD)-1;
		if (portion > size) 
			portion = (DWORD)size;
		if (WriteFile(h, (const char *)buf + res, portion, &portion, NULL) == 0)
			return (size_t)-1;

		res += portion;
		size -= portion;
		if (portion == 0)
			break;
	}
#endif
	return res;
}

uint64_t FileSeek(HANDLE h, uint64_t offset, SeekOrigin origin)
{
	uint64_t res;
#ifdef VMP_GNU
	int method;

	switch (origin) {
	case soBeginning:
		method = SEEK_SET;
		break;
	case soCurrent:
		method = SEEK_CUR;
		break;
	case soEnd:
		method = SEEK_END;
		break;
	default:
		return -1;
	}

	res = lseek(h, offset, method);
#else
	uint32_t method;

	switch (origin) {
	case soBeginning:
		method = FILE_BEGIN;
		break;
	case soCurrent:
		method = FILE_CURRENT;
		break;
	case soEnd:
		method = FILE_END;
		break;
	default:
		return -1;
	}

	uint32_t pos_low = static_cast<uint32_t>(offset);
	uint32_t pos_high = static_cast<uint32_t>(offset >> 32);
	pos_low = SetFilePointer(h, pos_low, (PLONG)&pos_high, method);
	if (pos_low == INVALID_SET_FILE_POINTER && GetLastError() != 0)
		return -1;
	res = (static_cast<uint64_t>(pos_high) << 32) | pos_low;
#endif
	return res;
}

bool FileSetEnd(HANDLE h)
{
#ifdef VMP_GNU
	uint64_t pos = lseek(h, 0, SEEK_CUR);
	if (pos == (uint64_t)-1)
		return false;
    return (ftruncate(h, pos) == 0);
#else
	return (SetEndOfFile(h) != 0);
#endif
}

bool FileGetCheckSum(const char *file_name, uint32_t *check_sum)
{
	if (!file_name)
		return false;

	bool res = false;
	HANDLE file_handle = FileCreate(file_name, fmOpenRead | fmShareDenyNone);
	if (file_handle != INVALID_HANDLE_VALUE) {
#ifdef VMP_GNU
		size_t file_size = lseek(file_handle, 0, SEEK_END);
#else
		uint32_t file_size = GetFileSize(file_handle, NULL);
		HANDLE file_map = CreateFileMappingW(file_handle, NULL, PAGE_READONLY, 0, 0, NULL);
		if (file_map) {
#endif

#ifdef VMP_GNU
			uint16_t *file_view = reinterpret_cast<uint16_t *>(mmap(0, file_size, PROT_READ, MAP_SHARED, file_handle, 0));
			if (file_view != MAP_FAILED) {
#else
			uint16_t *file_view = static_cast<uint16_t *>(MapViewOfFile(file_map, FILE_MAP_READ, 0, 0, 0));
			if (file_view) {
#endif
				bool is_valid_format = false;
				uint32_t header_sum = 0;
				IMAGE_DOS_HEADER *dos_header = reinterpret_cast<IMAGE_DOS_HEADER *>(file_view);
				if (dos_header->e_magic == IMAGE_DOS_SIGNATURE) {
					IMAGE_NT_HEADERS32 *header_32 = reinterpret_cast<IMAGE_NT_HEADERS32 *>(reinterpret_cast<uint8_t *>(file_view) + dos_header->e_lfanew);
					if (header_32->Signature == IMAGE_NT_SIGNATURE) {
						if (header_32->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
							header_sum = header_32->OptionalHeader.CheckSum;
							is_valid_format = true;
						} else if (header_32->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
							header_sum = reinterpret_cast<IMAGE_NT_HEADERS64 *>(header_32)->OptionalHeader.CheckSum;
							is_valid_format = true;
						}
					}
				}

				if (is_valid_format) {
					uint32_t sum = 0;
					size_t c = (file_size + 1) / sizeof(uint16_t);
					for (size_t i = 0; i < c; i++) {
						sum += file_view[i];
						if (HIWORD(sum))
							sum = LOWORD(sum) + HIWORD(sum);
					}
					sum = static_cast<uint16_t>(LOWORD(sum) + HIWORD(sum));

					if (LOWORD(sum) >= LOWORD(header_sum)) {
						sum -= LOWORD(header_sum);
					} else {
						sum = ((LOWORD(sum) - LOWORD(header_sum)) & 0xFFFF) - 1;
					}

					if (LOWORD(sum) >= HIWORD(header_sum)) {
						sum -= HIWORD(header_sum);
					} else {
						sum = ((LOWORD(sum) - HIWORD(header_sum)) & 0xFFFF) - 1;
					}
					sum += file_size;

					*check_sum = sum;
					res = true;
				}

#ifdef VMP_GNU
				munmap(file_view, file_size);
#else
				UnmapViewOfFile(file_view);
#endif
#ifndef VMP_GNU
			}
			CloseHandle(file_map);
#endif
		}
#ifdef VMP_GNU
		close(file_handle);
#else
		CloseHandle(file_handle);
#endif
	}

	return res;
}

#ifndef VMP_GNU
std::string ToOEM(const unicode_string &src)
{
	std::string res;
	if (!src.empty()) {
		int size = WideCharToMultiByte(CP_OEMCP, 0, src.c_str(), (int)src.size(), NULL, 0, NULL, NULL);
		if (size > 0) {
			res.resize(size);
			WideCharToMultiByte(CP_OEMCP, 0, src.c_str(), (int)src.size(), &res[0], (int)res.size(), NULL, NULL);
		}
	}
	return res;
}
unicode_string FromACP(const std::string &src)
{
	unicode_string res;
	if (!src.empty()) {
		int size = MultiByteToWideChar(CP_ACP, 0, src.c_str(), (int)src.size(), NULL, 0);
		if (size > 0) {
			res.resize(size);
			MultiByteToWideChar(CP_ACP, 0, src.c_str(), (int)src.size(), &res[0], (int)res.size());
		}
	}
	return res;
}
bool ValidateUTF8(const std::string &src)
{
	bool ret = true;
	if (!src.empty()) {
		int res = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, src.c_str(), -1, NULL, NULL);
		if (res == 0 && GetLastError() == ERROR_NO_UNICODE_TRANSLATION) {
			ret = false;
		}
	}
	return ret;
}
#endif

 void Print(const char *text)
 {
 #ifdef VMP_GNU
	std::cout << text << std::flush;
 #else
	std::cout << ToOEM(FromUTF8(text)) << std::flush;
 #endif
 }

std::vector<std::string> CommandLine()
{
	std::vector<std::string> res;
#ifdef __APPLE__
	int num = *_NSGetArgc();
	char **args = *_NSGetArgv();
	for (int i = 0; i < num; i++) {
		if (args[i])
			res.push_back(std::string(args[i]));
	}
#elif defined(__unix__)
	FILE *cmdline = fopen("/proc/self/cmdline", "rb");
	char *arg = 0;
	size_t size = 0;
	if (cmdline)
	{
		while (getdelim(&arg, &size, 0, cmdline) != -1)
		{
			res.push_back(std::string(arg));
		}
	}
	free(arg);
	fclose(cmdline);
#else
	int num;
	wchar_t **args = CommandLineToArgvW(GetCommandLineW(), &num);
	for (int i = 0; i < num; i++) {
		if (args[i])
			res.push_back(ToUTF8(std::wstring(args[i])));
	}
#endif
	return res;
}

#ifdef VMP_GNU
#define TOUPPER(x) toupper(x)
static bool WildcardMatch(const char *name, const char *mask)
#else
#define TOUPPER(x) towupper(x)
static bool WildcardMatch(const wchar_t *name, const wchar_t *mask)
#endif
{
	if (!name || !mask)
		return false;

	while (*name) {
		if (*mask == '*') {
			mask++;
			if (*mask == '\0')
				return true;
			while (*name) {
				if (WildcardMatch(name, mask))
					return true;
				name++;
			}
			return false;
		}
		if (*mask == '?' || TOUPPER(*name) == TOUPPER(*mask)) {
			name++;
			mask++;
		} else {
			return false;
		}
	}
	while (*mask == '*')
		mask++;
	return (*mask == '\0');
}

std::vector<std::string> FindFiles(const char *name, const char *mask, bool only_directories)
{
	std::vector<std::string> res;
	if (!name || !mask)
		return res;

#ifdef VMP_GNU
	DIR *dir;
	struct dirent *ent;
	dir = opendir(name);
	if (dir) {
		while ((ent = readdir(dir))) {
			if (WildcardMatch(ent->d_name, mask))
				res.push_back(CombinePaths(name, ent->d_name));
		}
		closedir(dir);
	}
#else
	std::wstring unicode_mask = FromUTF8(mask);
	WIN32_FIND_DATAW find_data;
	HANDLE h = FindFirstFileW(FromUTF8(std::string(name) + "\\*").c_str(), &find_data);
	if (h != INVALID_HANDLE_VALUE) {
		do {
			if (wcscmp(find_data.cFileName, L".") == 0 || wcscmp(find_data.cFileName, L"..") == 0)
				continue;
			if (only_directories && ((find_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0))
				continue;
			if (!WildcardMatch(find_data.cFileName, unicode_mask.c_str()))
				continue;

			res.push_back(CombinePaths(name, ToUTF8(find_data.cFileName).c_str()));
		} while (FindNextFileW(h, &find_data) != 0);
		FindClose(h);
	}
#endif
	return res;
}

uint32_t GetTickCount()
{
#ifdef __APPLE__
	const int64_t one_million = 1000 * 1000;
	mach_timebase_info_data_t timebase_info;
	mach_timebase_info(&timebase_info);

	// mach_absolute_time() returns billionth of seconds,
	// so divide by one million to get milliseconds
	return static_cast<uint32_t>((mach_absolute_time() * timebase_info.numer) / (one_million * timebase_info.denom));
#elif defined (__unix__)
	struct timeval tv;
	gettimeofday(&tv, NULL);
	return tv.tv_sec * 1000 + tv.tv_usec / 1000;
#else
	return ::GetTickCount();
#endif
}

#ifdef VMP_GNU
static char* rstrip(char* s)
{
	char* p = s + strlen(s);
	while (p > s && isspace((unsigned char)(*--p)))
		*p = '\0';
	return s;
}

static char* lskip(const char* s)
{
	while (*s && isspace((unsigned char)(*s)))
		s++;
	return (char*)s;
}

static char* find_char_or_comment(const char* s, char c)
{
	int was_whitespace = 0;
	while (*s && *s != c && !(was_whitespace && *s == ';')) {
		was_whitespace = isspace((unsigned char)(*s));
		s++;
	}
	return (char*)s;
}

static void SwapBuffer(unicode_char *buf, size_t size)
{
	for (size_t i = 0; i < size; i++) {
		unicode_char c = buf[i];
		buf[i] = (c >> 8) | (c << 8);
	}
}

bool ProfileString(const char *_section, const char *_key, const char *_value, char const *file_name, std::string *result)
{
	static const uint8_t utf16_le_bom[] = {0xFF, 0xFE};
	static const uint8_t utf16_be_bom[] = {0xFE, 0xFF};
	static const uint8_t utf8_bom[] = {0xEF, 0xBB, 0xBF};

	enum Encoding {
		enNone,
		enUTF16_le,
		enUTF16_be,
		enUTF8
	};

	char *start;
	char *end;
	char *section;
	char *name;
	char *value;
	Encoding encoding = enNone;
	std::stringstream stream;

	HANDLE file = FileCreate(file_name, fmOpenRead | fmShareDenyNone);
	if (file == INVALID_HANDLE_VALUE) {
		if (result)
			return false;
	} else	{
		char bom[3] = {0};
		FileRead(file, bom, sizeof(utf16_le_bom));
		if (memcmp(bom, utf16_le_bom, sizeof(utf16_le_bom)) == 0) {
			encoding = enUTF16_le;
		} else if (memcmp(bom, utf16_be_bom, sizeof(utf16_be_bom)) == 0) {
			encoding = enUTF16_be;
		} else {
			FileRead(file, &bom[2], 1);
			if (memcmp(bom, utf8_bom, sizeof(utf8_bom)) == 0)
				encoding = enUTF8;
		}
		uint64_t begin_pos = (encoding == enNone) ? 0 : FileSeek(file, 0, soCurrent);
		uint64_t end_pos = FileSeek(file, 0, soEnd);
		size_t size = static_cast<size_t>(end_pos - begin_pos);
		if (size) {
			FileSeek(file, begin_pos, soBeginning);
			uint8_t *buff = new uint8_t[size];
			FileRead(file, buff, size);
			FileClose(file);
			if (encoding == enUTF16_be)
				SwapBuffer(reinterpret_cast<unicode_char *>(buff), size / sizeof(unicode_char));
			stream.str((encoding == enUTF16_le || encoding == enUTF16_be) ? ToUTF8(unicode_string(reinterpret_cast<unicode_char *>(buff), size / sizeof(unicode_char))) : std::string(reinterpret_cast<char *>(buff), size));
			delete [] buff;
		}
		FileClose(file);
	}

	bool section_found = false;
	bool value_saved = false;
	std::string line;
	std::vector<std::string> lines;
	while (std::getline(stream, line)) {
		if (!line.empty() && *(line.end() - 1) == '\r')
			line.erase(line.size() - 1);

		if (!result)
			lines.push_back(line);

		start = &line[0];
		start = lskip(rstrip(start));

		if (*start == ';' || *start == '#') {
			/* Per Python ConfigParser, allow '#' comments at start of line */
        } else if (*start == '[') {
			/* A "[section]" line */
			end = find_char_or_comment(start + 1, ']');
			if (*end == ']') {
				*end = '\0';
				if (section_found) {
					if (_key) {
						if (result) {
							return false;
						} else if (!value_saved) {
							std::vector<std::string>::iterator it = lines.end() - 1;
							if (_value)
								lines.insert(it, std::string(_key) + std::string("=") + std::string(_value));
							else
								lines.erase(it);
							value_saved = true;
						}
					} else {
						if (result)
							return true;
					}
				}

				section = start + 1;
				section_found = (_strcmpi(section, _section) == 0);
			}
		} else if (*start && *start != ';') {
			/* Not a comment, must be a name[=:]value pair */
			end = find_char_or_comment(start, '=');
			if (*end != '=') {
				end = find_char_or_comment(start, ':');
			}
			if (*end == '=' || *end == ':') {
				*end = '\0';
				name = rstrip(start);
				value = lskip(end + 1);
				end = find_char_or_comment(value, '\0');
				if (*end == ';')
					*end = '\0';
				rstrip(value);

				if (section_found) {
					if (_key) {
						if (_strcmpi(name, _key) == 0) {
							if (result) {
								*result = value;
								return true;
							} else if (!value_saved) {
								std::vector<std::string>::iterator it = lines.end() - 1;
								if (_value)
									*it = std::string(name) + "=" + std::string(_value);
								else
									lines.erase(it);
								value_saved = true;
							}
						}
					} else {
						if (result) {
							*result += name;
							*result += '\0';
						}
					}
				}
			}
		}
	}

	if (result) {
		return false;
	} else {
		file = FileCreate(file_name, fmCreate | fmOpenWrite | fmShareDenyNone);
		if (file == INVALID_HANDLE_VALUE)
			return false;

		switch (encoding) {
		case enUTF8:
			FileWrite(file, utf8_bom, sizeof(utf8_bom));
			break;
		case enUTF16_le:
			FileWrite(file, utf16_le_bom, sizeof(utf16_le_bom));
			break;
		case enUTF16_be:
			FileWrite(file, utf16_be_bom, sizeof(utf16_be_bom));
			break;
		}

		if (!value_saved) {
			if (!section_found)
				lines.push_back(std::string("[") + std::string(_section) + std::string("]"));
			lines.push_back(std::string(_key) + std::string("=") + std::string(_value));
		}

		for (size_t i = 0; i < lines.size(); i++) {
			std::string str = lines[i] + "\r\n";
			if (encoding == enUTF16_le || encoding == enUTF16_be) {
				unicode_string wstr = FromUTF8(str);
				if (encoding == enUTF16_be)
					SwapBuffer(const_cast<unicode_char *>(wstr.c_str()), wstr.size());
				FileWrite(file, wstr.c_str(), wstr.size() * sizeof(unicode_char));
			} else {
				FileWrite(file, str.c_str(), str.size());
			}
		}
		FileClose(file);
		return true;
	}
}
#endif

bool WriteIniString(const char *section, const char *key, const char *value, const char *file_name)
{
#ifdef VMP_GNU
	return ProfileString(section, key, value, file_name, NULL);
#else
	return WritePrivateProfileStringW(section ? FromUTF8(section).c_str() : NULL, 
										key ? os::FromUTF8(key).c_str() : NULL,
										value ? os::FromUTF8(value).c_str() : NULL, 
										file_name ? os::FromUTF8(file_name).c_str() : NULL
										) != FALSE;
#endif
}

std::string ReadIniString(const char *section, const char *key, const char *default_value, const char *file_name)
{
	std::string res;
#ifdef VMP_GNU
	if (!ProfileString(section, key, default_value, file_name, &res)) {
		if (default_value)
			res = std::string(default_value);
	}
#else
	size_t buffer_size = 1024;
	os::unicode_char *buffer = NULL;
	for (;;) {
		delete [] buffer;
		buffer = new os::unicode_char[buffer_size];
		uint32_t len = GetPrivateProfileStringW(section ? FromUTF8(section).c_str() : NULL,
											key ? FromUTF8(key).c_str() : NULL, 
											default_value ? FromUTF8(default_value).c_str() : NULL, 
											buffer, (DWORD)buffer_size, 
											file_name ? FromUTF8(file_name).c_str() : NULL);
		if (len < buffer_size - sizeof(os::unicode_char)) {
			res = os::ToUTF8(os::unicode_string(buffer, len));
			break;
		}
		buffer_size *= 4;
	}
	delete [] buffer;
#endif
	return res;
}

HPROCESS ProcessOpen(uint32_t id)
{
#ifdef __APPLE__
	mach_port_t task;
	if (task_for_pid(mach_task_self(), id, &task) != KERN_SUCCESS)
		return 0;
	return task;
#elif defined(__unix__)
	return HPROCESS(id); 
#else
	return OpenProcess(PROCESS_ALL_ACCESS, FALSE, id);
#endif
}

bool ProcessClose(HPROCESS h)
{
#ifdef VMP_GNU
	// do nothing
	return true;
#else
	return (CloseHandle(h) != 0);
#endif
}

size_t ProcessRead(HPROCESS h, void *base_address, void *buf, size_t size)
{
#ifdef __APPLE__
	mach_vm_size_t res;
	if (mach_vm_read_overwrite(h, (mach_vm_address_t)base_address, size, (mach_vm_address_t)buf, &res) != KERN_SUCCESS)
		return -1;
	return res;
#elif defined(__unix__)
	struct iovec local, remote;
	local.iov_base = buf;
	local.iov_len = (int)size;
	remote.iov_base = base_address;
	local.iov_len = (int)size;
	ssize_t nread = process_vm_readv(reinterpret_cast<pid_t>(h), &local, 1, &remote, 1, 0);
	return (size_t)nread;
#else
	SIZE_T res;
	if (ReadProcessMemory(h, base_address, buf, size, &res) == 0)
		return -1;
	return res;
#endif
}

size_t ProcessWrite(HPROCESS h, void *base_address, const void *buf, size_t size)
{
#ifdef __APPLE__
	if (mach_vm_write(h, (mach_vm_address_t)base_address, size, (mach_vm_address_t)buf) != KERN_SUCCESS)
		return -1;
	return size;
#elif defined(__unix__)
	struct iovec local, remote;
	local.iov_base = const_cast<void *>(buf);
	local.iov_len = (int)size;
	remote.iov_base = base_address;
	local.iov_len = (int)size;
	ssize_t nwrite = process_vm_writev(reinterpret_cast<pid_t>(h), &local, 1, &remote, 1, 0);
	return (size_t)nwrite;
#else
	SIZE_T res;
	if (WriteProcessMemory(h, base_address, buf, size, &res) == 0)
		return -1;
	return res;
#endif
}

uint64_t GetLastWriteTime(const char *name)
{
	uint64_t res = 0;
	HANDLE h = FileCreate(name, fmOpenRead | fmShareDenyNone);
	if (h != INVALID_HANDLE_VALUE) {
#ifdef VMP_GNU
		struct stat stat_buf;
		if (fstat(h, &stat_buf) == 0)
			res = stat_buf.st_mtime;
#else
		FILETIME file_time;
		if (GetFileTime(h, NULL, NULL , &file_time))
			res = (static_cast<uint64_t>(file_time.dwHighDateTime) << 32 | file_time.dwLowDateTime) / 10000000 - 11644473600;
#endif
		FileClose(h);
	}
	return res;
}

std::vector<PROCESS_ITEM> EnumProcesses()
{
	std::vector<PROCESS_ITEM> res;
#ifdef __APPLE__
	int err;
	static const int name[] = {CTL_KERN, KERN_PROC, KERN_PROC_ALL, 0};
	size_t length;

	bool done = false;
	kinfo_proc *processes = NULL;
	do {
		length = 0;
		err = sysctl(const_cast<int *>(name), (sizeof(name) / sizeof(*name)) - 1, NULL, &length, NULL, 0);
		if (err == -1)
			err = errno;

		if (err == 0) {
			processes = new kinfo_proc[length];
			if (processes == NULL)
				err = ENOMEM;
		}

		if (err == 0) {
			err = sysctl(const_cast<int *>(name), (sizeof(name) / sizeof(*name)) - 1, processes, &length, NULL, 0);
			if (err == -1)
				err = errno;
			if (err == 0) {
				done = true;
			} else if (err == ENOMEM) {
				delete [] processes;
				processes = NULL;
				err = 0;
			}
		}
	} while (err == 0 && !done);

	mach_port_t task;
	if (err == 0 && processes) {
		for (size_t i = 0; i < length / sizeof(kinfo_proc); i++) {
			kinfo_proc *process = &processes[i];

			if (task_for_pid(mach_task_self(), process->kp_proc.p_pid, &task) != KERN_SUCCESS)
				continue;

			PROCESS_ITEM item;
			item.id = process->kp_proc.p_pid;
			item.name = process->kp_proc.p_comm;
			res.push_back(item);
		}
	}
	delete [] processes;
#elif defined(__unix__)
	struct dirent* dent;
	DIR* srcdir = opendir("/proc");
	if (srcdir != NULL)
	{
		while((dent = readdir(srcdir)) != NULL)
		{
			struct stat st;

			if(strcmp(dent->d_name, ".") == 0 || strcmp(dent->d_name, "..") == 0)
				continue;

			if (fstatat(dirfd(srcdir), dent->d_name, &st, 0) >= 0 && S_ISDIR(st.st_mode))
			{
				PROCESS_ITEM item;
				item.id = atoi(dent->d_name);
				if (item.id == 0)
					continue;
				char path[4096];
				snprintf(path, sizeof(path), "/proc/%d/maps", item.id);
				FILE *fmaps = fopen(path, "r");
				if (fmaps)
				{
					char c;
					size_t read = fread(&c, 1, 1, fmaps);
					fclose(fmaps);
					if (read == 1)
					{
						snprintf(path, sizeof(path), "/proc/%d/comm", item.id);
						std::ifstream f(path);
						std::stringstream buffer;
						buffer << f.rdbuf();
						item.name = buffer.str();
						size_t endpos = item.name.find_last_not_of("\r\n");
						if( std::string::npos != endpos )
							item.name = item.name.substr( 0, endpos+1 );
						res.push_back(item);
					}
				}
			}
		}
	}
	closedir(srcdir);
#else
	DWORD processes[1024], needed;
	if (::EnumProcesses(processes, sizeof(processes), &needed)) {
		size_t count = needed / sizeof(DWORD);
		for (size_t i = 0; i < count; i++) {
			if (!processes[i])
				continue;

			wchar_t process_name[MAX_PATH] = {0};
			HANDLE process = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processes[i]);
			if (process) {
				if (GetModuleFileNameExW(process, 0, process_name, _countof(process_name))) {
					PROCESS_ITEM item;
					item.id = processes[i];
					item.name = ExtractFileName(ToUTF8(process_name).c_str());
					res.push_back(item);
				}
				CloseHandle(process);
			}
		}
	}
#endif
	return res;
}

#ifdef __unix__
/*
address           perms offset  dev   inode       pathname
00400000-00452000 r-xp 00000000 08:02 173521      /usr/bin/dbus-daemon
00651000-00652000 r--p 00051000 08:02 173521      /usr/bin/dbus-daemon
00652000-00655000 rw-p 00052000 08:02 173521      /usr/bin/dbus-daemon
00e03000-00e24000 rw-p 00000000 00:00 0           [heap]
00e24000-011f7000 rw-p 00000000 00:00 0           [heap]
...
35b1800000-35b1820000 r-xp 00000000 08:02 135522  /usr/lib64/ld-2.15.so
35b1a1f000-35b1a20000 r--p 0001f000 08:02 135522  /usr/lib64/ld-2.15.so
35b1a20000-35b1a21000 rw-p 00020000 08:02 135522  /usr/lib64/ld-2.15.so
35b1a21000-35b1a22000 rw-p 00000000 00:00 0
35b1c00000-35b1dac000 r-xp 00000000 08:02 135870  /usr/lib64/libc-2.15.so
35b1dac000-35b1fac000 ---p 001ac000 08:02 135870  /usr/lib64/libc-2.15.so
35b1fac000-35b1fb0000 r--p 001ac000 08:02 135870  /usr/lib64/libc-2.15.so
35b1fb0000-35b1fb2000 rw-p 001b0000 08:02 135870  /usr/lib64/libc-2.15.so
...
f2c6ff8c000-7f2c7078c000 rw-p 00000000 00:00 0    [stack:986]
...
7fffb2c0d000-7fffb2c2e000 rw-p 00000000 00:00 0   [stack]
7fffb2d48000-7fffb2d49000 r-xp 00000000 00:00 0   [vdso]
*/
static bool ParseMapsLine(const char *maps, int *inode, char *name, size_t cch_name, uint64_t *from, uint64_t *to, uint64_t *offset)
{
	bool res = false;
	*inode = 0;
	*name = 0;
	*from = *to = *offset = 0;
	if (	strlen(maps) < cch_name &&
			sscanf_s(maps, "%llx-%llx%*[ \trwxp-]%llx%*[ \t]%*d:%*d%*[ \t]%d%*[ \t]%s", from, to, offset, inode, name) == 5 &&
			*inode != 0)
	{
		res = true;
	}
	return res;
}
#endif

std::vector<MODULE_ITEM> EnumModules(uint32_t process_id)
{
	std::vector<MODULE_ITEM> res;
#ifdef __APPLE__
	mach_port_t task;
	if (task_for_pid(mach_task_self(), process_id, &task) == KERN_SUCCESS) {
		struct task_dyld_info dyld_info;
		mach_msg_type_number_t count = TASK_DYLD_INFO_COUNT;
		if (task_info(task, TASK_DYLD_INFO, (task_info_t)&dyld_info, &count) == KERN_SUCCESS) {
			if (dyld_info.all_image_info_addr != 0 && dyld_info.all_image_info_size != 0) {
				dyld_all_image_infos image_infos;
				if (ProcessRead(task, (void *)dyld_info.all_image_info_addr, &image_infos, sizeof(image_infos)) != (size_t)-1 && image_infos.infoArrayCount) {
					dyld_image_info *info_array = new dyld_image_info[image_infos.infoArrayCount];
					if (ProcessRead(task, (void *)image_infos.infoArray, info_array, sizeof(dyld_image_info) * image_infos.infoArrayCount) != (size_t)-1) {
						for (size_t i = 0; i < image_infos.infoArrayCount; i++) {
							dyld_image_info *info = &info_array[i];

							std::string name;
							char c;
							while (ProcessRead(task, (void *)(info->imageFilePath + name.size()), &c, sizeof(c)) != (size_t)-1) {
								if (!c)
									break;
								name += c;
							}

							MODULE_ITEM item;
							item.handle = (HMODULE)info->imageLoadAddress;
							item.name = name;
							res.push_back(item);
						}
					}
					delete [] info_array;
				}
			}
		}
	}
#elif defined(__unix__)
	char maps[2048], name[2048];
	snprintf(maps, sizeof(maps), "/proc/%d/maps", process_id);
	FILE *fmaps = fopen(maps, "r");
	if (fmaps)
	{
		while (fgets(maps, sizeof(maps), fmaps))
		{
			MODULE_ITEM item;
			int inode;
			uint64_t from, to, offset;
			if(ParseMapsLine(maps, &inode, name, sizeof(name), &from, &to, &offset))
			{
				item.handle = reinterpret_cast<HMODULE>(from);
				item.name = name;
				res.push_back(item);
			}
		}
		fclose(fmaps);
	}
#else
	HANDLE process = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, process_id);
	if (process) {
        HMODULE mods[1024];
        DWORD needed;

		if (EnumProcessModules(process, mods, sizeof(mods), &needed)) { //-V
			size_t count = needed / sizeof(HMODULE);
			for (size_t i = 0; i < count; i++) {
				wchar_t module_name[MAX_PATH] = {0};
	            if (GetModuleFileNameExW(process, mods[i], module_name, _countof(module_name))) {
					MODULE_ITEM item;
					item.handle = mods[i];
					item.name = ToUTF8(module_name);
					res.push_back(item);
				}
            }
        }
		CloseHandle(process);
    }
#endif
	return res;
}

bool GetModuleInformation(HANDLE process, HMODULE module, MODULE_INFO *info, size_t size)
{
	if (size < sizeof(MODULE_INFO))
		return false;

#ifdef __APPLE__
	uint8_t *address = static_cast<uint8_t *>(module);
	mach_header header;
	if (ProcessRead(process, address, &header, sizeof(header)) == (size_t)-1)
		return false;

	if (header.magic == MH_MAGIC) {
		info->address = address;
		address += sizeof(mach_header);
		uint32_t min_address = 0;
		uint32_t max_address = 0;
		for (size_t i = 0; i < header.ncmds; i++) {
			load_command command;
			if (ProcessRead(process, address, &command, sizeof(command)) == (size_t)-1)
				return false;

			if (command.cmd == LC_SEGMENT) {
				segment_command segment;
				if (ProcessRead(process, address, &segment, sizeof(segment)) == (size_t)-1)
					return false;

				if (segment.vmaddr) {
					if (!min_address)
						min_address = segment.vmaddr;
					if (max_address < segment.vmaddr + segment.vmsize)
						max_address = segment.vmaddr + segment.vmsize;
				}
			}
			address += command.cmdsize;
		}
		info->size = max_address - min_address;
	} else if (header.magic == MH_MAGIC_64) {
		info->address = address;
		address += sizeof(mach_header_64);
		uint64_t min_address = 0;
		uint64_t max_address = 0;
		for (size_t i = 0; i < header.ncmds; i++) {
			load_command command;
			if (ProcessRead(process, address, &command, sizeof(command)) == (size_t)-1)
				return false;

			if (command.cmd == LC_SEGMENT_64) {
				segment_command_64 segment;
				if (ProcessRead(process, address, &segment, sizeof(segment)) == (size_t)-1)
					return false;
				if (segment.vmaddr) {
					if (!min_address)
						min_address = segment.vmaddr;
					if (max_address < segment.vmaddr + segment.vmsize)
						max_address = segment.vmaddr + segment.vmsize;
				}
			}
			address += command.cmdsize;
		}
		info->size = static_cast<size_t>(max_address - min_address);
	} else {
		return false;
	}

	return true;
#elif defined(__unix__)
	bool ret = false;
	char maps[1024], name[2048];
	snprintf(maps, sizeof(maps), "/proc/%d/maps", (int)process);
	FILE *fmaps = fopen(maps, "r");
	if (fmaps)
	{
		while (fgets(maps, sizeof(maps), fmaps))
		{
			int inode;
			uint64_t from, to, offset;
			if(ParseMapsLine(maps, &inode, name, sizeof(name), &from, &to, &offset) && 
				reinterpret_cast<HMODULE>(from) == module)
			{
				info->address = (void *)from;
				info->size = to - from;
				ret = true;
			}
		}
		fclose(fmaps);
	}
	return ret;
#else
	MODULEINFO moduleInfo;
	if (!::GetModuleInformation(process, module, &moduleInfo, sizeof(moduleInfo)))
		return false;

	info->address = moduleInfo.lpBaseOfDll;
	info->size = moduleInfo.SizeOfImage;
	return true;
#endif
}

std::string GetSysAppDataDirectory()
{
	std::string res;
#ifdef __APPLE__
	FSRef ref;
	if (FSFindFolder(kOnAppropriateDisk, kSharedUserDataFolderType, kDontCreateFolder, &ref) == 0) {
		CFURLRef url_ref = CFURLCreateFromFSRef(NULL, &ref);
		if (url_ref) {
			char buffer[PATH_MAX];
			if (CFURLGetFileSystemRepresentation(url_ref, true, (uint8_t*)buffer, sizeof(buffer)))
				res = std::string(buffer);
			CFRelease(url_ref);
		}
	}
#elif defined(__unix__)
	const char *homedir;

	if ((homedir = getenv("HOME")) == NULL) {
		homedir = getpwuid(getuid())->pw_dir;
	}
	res = std::string(homedir) + "/.config"; //admin should use hard links to map this stuff to /usr/share etc
#else
	os::unicode_char buffer[MAX_PATH];

	if (SHGetFolderPathW(NULL, CSIDL_COMMON_APPDATA,  NULL, 0, buffer) >= 0)
		res = os::ToUTF8(buffer);
#endif
	return res;
}

bool DirectoryCreate(const char *name)
{
	if (!name)
		return false;

#ifdef VMP_GNU
	return (mkdir(name, S_IRWXU | S_IRWXG | S_IRWXO) == 0);
#else
	return (CreateDirectoryW(FromUTF8(name).c_str(), NULL) != 0 || GetLastError() == ERROR_ALREADY_EXISTS);
#endif
}

bool PathCreate(const char *name)
{
	if (!name)
		return false;

	bool res = DirectoryCreate(name);
	if (!res) {
		const char *prev = GetFileName(name);
		if (prev != name && PathCreate(std::string(name, prev - name - 1).c_str()))
			res = DirectoryCreate(name);
	}
	return res;
}

#ifndef VMP_GNU
struct LocaleInfo {
	LCID id;
	char iso_name[6];
};

static const LocaleInfo win_locale_info[] = {
	{0x0436, "af"},
	{0x3801, "ar_AE"},
	{0x3c01, "ar_BH"},
	{0x1401, "ar_DZ"},
	{0x0c01, "ar_EG"},
	{0x0801, "ar_IQ"},
	{0x2c01, "ar_JO"},
	{0x3401, "ar_KW"},
	{0x3001, "ar_LB"},
	{0x1001, "ar_LY"},
	{0x1801, "ar_MA"},
	{0x2001, "ar_OM"},
	{0x4001, "ar_QA"},
	{0x0401, "ar_SA"},
	{0x2801, "ar_SY"},
	{0x1c01, "ar_TN"},
	{0x2401, "ar_YE"},
	{0x0423, "be"},
	{0x0402, "bg"},
	{0x0403, "ca"},
	{0x0405, "cs"},
	{0x0406, "da"},
	{0x0407, "de"},
	{0x0c07, "de_AT"},
	{0x0807, "de_CH"},
	{0x1407, "de_LI"},
	{0x1007, "de_LU"},
	{0x0408, "el"},
	{0x0409, "en"},
	{0x0c09, "en_AU"},
	{0x2809, "en_BZ"},
	{0x1009, "en_CA"},
	{0x0809, "en_GB"},
	{0x1809, "en_IE"},
	{0x2009, "en_JM"},
	{0x1409, "en_NZ"},
	{0x2c09, "en_TT"},
	{0x0409, "en_US"},
	{0x1c09, "en_ZA"},
	{0x040a, "es"},
	{0x2c0a, "es_AR"},
	{0x400a, "es_BO"},
	{0x340a, "es_CL"},
	{0x240a, "es_CO"},
	{0x140a, "es_CR"},
	{0x1c0a, "es_DO"},
	{0x300a, "es_EC"},
	{0x100a, "es_GT"},
	{0x480a, "es_HN"},
	{0x080a, "es_MX"},
	{0x4c0a, "es_NI"},
	{0x180a, "es_PA"},
	{0x280a, "es_PE"},
	{0x500a, "es_PR"},
	{0x3c0a, "es_PY"},
	{0x440a, "es_SV"},
	{0x380a, "es_UY"},
	{0x200a, "es_VE"},
	{0x0425, "et"},
	{0x042d, "eu"},
	{0x0429, "fa"},
	{0x040b, "fi"},
	{0x0438, "fo"},
	{0x040c, "fr"},
	{0x080c, "fr_BE"},
	{0x0c0c, "fr_CA"},
	{0x100c, "fr_CH"},
	{0x140c, "fr_LU"},
	{0x040d, "he"},
	{0x0439, "hi"},
	{0x041a, "hr"},
	{0x040e, "hu"},
	{0x0421, "in"},
	{0x040f, "is"},
	{0x0410, "it"},
	{0x0810, "it_CH"},
	{0x0411, "ja"},
	{0x0812, "ko"},
	{0x0412, "ko"},
	{0x0427, "lt"},
	{0x0426, "lv"},
	{0x042f, "mk"},
	{0x043e, "ms"},
	{0x0458, "mt"},
	{0x0413, "nl"},
	{0x0813, "nl_BE"},
	{0x0814, "no"},
	{0x0414, "no"},
	{0x0415, "pl"},
	{0x0816, "pt"},
	{0x0416, "pt_BR"},
	{0x0418, "ro"},
	{0x0419, "ru"},
	{0x041c, "sq"},
	{0x081a, "sr"},
	{0x0c1a, "sr"},
	{0x041d, "sv"},
	{0x081d, "sv_FI"},
	{0x041e, "th"},
	{0x041f, "tr"},
	{0x0422, "uk"},
	{0x0420, "ur"},
	{0x042a, "vi"},
	{0x0804, "zh"},
	{0x0804, "zh_CN"},
	{0x0c04, "zh_HK"},
	{0x1004, "zh_SG"},
	{0x0404, "zh_TW"}
};
#endif

#ifdef __unix__
struct LocaleInfo {
	char iso_name[3];
	char int_name[32];
};

static const LocaleInfo lin_locale_info[] = {
	{"af", "Afrikaans"},
	{"ar", "Arabic"},
	{"be", "Belarusian"},
	{"bg", "Bulgarian"},
	{"ca", "Catalan"},
	{"cs", "Czech"},
	{"da", "Danish"},
	{"de", "German"},
	{"el", "Greek"},
	{"en", "English"},
	{"es", "Spanish"},
	{"et", "Estonian"},
	{"eu", "Basque"},
	{"fa", "Farsi"},
	{"fi", "Finnish"},
	{"fo", "Faroese"},
	{"fr", "French"},
	{"he", "Hebrew"},
	{"hi", "Hindi"},
	{"hr", "Croatian"},
	{"hu", "Hungarian"},
	{"is", "Icelandic"},
	{"it", "Italian"},
	{"ja", "Japanese"},
	{"ko", "Korean"},
	{"lt", "Lithuanian"},
	{"lv", "Latvian"},
	{"mk", "Macedonian"},
	{"ms", "Malay"},
	{"mt", "Maltese"},
	{"nl", "Dutch"},
	{"pl", "Polish"},
	{"pt", "Portuguese"},
	{"ro", "Romanian"},
	{"ru", "Russian"},
	{"sq", "Albanian"},
	{"sr", "Serbian"},
	{"sv", "Swedish"},
	{"th", "Thai"},
	{"tr", "Turkish"},
	{"uk", "Ukrainian"},
	{"ur", "Urdu"},
	{"vi", "Vietnamese"},
	{"zh", "Chinese"},
};
#endif

std::string GetLocaleName(const char *code)
{
	if (!code)
		return std::string();

	std::string res;
#ifdef __APPLE__
	CFStringRef id = CFStringCreateWithCString(NULL, code, kCFStringEncodingUTF8);
	CFLocaleRef loc = CFLocaleCreate(NULL, id);
	if (loc) {
		CFStringRef name = CFLocaleCopyDisplayNameForPropertyValue(loc, kCFLocaleLanguageCode, id);
		if (name) {
			CFMutableStringRef mutable_name = CFStringCreateMutableCopy(NULL, 0, name);
			CFStringCapitalize(mutable_name, loc);
			char buffer[1024];
			if (CFStringGetCString(mutable_name, buffer, sizeof(buffer), kCFStringEncodingUTF8))
				res = buffer;
			CFRelease(mutable_name);
			CFRelease(name);
		}
		CFRelease(loc);
	}
	CFRelease(id);
#elif defined(__unix__)
	int begin = 0;
	int end = _countof(lin_locale_info);
	while (end - begin > 1) {
		int mid = (begin + end)/2;

		const LocaleInfo *info = lin_locale_info + mid;
		int cmp = strcmp(code, info->iso_name);
		if (cmp < 0)
			end = mid;
		else if (cmp > 0)
			begin = mid;
		else {
			res = info->int_name;
			break;
		}
	}
#else
	LCID id = 0;

	int begin = 0;
	int end = _countof(win_locale_info);
	while (end - begin > 1) {
		int mid = (begin + end)/2;

		const LocaleInfo *info = win_locale_info + mid;
		int cmp = strcmp(code, info->iso_name);
		if (cmp < 0)
			end = mid;
		else if (cmp > 0)
			begin = mid;
		else {
			id = info->id;
			break;
		}
	}

	if (id) {
		os::unicode_char buffer[1024];
		if (GetLocaleInfoW(id, LOCALE_SNATIVELANGNAME, buffer, sizeof(buffer))) {
			LCMapStringW(id, LCMAP_UPPERCASE, buffer, 1, buffer, 1);
			res = os::ToUTF8(os::unicode_string(buffer));
		}
	}
#endif
	if (res.empty())
		res = code;
	return res;
}

std::string GetCurrentLocale()
{
	std::string res;
#ifdef __APPLE__
	CFLocaleRef loc = CFLocaleCopyCurrent();
	if (loc) {
		CFStringRef name = CFLocaleGetIdentifier(loc);
		if (name) {
			char buffer[1024];
			if (CFStringGetCString(name, buffer, sizeof(buffer), kCFStringEncodingUTF8))
				res = buffer;
		}
		CFRelease(loc);
	}
#elif defined(__unix__)
	const char *lang = ::getenv("LANG");
	if (lang && *lang)
	{
		while (char sym = *lang++)
		{
			if (sym == '.' || sym == '_')
				break;
			res += sym;
		}
	} else
	{
		res = "en";
	}
#else
	LCID id = GetUserDefaultLCID();
	for (size_t i = 0; i < _countof(win_locale_info); i++) {
		if (win_locale_info[i].id == id) {
			res = win_locale_info[i].iso_name;
			break;
		}
	}
#endif
	return res;
}

void GetLocalTime(SYSTEM_TIME *res)
{
#ifdef VMP_GNU
	time_t rawtime;
	time(&rawtime);
	struct tm local_tm;
	tm *timeinfo = localtime_r(&rawtime, &local_tm);
	res->year = static_cast<uint16_t>(timeinfo->tm_year + 1900);
	res->month = static_cast<uint8_t>(timeinfo->tm_mon);
	res->day = static_cast<uint8_t>(timeinfo->tm_mday);
#else
	SYSTEMTIME local_time;
	::GetLocalTime(&local_time);
	res->year = local_time.wYear;
	res->month = static_cast<uint8_t>(local_time.wMonth);
	res->day = static_cast<uint8_t>(local_time.wDay);
#endif
}

#ifndef VMP_GNU
#include <fcntl.h>

static const wchar_t letters[] =
L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

/* Generate a temporary file name based on TMPL.  TMPL must match the
   rules for mk[s]temp (i.e. end in "XXXXXX").  The name constructed
   does not exist at the time of the call to mkstemp.  TMPL is
   overwritten with the result.  */
int
mkstemp (wchar_t *tmpl)
{
	size_t len;
	wchar_t *XXXXXX;
	static unsigned long long value;
	unsigned long long random_time_bits;
	unsigned int count;
	int fd = -1;
	int save_errno = errno;

	/* A lower bound on the number of temporary files to attempt to
		generate.  The maximum total number of temporary file names that
		can exist for a given template is 62**6.  It should never be
		necessary to try all these combinations.  Instead if a reasonable
		number of names is tried (we define reasonable as 62**3) fail to
		give the system administrator the chance to remove the problems.  */
#define ATTEMPTS_MIN (62 * 62 * 62)

	/* The number of times to attempt to generate a temporary file.  To
		conform to POSIX, this must be no smaller than TMP_MAX.  */
#if ATTEMPTS_MIN < TMP_MAX
	unsigned int attempts = TMP_MAX;
#else
	unsigned int attempts = ATTEMPTS_MIN;
#endif

	len = wcsnlen_s (tmpl, MAX_PATH);
	if (len < 6 || wcsncmp (&tmpl[len - 6], L"XXXXXX", MAX_PATH))
	{
		errno = EINVAL;
		return -1;
	}

	/* This is where the Xs start.  */
	XXXXXX = &tmpl[len - 6];

	/* Get some more or less random data.  */
	{
		SYSTEMTIME      stNow;
		FILETIME ftNow;

		// get system time
		GetSystemTime(&stNow);
		stNow.wMilliseconds = 500;
		if (!SystemTimeToFileTime(&stNow, &ftNow))
		{
			errno = -1;
			return -1;
		}

		random_time_bits = (((unsigned long long)ftNow.dwHighDateTime << 32)
			| (unsigned long long)ftNow.dwLowDateTime);
	}
	value += random_time_bits ^ (unsigned long long)GetCurrentThreadId ();

	for (count = 0; count < attempts; value += 7777, ++count)
	{
		unsigned long long v = value;

		/* Fill in the random bits.  */
		XXXXXX[0] = letters[v % 62];
		v /= 62;
		XXXXXX[1] = letters[v % 62];
		v /= 62;
		XXXXXX[2] = letters[v % 62];
		v /= 62;
		XXXXXX[3] = letters[v % 62];
		v /= 62;
		XXXXXX[4] = letters[v % 62];
		v /= 62;
		XXXXXX[5] = letters[v % 62];

		if (0 == _wsopen_s(&fd, tmpl, O_RDWR | O_CREAT | O_EXCL, _SH_DENYRW, _S_IREAD | _S_IWRITE) && fd >= 0)
		{
			errno = save_errno;
			return fd;
		} else if (errno != EEXIST)
		{
			return -1;
		}
	}

	/* We got out of the loop because we ran out of combinations to try.  */
	errno = EEXIST;
	return -1;
}
#endif

std::string GetTempFilePathName(const char *pathname_template /*=NULL*/)
{
	std::string ret;
#ifdef VMP_GNU
	char szTempFileName[PATH_MAX] = "/tmp/vmpXXXXXX";
	if(pathname_template)
		strcpy_s(szTempFileName, pathname_template);
	int fd = mkstemp(szTempFileName);
	if(fd >= 0)
	{
		fchmod(fd, S_IRUSR | S_IWUSR | S_IXUSR);
		ret = szTempFileName;
		close(fd);
	}
#else
	if(pathname_template)
	{
		os::unicode_string tempFileName = os::FromUTF8(pathname_template);
		int fd = mkstemp(const_cast<wchar_t *>(tempFileName.data()));
		if(fd >= 0)
		{
			ret = os::ToUTF8(tempFileName);
			_close(fd);
		}
	} else
	{
		wchar_t lpTempPathBuffer[MAX_PATH], szTempFileName[MAX_PATH];
		DWORD dwRetVal = GetTempPathW(MAX_PATH, lpTempPathBuffer);
		if (dwRetVal <= MAX_PATH && (dwRetVal != 0))
		{
			UINT uRetVal = GetTempFileNameW(lpTempPathBuffer, L"vmp", 0, szTempFileName);
			if (uRetVal > 0)
			{
				ret  = os::ToUTF8(std::wstring(szTempFileName));
			}
		}
	}
#endif
	return ret;
}
std::string GetTempFilePathNameFor(const char *pathname)
{
	std::string ret = os::GetTempFilePathName((std::string(pathname) + ".XXXXXX").c_str());
	if(ret.empty())
	{
		return os::GetTempFilePathName();
	}
	return ret;
}

bool FileMove(const char *oldName, const char *newName)
{
#ifdef VMP_GNU
	return rename(oldName, newName) == 0;
#else
	return MoveFileExW(os::FromUTF8(oldName).c_str(), os::FromUTF8(newName).c_str(), 
		MOVEFILE_COPY_ALLOWED | // used only when different volumes
		MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH) == TRUE;
#endif
}

#ifdef __APPLE__
std::string GetMainExeFileName(const char *file_name)
{
	std::string res;
	CFStringRef cfPath = CFStringCreateWithCString(NULL, file_name, kCFStringEncodingUTF8);
	if (cfPath) {
		CFURLRef bundleURL = CFURLCreateWithFileSystemPath(NULL, cfPath, kCFURLPOSIXPathStyle, true);
		if (bundleURL) {
			CFBundleRef aBundle = CFBundleCreate(NULL, bundleURL);
			if (aBundle) {
				CFURLRef mainExecUrl = CFBundleCopyExecutableURL(aBundle);
				if(mainExecUrl) {
					CFURLRef mainExecAbsUrl = CFURLCopyAbsoluteURL(mainExecUrl);
					if(mainExecAbsUrl) {
						CFStringRef mainExec = CFURLCopyFileSystemPath(mainExecAbsUrl, kCFURLPOSIXPathStyle);
						if (mainExec) {
							char buffer[PATH_MAX];
							if (CFStringGetCString(mainExec, buffer, sizeof(buffer), kCFStringEncodingUTF8))
								res = buffer;
							CFRelease(mainExec);
						}
						CFRelease(mainExecAbsUrl);
					}
					CFRelease(mainExecUrl);
				}
				CFRelease(aBundle);
			}
			CFRelease(bundleURL);
		}
		CFRelease(cfPath);
	}
	return res;
}
#endif

std::string CombineThisAppDataDirectory(const char *lastPathPart)
{
	return os::CombinePaths(os::CombinePaths(os::GetSysAppDataDirectory().c_str(), "VMProtect Software/VMProtect").c_str(), lastPathPart);
}

HMODULE LibraryOpen(const std::string &name)
{
#ifdef VMP_GNU
	return dlopen(name.c_str(), RTLD_NOW);
#else
	return LoadLibraryW(FromUTF8(name).c_str());
#endif
}

bool LibraryClose(HMODULE h)
{
#ifdef VMP_GNU
	return (dlclose(h) == 0);
#else
	return (FreeLibrary(h) != 0);
#endif
}

void *GetFunction(HMODULE h, const std::string &name)
{
#ifdef VMP_GNU
	return dlsym(h, name.c_str());
#else
	return GetProcAddress(h, name.c_str());
#endif
}

std::string ExpandEnvironmentVariables(const char *path)
{
#ifdef VMP_GNU
	std::string res;
	for (const char *p = path; *p; ) {
		const char *first = strchr(p, '%');
		if (first) {
			const char *next = strchr(first + 1, '%');
			if (next) {
				const char *var_value = getenv(std::string(first + 1, next - first - 1).c_str());
				if (var_value) {
					res.append(p, first - p);
					res.append(var_value);
				} else {
					res.append(p, next + 1 - p);
				}
				p = next + 1;
				continue;
			}
		}

		res.append(p);
		break;
	}
	return res;
#else
	unicode_string src = FromUTF8(path);
	unicode_string res;
	for (const unicode_char *p = src.c_str(); *p; ) {
		const unicode_char *first = wcschr(p, '%');
		if (first) {
			const unicode_char *next = wcschr(first + 1, '%');
			if (next) {
				size_t var_size;
				unicode_string var = unicode_string(first + 1, next - first - 1);
				_wgetenv_s(&var_size, NULL, 0, var.c_str()); //-V530
				if (var_size) {
					res.append(p, first - p);
					unicode_char *var_value = new unicode_char[var_size];
					_wgetenv_s(&var_size, var_value, var_size, var.c_str()); //-V530
					res.append(var_value);
					delete [] var_value;
				} else {
					res.append(p, next + 1 - p);
				}
				p = next + 1;
				continue;
			}
		}

		res.append(p);
		break;
	}
	return ToUTF8(res);
#endif
}

std::string GetEnvironmentVariable(const char *name)
{
#ifdef VMP_GNU
	if (const char *p = getenv(name))
		return std::string(p);
	return std::string();
#else
	unicode_string var = FromUTF8(name);
	unicode_string res;
	size_t var_size;
	_wgetenv_s(&var_size, NULL, 0, var.c_str());
	if (var_size) {
		unicode_char *var_value = new unicode_char[var_size];
		_wgetenv_s(&var_size, var_value, var_size, var.c_str()); //-V530
		res = var_value;
		delete[] var_value;
	}
	return ToUTF8(res);
#endif
}

void SetEnvironmentVariable(const char *name, const char *value)
{
#ifdef VMP_GNU
	setenv(name, value, 1);
#else
	_wputenv_s(FromUTF8(name).c_str(), FromUTF8(value).c_str());
#endif
}

}