#pragma once

#include "lang/app_language.h"
#include "base_pak.h"

#if defined(_WIN32) || defined(_WIN64)
#define PATH_SEPERATOR		"\\"
#define THIS_MODULE_NAME	"lang.dll"
#else
#include <string.h>			// for strcasecmp
#define PATH_SEPERATOR		"/"
#define THIS_MODULE_NAME	"lang.so"
#endif

#include <string>
#include <vector>
#include <map>
#include <algorithm>
#include <locale.h>
#include <thread>

namespace util
{
	const uint32_t crc_table[256] = {
  0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
  0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
  0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
  0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
  0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
  0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
  0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
  0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
  0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
  0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
  0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
  0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
  0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
  0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
  0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
  0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
  0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
  0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
  0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
  0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
  0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
  0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
  0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
  0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
  0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
  0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
  0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
  0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
  0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
  0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
  0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
  0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
  0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
  0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
  0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
  0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
  0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
  0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
  0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
  0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
  0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
  0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
  0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
  0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
  0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
  0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
  0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
  0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
  0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
  0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
  0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
  0x2d02ef8dL
	};

#define CRC32(c, b) (crc_table[((int)(c) ^ (b)) & 0xff] ^ ((c) >> 8))
#define DO1(buf)  crc = CRC32(crc, *buf++)
#define DO2(buf)  DO1(buf); DO1(buf)
#define DO4(buf)  DO2(buf); DO2(buf)
#define DO8(buf)  DO4(buf); DO4(buf)

	uint32_t crc32(uint32_t crc, const uint8_t* buf, uint32_t len)
	{
		if (buf == NULL) return 0L;
		crc = crc ^ 0xffffffffL;
		while (len >= 8) { DO8(buf); len -= 8; }
		if (len) do { DO1(buf); } while (--len);

		return crc ^ 0xffffffffL;  // (instead of ~c for 64-bit machines)
	}

};

// *.pak ...
//typedef struct _lang_pak
//{
//  uint32_t	len;
//	uint32_t	crc;		// crc check ...
//	uint32_t	ver;		
//	uint32_t* cps[];		// supported code-pages table offset, until '-1'
//	struct
//	{
//		uint32_t	name_id;
//		char		name[0];
//	}*name[];				// my name on my code-page
//	ENDING address align 16 before
// 
//	struct
//	{
//		uint32_t	id;
//		uint32_t	offset;	// offset to the first structure
//	}str_map[];				// Offset of corresponding ID string, until id == -1
//};
struct _cp_locale
{
	int	cp;
	const char* locale;
}g_known_locale[] =
	{ {DEFAULT_CODE_PAGE, "zh_CN"}
	, {950, "zh_HK"}
	, {950, "zh_TW"}
	, {950, "zh_SG"}
	, {20127, "en_"}
	, {932, "ja_JP"}
	, {863, "fr_"}
	, {1144, "it_CH"}
	, {1141, "de_"}
	, {855, "ru_RU"}
};

class lang_mgr
{
	typedef struct _map_str
	{
		uint32_t			name_id;		// global unique
		std::vector<int>	code_pages;
		std::string			name;
		std::string			file;

		bool operator==(int cp)
		{
			return std::find(code_pages.begin(), code_pages.end(), cp) != code_pages.end();
		}
	}MAPSTR;
	typedef struct _chg_notify
	{
		void(*notify)(int code_page, void* param);
		void* param;
		bool operator==(void(*ntfy)(int code_page, void* param))
		{
			return notify == ntfy;
		}
	}CHGNOTIFY;
	std::vector<CHGNOTIFY>	notify_;

	volatile bool		in_changing_;
	std::vector<MAPSTR>	code_pages_;
	LANATTR** all_;
	uint32_t	os_cp_;
	uint32_t	cur_cp_;
	std::string	cur_lang_;
	std::map<uint32_t, std::string>	map_off_;

	static lang_mgr* inst_;
	MAPSTR							cp_default_;
	std::map<uint32_t, std::string>	map_default_;
	std::map<uint32_t, std::string>* pak_now_;


	void clear(void)
	{
		map_off_.clear();
		cur_lang_.clear();
		cur_cp_ = -1;
	}
	uint32_t calculate_crc32(uint8_t* data, uint32_t len, uint32_t prev = 0)
	{
		return util::crc32(prev, data, len);
	}
	uint32_t get_cur_code_page_id(void)
	{
		return os_cp_;
	}
	bool parse_pak_digest(uint8_t* data, MAPSTR& ms, int* id)
	{
		uint32_t	ver = *(uint32_t*)data,
			val = 0,
			* cps = (uint32_t*)(data + sizeof(uint32_t) * 3);

		if (id)
			*id = *cps;
		while (*cps != -1)
		{
			ms.code_pages.push_back(*cps++);
		}
		if (ms.code_pages.empty())
			return false;

		cps++;
		ms.name_id = *cps++;
		val = (uint8_t*)cps - data;
		ms.name = (char*)data + val;

		return ms.name.length() ? true : false;
	}
	bool parse_pak(uint8_t* data, uint32_t* bgn, uint32_t* id, std::map<uint32_t, std::string>& off)
	{
		uint32_t	ver = *(uint32_t*)data,
			val = 0,
			* cps = (uint32_t*)(data + sizeof(uint32_t) * 3);

		if (id)
			*id = cps[0];
		while (*cps++ != -1);
		cps++;
		val = (uint8_t*)cps - data;
		val += strlen((char*)data + val) + 1;
		val += 15;
		val /= 16;
		val *= 16;
		if (bgn)
			*bgn = val;

		struct
		{
			uint32_t id;
			uint32_t off;
		}*go = nullptr;
		*((void**)&go) = (void*)(data + val);
		while (go->id != -1)
		{
			off[go->id] = (char*)data + go->off + val;
			go++;
		}

		return true;
	}
	bool load_language_pak(const char* file, bool at_init)
	{
		std::string	cont(""), name("");
		uint32_t	bgn = 0, id = 0, cur_id = -1;
		bool		ret = false;
		FILE* src = fopen(file, "rb");
		std::map<uint32_t, std::string>	off;

		if (src)
		{
			int	len = 0;
			uint8_t* buf = nullptr;

			fseek(src, 0, SEEK_END);
			len = ftell(src);
			fseek(src, 0, SEEK_SET);
			if (len)
			{
				buf = new uint8_t[len + 4];
				if (buf)
				{
					memset(buf, 0, len + 4);
					len = fread(buf, 1, len, src);
					if (len == *(uint32_t*)buf
						&& calculate_crc32(buf + sizeof(uint32_t) * 2, len - sizeof(uint32_t) * 2) == ((uint32_t*)buf)[1])
					{
						cont = std::string((char*)buf, len);
					}
					delete[] buf;
				}
			}
			fclose(src);
		}
		if (cont.length())
		{
			if (at_init)
			{
				MAPSTR	ms;

				ms.file = file;
				cur_id = get_cur_code_page_id();
				if (parse_pak_digest((uint8_t*)&cont[0], ms, (int*)&id))
				{
					if (id == DEFAULT_CODE_PAGE)
						cp_default_ = ms;
					else
						code_pages_.push_back(std::move(ms));
					if (cur_id == id && map_off_.size() == 0)
					{
						ret = parse_pak((uint8_t*)&cont[0], &bgn, &id, off);
						if (ret)
							name = ms.name;
					}
				}
			}
			else
				ret = parse_pak((uint8_t*)&cont[0], &bgn, &id, off);
		}

		if (ret && ((at_init && cur_id == id) || !at_init))
		{
			clear();
			cur_cp_ = id;
			cur_lang_ = std::move(name);
			if (cur_cp_ == DEFAULT_CODE_PAGE)
			{
				map_default_ = std::move(off);
				pak_now_ = &map_default_;
			}
			else
			{
				map_off_ = std::move(off);
				pak_now_ = &map_off_;
			}
		}

		return ret;
	}
	void notify_changed(void)
	{
		for (auto& v : notify_)
			v.notify(cur_cp_, v.param);
	}

#if defined(_WIN32) || defined(_WIN64)
	static std::string u2a(const wchar_t* u, UINT cp = CP_ACP)
	{
		std::string a("");

		if (u)
		{
			char	stack[256] = { 0 }, * ansi = NULL;
			int		len = 0;

			len = WideCharToMultiByte(cp, 0, u, lstrlenW(u), NULL, 0, NULL, NULL);
			ansi = new char[len + 2];
			len = WideCharToMultiByte(cp, 0, u, lstrlenW(u), ansi, len, NULL, NULL);
			ansi[len--] = 0;
			a = ansi;
			delete[] ansi;
		}

		return a;
	}
	static std::wstring a2u(const char* a, UINT cp = CP_ACP)
	{
		std::wstring u(L"");

		if (a)
		{
			wchar_t* unic = NULL;
			int		len = 0;

			len = MultiByteToWideChar(cp, 0, a, lstrlenA(a), NULL, 0);
			unic = new wchar_t[len + 2];
			len = MultiByteToWideChar(cp, 0, a, lstrlenA(a), unic, len + 1);
			unic[len--] = 0;
			u = unic;
			delete[] unic;
		}

		return u;
	}
#else
	static std::string link_file(const char* lnk)
	{
		char path[512] = { 0 };
		int	 len = readlink(lnk, path, sizeof(path) - 1);

		return path;
	}
	static bool found_module(const char* file, void* param)
	{
		std::string* str = (std::string*)param;
		const char* n = strrchr(file, PATH_SEPERATOR[0]);

		if (n++ == nullptr)
			n = file;
		if (strcasecmp(str->c_str(), n) == 0)
		{
			*str = file;

			return false;
		}
		else
			return true;
	}
#endif

	int enum_files(const char* dir, bool(*on_found)(const char*, void*), void* param, bool recursive = true)
	{
		int ret = 0;

#if defined(_WIN32) || defined(_WIN64)
		std::wstring		root(a2u(dir, CP_UTF8) + L"\\");
		WIN32_FIND_DATAW	fd = { 0 };
		HANDLE h = FindFirstFileW((a2u(dir, CP_UTF8) + L"\\*.pak").c_str(), &fd);
		if (h == INVALID_HANDLE_VALUE)
			return GetLastError();
		do
		{
			if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
			{
				if (recursive && wcscmp(fd.cFileName, L".") && wcscmp(fd.cFileName, L".."))
				{
					ret = enum_files(u2a((root + fd.cFileName).c_str(), CP_UTF8).c_str(), on_found, param, recursive);
					if (ret == ERROR_CANCELLED)
						break;
				}
			}
			else if (!on_found(u2a((root + fd.cFileName).c_str(), CP_UTF8).c_str(), param))
			{
				ret = ERROR_CANCELLED;
				break;
			}
		} while (FindNextFileW(h, &fd));
		FindClose(h);
#else
		DIR* pdir = nullptr;
		struct dirent* ent = nullptr;

		pdir = opendir(dir);
		if (!pdir)
			return errno;

		while ((ent = readdir(pdir)))
		{
			if (ent->d_type & DT_DIR)
			{
				if (recursive)
				{
					if (strcmp(ent->d_name, ".") && strcmp(ent->d_name, ".."))
					{
						std::string	sub(dir);
						sub += "/";
						sub += ent->d_name;
						ret = enum_files(sub.c_str(), found_file, param, recursive);
						if (ret == 0x5e17)
							break;
					}
				}
			}
			else
			{
				char* ext = strrchr(ent->d_name, '.');
				if (ext && strcasecmp(ext, ".pak") == 0)
				{
					std::string file(dir);

					file += "/";
					file += ent->d_name;
					if (!found_file(link_file(file.c_str()).c_str(), param))
					{
						ret = 0x5e17;
						break;
	}
				}
			}
		}
#endif

		return ret;
	}
	static bool found_language_pak(const char* file, void* obj)
	{
		((lang_mgr*)obj)->load_language_pak(file, true);

		return true;
	}
	std::string get_module_path(void)
	{
#if defined(_WIN32) || defined(_WIN64)
		wchar_t	path[MAX_PATH] = { 0 };

		GetModuleFileNameW(GetModuleHandleA(THIS_MODULE_NAME), path, _countof(path) - 1);

		return u2a(path, CP_UTF8);
#else
		char	path[256] = { 0 };
		std::string	ret(THIS_MODULE_NAME);

		sprintf(path, "/proc/%u/map_files", getpid());
		enum_files(path, &lang_mgr::found_module, &ret);

		return ret;
#endif
	}

	lang_mgr() : os_cp_(lang_mgr::get_os_code_page()), cur_cp_(-1), cur_lang_(""), all_(nullptr), in_changing_(true), pak_now_(&map_off_)
	{
		std::string	path(get_module_path());
		size_t		pos = path.rfind(PATH_SEPERATOR[0]);
		char		*str = nullptr;
		LANATTR		*st = nullptr;
		int			ind = 0;

		if (pos++ == std::string::npos)
			pos = 0;
		path.erase(pos);
		path += "lang";
		parse_pak_digest(g_chinese, cp_default_, nullptr);
		parse_pak(g_chinese, nullptr, nullptr, map_default_);
		enum_files(path.c_str(), &lang_mgr::found_language_pak, this, false);

		size_t len = sizeof(LANATTR*) * (code_pages_.size() + 1) + sizeof(LANATTR) * code_pages_.size();

		pos = len;
		for (const auto& v: code_pages_)
		{
			len += v.name.length() + 4;
		}

		all_ = (LANATTR**)new char[len];
		memset(all_, 0, len);
		str = (char*)all_ + pos;
		st = (LANATTR*)((char*)all_ + sizeof(LANATTR*) * (code_pages_.size() + 1));
		for (const auto& v : code_pages_)
		{
			all_[ind++] = st;
			st->cp = v.code_pages[0];
			st->name = str;
			st->id = v.name_id;
			strcpy(str, v.name.c_str());
			str += v.name.length() + 2;
			st++;
		}

		if (map_off_.empty())
		{
			// system language pak not found, reset to DEFAULT_CODE_PAGE or first ...
			cur_cp_ = DEFAULT_CODE_PAGE;
			pak_now_ = &map_default_;
		}

		in_changing_ = false;
	}
	~lang_mgr()
	{
		delete[](char*)all_;
	}

public:
	static int get_os_code_page(void)
	{
		char* locale = setlocale(LC_ALL, "");
		int	cp = DEFAULT_CODE_PAGE;

		if (locale)
		{
			char* end = nullptr;
			bool found = false;

			if (strstr(locale, "LC_CTYPE="))
				locale = strstr(locale, "LC_CTYPE=") + strlen("LC_CTYPE");
			end = strstr(locale, ";");
			if (end)
				*end = 0;
			for (int i = 0; i < sizeof(g_known_locale) / sizeof(g_known_locale[0]); ++i)
			{
				if (strstr(locale, g_known_locale[i].locale))
				{
					cp = g_known_locale[i].cp;
					found = true;
					break;
				}
			}
			if (!found && strrchr(locale, '.'))
			{
				// windows: Chinese (Simplified)_China.DEFAULT_CODE_PAGE
				locale = strrchr(locale, '.') + 1;
				if (*locale >= '0' && *locale <= '9')
					cp = atoi(locale);
			}
			if(end)
				*end = ';';
		}

		return cp;
	}

public:
	static lang_mgr* instance(void)
	{
		if (!lang_mgr::inst_)
			lang_mgr::inst_ = new lang_mgr();

		return lang_mgr::inst_;
	}
	int get_cur_cp(void)
	{
		return cur_cp_;
	}
	std::string get_cur_name(void)
	{
		return cur_lang_;
	}
	LANATTR** get_all(void)
	{
		return all_;
	}
	int set_code_page(int cp)
	{
		if (cp == 0)
			cp = lang_mgr::get_os_code_page();
		if (cp == cur_cp_)
			return 0;

		bool changed = true;
		if (cp == DEFAULT_CODE_PAGE)
		{
			pak_now_ = &map_default_;
			cur_cp_ = cp;
			cur_lang_ = cp_default_.name;
		}
		else
		{
			std::vector<MAPSTR>::iterator it = std::find(code_pages_.begin(), code_pages_.end(), cp);
			if (it == code_pages_.end())
				return ENOENT;

			std::string f(it->file);

			in_changing_ = true;
			std::this_thread::sleep_for(std::chrono::milliseconds(50));

			cp = cur_cp_;
			load_language_pak(f.c_str(), false);
			in_changing_ = false;
			changed = cp != cur_cp_;
		}

		if (changed)
			notify_changed();

		return 0;
	}
	const char* get_string(uint32_t id, int* err, bool def)
	{
		int cnt = 0;
		while (in_changing_)
		{
			std::this_thread::sleep_for(std::chrono::milliseconds(10));
			if (cnt++ > 100)
				return "";
		}

		std::map<uint32_t, std::string>* pak = def ? &map_default_ : pak_now_;
		if ((*pak)[id].size())
		{
			if (err)
				*err = 0;

			return (*pak)[id].c_str();
		}
		else
		{
			if (err)
				*err = ENOENT;

			return "";
		}
	}
	int supported_cps(void)
	{
		return code_pages_.size() + 1;
	}
	void register_language_changed_notify(void(*lan_changed)(int code_page, void* param), bool reg, void* param = nullptr)
	{
		std::vector<CHGNOTIFY>::iterator it = std::find(notify_.begin(), notify_.end(), lan_changed);

		if (it == notify_.end())
		{
			if (reg)
			{
				CHGNOTIFY	c;
				c.notify = lan_changed;
				c.param = param;
				notify_.push_back(c);
			}
		}
		else
		{
			if (reg)
				it->param = param;
			else
				notify_.erase(it);
		}
	}
	int get_string_id(const char* str, bool def)
	{
		std::map<uint32_t, std::string>* lang = def ? &map_default_ : pak_now_;

		while (*str == ' ')
			str++;

		for (auto& v : *lang)
		{
			if (v.second == str)
				return v.first;
		}

		return -1;
	}
	const char* transform_language(const char* in, bool to_def, bool* found)
	{
		if (cur_cp_ == DEFAULT_CODE_PAGE)
		{
			if (found)
				*found = true;

			return in;
		}

		int id = get_string_id(in, false);
		std::map<uint32_t, std::string>* t = to_def ? &map_default_ : pak_now_;

		if (id == -1)
		{
			if (found)
				*found = false;

			return in;
		}

		if (t->count(id))
		{
			if (found)
				*found = true;

			return (*t)[id].c_str();
		}
		else
		{
			if (found)
				*found = false;

			return in;
		}
	}
};
lang_mgr* lang_mgr::inst_ = nullptr;

extern "C"
{
	int lang_initialize(void* param)
	{
		if (lang_mgr::instance()->supported_cps() > 0)
			return lang_mgr::instance()->get_cur_cp();
		else
			return -1;
	}
	LANATTR** lang_get_supported_languages(void)
	{
		return lang_mgr::instance()->get_all();
	}
	int lang_get_cur_code_page(void)
	{
		return lang_mgr::instance()->get_cur_cp();
	}
	int lang_set_code_page(int cp)
	{
		return lang_mgr::instance()->set_code_page(cp);
	}
	const char* lang_load_string(uint32_t id, int* err, bool def)
	{
		return lang_mgr::instance()->get_string(id, err, def);
	}
	void register_language_changed_notify(void(*lan_changed)(int code_page, void* param), bool reg, void* param)
	{
		lang_mgr::instance()->register_language_changed_notify(lan_changed, reg, param);
	}

	int lang_get_string_id(const char* str, bool def_lang)
	{
		return lang_mgr::instance()->get_string_id(str, def_lang);
	}

	const char* to_default_language(const char* str, bool* ok)
	{
		return lang_mgr::instance()->transform_language(str, true, ok);
	}
	const char* from_default_language(const char* str, bool* ok)
	{
		return lang_mgr::instance()->transform_language(str, false, ok);
	}
}