#include "U_String.h"
	#include <algorithm>
	#include <cctype>
	#include <iostream>
	#include <cwctype>
	std::wstring StringUtils::StrToWstr(const std::string& str)
	{
	/*std::vector<wchar_t> buf(str.size());
	std::use_facet<std::ctype<wchar_t>>(std::locale{}).widen(str.data(), str.data() + str.size(), buf.data());
	return std::wstring(buf.data(), buf.size());*/
	return boost::locale::conv::utf_to_utf<wchar_t>(str);
	}
	std::string StringUtils::WstrToStr(const std::wstring& wstr)
	{
	/*std::vector<char> buf(wstr.size());
	std::use_facet<std::ctype<wchar_t>>(std::locale{}).narrow(wstr.data(), wstr.data() + wstr.size(), '?', buf.data());
	return std::string(buf.data(), buf.size());*/
	return boost::locale::conv::utf_to_utf<char>(wstr);
	}
	std::u16string StringUtils::Utf8ToU16(const std::string& str)
	{
	return boost::locale::conv::utf_to_utf<char16_t>(str);
	}
	std::string StringUtils::U16ToUtf8(const std::u16string& str)
	{
	return boost::locale::conv::utf_to_utf<char>(str);
	}
	std::u16string StringUtils::WstrToU16(const std::wstring& wstr)
	{
	return boost::locale::conv::utf_to_utf<char16_t>(wstr);
	}
	std::wstring StringUtils::U16ToWstr(const std::u16string& str)
	{
	return boost::locale::conv::utf_to_utf<wchar_t>(str);
	}
	bool StringUtils::StartsWith(const std::string& str, const std::string& startswith)
	{
	return StringUtils::SafeSubstring(str, startswith.size()) == startswith;
	}
	bool StringUtils::StartsWith(const std::wstring& str, const std::wstring& startswith)
	{
	return StringUtils::SafeSubstring(str, startswith.size()) == startswith;
	}
	void StringUtils::split_str(const std::string& s, char delim, std::vector<std::string>& ua)
	{
	std::stringstream ss;
	ss.str(s);
	std::string item;
	while (true)
	{
	if (!ss)
	{
	return;
	}
	if (ss.eof())
	{
	break;
	}
	std::getline(ss, item, delim);
	ua.push_back(item);
	}
	}
	void StringUtils::split_str(const std::wstring& s, wchar_t delim, std::vector<std::wstring>& ua)
	{
	std::wstringstream ss;
	ss.str(s);
	std::wstring item;
	while (true)
	{
	if (!ss)
	{
	return;
	}
	if (ss.eof())
	{
	break;
	}
	std::getline(ss, item, delim);
	ua.push_back(item);
	}
	}
	std::vector<std::string> StringUtils::split_str(const std::string& s, char delim)
	{
	std::vector<std::string> ret;
	split_str(s, delim, ret);
	return ret;
	}
	std::vector<std::wstring> StringUtils::split_str(const std::wstring& s, wchar_t delim)
	{
	std::vector<std::wstring> ret;
	split_str(s, delim, ret);
	return ret;
	}
	void StringUtils::remove_consecutive_commas(std::string& str)
	{
	std::regex comma_pattern(",{2,}");
	str = std::regex_replace(str, comma_pattern, ",");
	}
	void StringUtils::remove_consecutive_commas(std::wstring& str)
	{
	std::wregex comma_pattern(L",{2,}");
	str = std::regex_replace(str, comma_pattern, L",");
	}
	void CommandPreprocess::Trim(std::wstring& str)
	{
	str.erase(str.begin(), std::find_if(str.begin(), str.end(), [](wchar_t c) { return !std::iswspace(c); }));
	str.erase(std::find_if(str.rbegin(), str.rend(), [](wchar_t c) { return !std::iswspace(c); }).base(), str.end());
	}
	void CommandPreprocess::PreprocessEscapes(std::wstring& str)
	{
	std::wstring result;
	for (size_t i = 0; i < str.size(); ++i)
	{
	if (str[i] == L'\\' && i + 1 < str.size())
	{
	if (str[i + 1] == L';')
	{
	result += L'\x1F';
	++i;
	}
	else
	{
	result += str[i];
	result += str[i + 1];
	++i;
	}
	}
	else
	{
	result += str[i];
	}
	}
	str = result;
	}
	void CommandPreprocess::ReplaceEscapes(std::wstring& str)
	{
	std::wstring result;
	for (size_t i = 0; i < str.size(); ++i)
	{
	if (str[i] == L'\x1F')
	{
	result += L';';
	}
	else if (str[i] == L'\\' && i + 1 < str.size())
	{
	switch (str[i + 1])
	{
	case L'\\': result += L'\\'; ++i; break;
	case L'n': result += L'\n'; ++i; break;
	case L'r': result += L'\r'; ++i; break;
	case L'\"': result += L'\"'; ++i; break;
	default: result += str[i]; break;
	}
	}
	else
	{
	result += str[i];
	}
	}
	str = result;
	}
	std::vector<std::wstring> CommandPreprocess::SplitCommands(const std::wstring& input)
	{
	std::vector<std::wstring> commands;
	std::wstring current;
	bool inString = false;
	for (size_t i = 0; i < input.size(); ++i)
	{
	if (input[i] == L'\"' && (i == 0 || input[i - 1] != L'\\'))
	{
	inString = !inString;
	}
	else if (input[i] == L';' && !inString)
	{
	Trim(current);
	if (!current.empty())
	{
	commands.push_back(current);
	current.clear();
	}
	continue;
	}
	current += input[i];
	}
	Trim(current);
	if (!current.empty())
	{
	commands.push_back(current);
	}
	return commands;
	}
	std::vector<std::wstring> CommandPreprocess::ParseArguments(const std::wstring& command)
	{
	std::vector<std::wstring> arguments;
	std::wstring current;
	bool inString = false;
	for (size_t i = 0; i < command.size(); ++i)
	{
	if (command[i] == L'\"' && (i == 0 || command[i - 1] != L'\\'))
	{
	inString = !inString;
	continue;
	}
	if (std::iswspace(command[i]) && !inString)
	{
	if (!current.empty())
	{
	ReplaceEscapes(current);
	arguments.push_back(current);
	current.clear();
	}
	continue;
	}
	current += command[i];
	}
	if (!current.empty())
	{
	ReplaceEscapes(current);
	arguments.push_back(current);
	}
	return arguments;
	}
	std::vector<std::vector<std::wstring>> CommandPreprocess::PreProcessString(std::wstring cmdline)
	{
	Trim(cmdline);
	if (cmdline.empty())
	{
	return {};
	}
	PreprocessEscapes(cmdline);
	std::vector<std::vector<std::wstring>> result;
	std::vector<std::wstring> commands = SplitCommands(cmdline);
	for (auto& cmd : commands)
	{
	std::vector<std::wstring> args = ParseArguments(cmd);
	if (!args.empty())
	{
	result.push_back(args);
	}
	}
	return result;
	}
	void ArgumentsPreprocess::ReplaceEscapes(std::string& str)
	{
	std::string result;
	for (size_t i = 0; i < str.size(); ++i)
	{
	if (str[i] == '\\' && i + 1 < str.size())
	{
	switch (str[i + 1])
	{
	case '\\': result += '\\'; ++i; break;
	case 'n': result += '\n'; ++i; break;
	case 'r': result += '\r'; ++i; break;
	case 't': result += '\t'; ++i; break;
	case '\"': result += '\"'; ++i; break;
	default: result += str[i]; break;
	}
	}
	else
	{
	result += str[i];
	}
	}
	str = result;
	}
	std::vector<std::string> ArgumentsPreprocess::ParseArguments(std::string cmdline)
	{
	std::vector<std::string> arguments;
	std::string current;
	bool inString = false;
	for (size_t i = 0; i < cmdline.size(); ++i)
	{
	if (cmdline[i] == '\"' && (i == 0 || cmdline[i - 1] != '\\'))
	{
	inString = !inString;
	continue;
	}
	if ((cmdline[i] == ' ' || cmdline[i] == '\t') && !inString)
	{
	if (!current.empty())
	{
	ReplaceEscapes(current);
	arguments.push_back(current);
	current.clear();
	}
	continue;
	}
	current += cmdline[i];
	}
	if (!current.empty())
	{
	ReplaceEscapes(current);
	arguments.push_back(current);
	}
	return arguments;
	}
	bool ArgumentsPreprocess::Compare(const std::string& str, const std::string& op, const std::string& arg) //TODO ugly code
	{
	if (op.empty()) { return false; }
	if (StringUtils::isNumber(str))
	{
	double numstr = StringUtils::FromStr<double>(str);
	double numarg = StringUtils::FromStr<double>(arg);
	if (op == "==")
	{
	return numstr == numarg;
	}
	else if (op == ">")
	{
	return numstr > numarg;
	}
	else if (op == "<")
	{
	return numstr < numarg;
	}
	else if (op == ">=")
	{
	return numstr >= numarg;
	}
	else if (op == "<=")
	{
	return numstr <= numarg;
	}
	else if (op == "!=")
	{
	return numstr != numarg;
	}
	else
	{
	return false;
	}
	}
	if (op == "==")
	{
	return str == arg;
	}
	else if (op == ">")
	{
	return str > arg;
	}
	else if (op == "<")
	{
	return str < arg;
	}
	else if (op == ">=")
	{
	return str >= arg;
	}
	else if (op == "<=")
	{
	return str <= arg;
	}
	else if (op == "!=")
	{
	return str != arg;
	}
	return false;
	}