#pragma once
	#include <string>
	#include <sstream>
	#include <locale>
	#include <codecvt>
	#include <vector>
	#include <algorithm>
	#include <type_traits>
	#include <regex>
	#include <iostream>
	#include <string_view>
	#include <boost/locale.hpp>
	#include "U_General.h"
	#include "U_Types.h"
	#include "glm/glm.hpp"
	#include "glm/gtc/quaternion.hpp"
	#include "CAngle.h"
	#include "CColor.h"
	#include "CColorInt.h"
	namespace StringUtils
	{
	std::wstring StrToWstr(const std::string& str);
	std::string WstrToStr(const std::wstring& wstr);
	std::u16string Utf8ToU16(const std::string& str);
	std::string U16ToUtf8(const std::u16string& str);
	std::u16string WstrToU16(const std::wstring& wstr);
	std::wstring U16ToWstr(const std::u16string& str);
	void split_str(const std::string& s, char delim, std::vector<std::string>& ua);
	void split_str(const std::wstring& s, wchar_t delim, std::vector<std::wstring>& ua);
	std::vector<std::string> split_str(const std::string& s, char delim);
	std::vector<std::wstring> split_str(const std::wstring& s, wchar_t delim);
	template<typename String = std::string>
	String RemoveSpaces(const String& str, size_t stayBegin = 0, size_t stayEnd = 0)
	{
	using C = std::conditional_t<std::is_same_v<String, std::string>, char, wchar_t>;
	constexpr C charspace = std::is_same_v<C, char> ? ' ' : L' ';
	constexpr C chartab = std::is_same_v<C, char> ? '\t' : L'\t';
	String ret = str;
	size_t spacesAtBegin = 0, spacesAtEnd = 0;
	for(auto it = str.begin(); it != str.end(); ++it)
	{
	if(*it == charspace || *it == chartab)
	{
	spacesAtBegin++;
	}
	else
	{
	break;
	}
	}
	for(auto it = str.rbegin(); it != str.rend(); ++it)
	{
	if(*it == charspace || *it == chartab)
	{
	spacesAtEnd++;
	}
	else
	{
	break;
	}
	}
	int diffBegin = static_cast<int>(spacesAtBegin) - static_cast<int>(stayBegin);
	int diffEnd = static_cast<int>(spacesAtEnd) - static_cast<int>(stayEnd);
	//3 - 1 = 2
	//1 - 1 = 0
	//3 - 4 = -1
	if(diffBegin < 0) { diffBegin = 0; }
	if(diffEnd < 0) { diffEnd = 0; }
	if (diffBegin > ret.size()) { diffBegin = ret.size(); }
	ret.erase(0, diffBegin);
	if (diffEnd > ret.size()) { diffEnd = ret.size(); }
	ret.erase(ret.size() - diffEnd, diffEnd);
	//mleb***
	//0123456 size = 7
	//diffEnd = 3
	//7 - 3 = 4
	return ret;
	}
	template<typename String = std::string>
	String SafeSubstring(const String& str, size_t count, size_t offset = 0)
	{
	//substr
	//0, 3 -> sub
	//substr
	//0, 6 -> substr
	//substr
	//1, 3 -> ubs
	//substr
	//4, 4 -> tr (6 - 4) = 2
	//substr
	//4, 5 -> tr (6 - 4) = 2
	if (str.empty()) { return String(); }
	size_t startIndex = offset;
	size_t endIndex = offset + count;
	if (startIndex >= str.size()) { return String(); }
	if (endIndex >= str.size()) { return str.substr(startIndex, str.size() - startIndex); }
	return str.substr(startIndex, count);
	}
	bool StartsWith(const std::string& str, const std::string& startswith);
	bool StartsWith(const std::wstring& str, const std::wstring& startswith);
	template<typename String = std::string>
	String merge_arg(const std::vector<String>& vect, size_t start, size_t end)
	{
	if (vect.empty()) { return {}; }
	String ret;
	for (size_t i = start; i <= end; ++i)
	{
	if constexpr (std::is_same_v<String, std::wstring>)
	{
	if (i != start) { ret += L" "; }
	}
	else
	{
	if (i != start) { ret += " "; }
	}
	ret += vect.at(i);
	}
	return ret;
	}
	template<typename String = std::string>
	void replace(String& str, const String& from, const String& to)
	{
	if (from.empty()) { return; }
	size_t start_pos = 0;
	while ((start_pos = str.find(from, start_pos)) != String::npos)
	{
	str.replace(start_pos, from.length(), to);
	start_pos += to.length();
	}
	}
	template<typename String = std::string>
	bool hasEnding(const String& fullString, const String& ending)
	{
	if (fullString.length() >= ending.length())
	{
	return (0 == fullString.compare(fullString.length() - ending.length(), ending.length(), ending));
	}
	return false;
	}
	template<typename String = std::string>
	bool IsEmpty(const String& str)
	{
	if (str.empty()) { return true; }
	using C = std::conditional_t<std::is_same_v<String, std::string>, char, wchar_t>;
	constexpr C charspace = std::is_same_v<C, char> ? ' ' : L' ';
	constexpr C chartab = std::is_same_v<C, char> ? '\t' : L'\t';
	for (C b : str)
	{
	if (b != charspace && b != chartab)
	{
	return false;
	}
	}
	return true;
	}
	template <typename StringType>
	bool isNumber(const StringType& str)
	{
	if (str.empty()) { return false; }
	typename StringType::const_iterator it = str.begin();
	bool decimalPoint = false;
	bool hasDigits = false;
	typename StringType::value_type dotChar = '.';
	typename StringType::value_type minusChar = '-';
	if (*it == minusChar) { ++it; }
	for (; it != str.end(); ++it)
	{
	if (*it == dotChar)
	{
	if (decimalPoint)
	{
	return false;
	}
	decimalPoint = true;
	}
	else if (!std::isdigit(*it, std::locale()))
	{
	return false;
	}
	else
	{
	hasDigits = true;
	}
	}
	return hasDigits;
	}
	void remove_consecutive_commas(std::string& str);
	void remove_consecutive_commas(std::wstring& str);
	namespace SequentVectorParse
	{
	template<typename String>
	std::vector<String> Split(String str)
	{
	std::vector<String> ret;
	if constexpr (std::is_same_v<String, std::string>)
	{
	replace(str, std::string(" "), std::string(","));
	replace(str, std::string(";"), std::string(","));
	replace(str, std::string("\t"), std::string(","));
	replace(str, std::string(":"), std::string(","));
	remove_consecutive_commas(str);
	split_str(str, ',', ret);
	}
	else if constexpr (std::is_same_v<String, std::wstring>)
	{
	replace(str, std::wstring(L" "), std::wstring(L","));
	replace(str, std::wstring(L";"), std::wstring(L","));
	replace(str, std::wstring(L"\t"), std::wstring(L","));
	replace(str, std::wstring(L":"), std::wstring(L","));
	remove_consecutive_commas(str);
	split_str(str, L',', ret);
	}
	return ret;
	}
	template<typename Vec, typename String = std::string>
	void Parse(Vec& vec, const String& str)
	{
	using sstream = std::conditional_t<std::is_same_v<String, std::string>, std::stringstream, std::wstringstream>;
	auto splitted = Split(str);
	for (auto i = 0; i < vec.length() && i < splitted.size(); i++)
	{
	typename Vec::value_type single;
	sstream ss(splitted[i]);
	ss >> single;
	vec[i] = single;
	}
	}
	}
	template<typename T, typename String = std::string>
	T FromStr(const String& str) //TODO glm::mat
	{
	using sstream = std::conditional_t<std::is_same_v<String, std::string>, std::stringstream, std::wstringstream>;
	constexpr bool is_this_string = std::is_same_v<String, std::string>;
	constexpr bool is_this_wstring = std::is_same_v<String, std::wstring>;
	constexpr bool is_char = std::is_same<T, char>::value || std::is_same<T, unsigned char>::value;
	constexpr bool is_string = std::is_same<T, std::string>::value;
	constexpr bool is_wstring = std::is_same<T, std::wstring>::value;
	constexpr bool is_angle = std::is_same<T, CAngle>::value;
	constexpr bool is_angles = std::is_same<T, CAngles>::value;
	constexpr bool is_color = std::is_same<T, CColor>::value;
	constexpr bool is_colorint = std::is_same<T, CColorInt>::value;
	constexpr bool is_anycolor = is_color || is_colorint;
	constexpr bool is_quat = are_same_template<T, glm::quat>::value;
	constexpr bool is_vec2 = are_same_template<T, glm::vec2>::value;
	constexpr bool is_vec3 = are_same_template<T, glm::vec3>::value;
	constexpr bool is_vec4 = are_same_template<T, glm::vec4>::value;
	constexpr bool is_ivec2 = are_same_template<T, glm::ivec2>::value;
	constexpr bool is_ivec3 = are_same_template<T, glm::ivec3>::value;
	constexpr bool is_ivec4 = are_same_template<T, glm::ivec4>::value;
	constexpr bool is_uvec2 = are_same_template<T, glm::uvec2>::value;
	constexpr bool is_uvec3 = are_same_template<T, glm::uvec3>::value;
	constexpr bool is_uvec4 = are_same_template<T, glm::uvec4>::value;
	constexpr bool is_vec_or_quat = is_glm_quat_v<T> || is_glm_vec_v<T>;
	constexpr bool is_bool = std::is_same<T, bool>::value;
	constexpr bool is_int8 = std::is_same<T, std::int8_t>::value;
	constexpr bool is_uint8 = std::is_same<T, std::uint8_t>::value;
	sstream ss(str);
	if constexpr (is_int8 || is_uint8)
	{
	int ret;
	ss >> ret;
	return ret;
	}
	else if constexpr (is_wstring && is_this_string)
	{
	return StrToWstr(str);
	}
	else if constexpr (is_string && is_this_wstring)
	{
	return WstrToStr(str);
	}
	else if constexpr (is_bool)
	{
	String str_lower = str;
	if constexpr (is_this_string)
	{
	std::transform(str_lower.begin(), str_lower.end(), str_lower.begin(), ::tolower);
	if (str_lower == "true" || str_lower == "yes")
	{
	return true;
	}
	}
	else
	{
	std::transform(str_lower.begin(), str_lower.end(), str_lower.begin(), ::towlower);
	if (str_lower == L"true" || str_lower == L"yes")
	{
	return true;
	}
	}
	int num;
	float fl_num;
	ss >> num;
	if (ss.fail())
	{
	ss.clear();
	ss.str(str);
	ss >> fl_num;
	if (ss.fail() || std::isnan(fl_num))
	{
	return false;
	}
	else
	{
	return (fl_num > 0.0f);
	}
	}
	else
	{
	return (num > 0);
	}
	}
	else if constexpr (is_vec_or_quat || is_angles || is_anycolor)
	{
	T ret{};
	SequentVectorParse::Parse(ret, str);
	return ret;
	}
	else if constexpr (is_angle)
	{
	float angl;
	ss >> angl;
	return CAngle::radians(angl);
	}
	else
	{
	T ret;
	ss >> ret;
	return ret;
	}
	}
	template<typename String = std::string, typename T>
	String ToStr(const T& val) //TODO glm::mat
	{
	using sstream = std::conditional_t<std::is_same_v<String, std::string>, std::stringstream, std::wstringstream>;
	constexpr bool is_int8 = std::is_same<T, std::int8_t>::value;
	constexpr bool is_uint8 = std::is_same<T, std::uint8_t>::value;
	constexpr bool is_this_string = std::is_same_v<String, std::string>;
	constexpr bool is_this_wstring = std::is_same_v<String, std::wstring>;
	constexpr bool is_char = std::is_same<T, char>::value || std::is_same<T, unsigned char>::value;
	constexpr bool is_double = std::is_floating_point<T>::value;
	constexpr bool is_string = std::is_same<T, std::string>::value;
	constexpr bool is_wstring = std::is_same<T, std::wstring>::value;
	constexpr bool is_angle = std::is_same<T, CAngle>::value;
	constexpr bool is_angles = std::is_same<T, CAngles>::value;
	constexpr bool is_quat = are_same_template<T, glm::quat>::value;
	constexpr bool is_vec2 = are_same_template<T, glm::vec2>::value;
	constexpr bool is_vec3 = are_same_template<T, glm::vec3>::value;
	constexpr bool is_vec4 = are_same_template<T, glm::vec4>::value;
	constexpr bool is_ivec2 = are_same_template<T, glm::ivec2>::value;
	constexpr bool is_ivec3 = are_same_template<T, glm::ivec3>::value;
	constexpr bool is_ivec4 = are_same_template<T, glm::ivec4>::value;
	constexpr bool is_uvec2 = are_same_template<T, glm::uvec2>::value;
	constexpr bool is_uvec3 = are_same_template<T, glm::uvec3>::value;
	constexpr bool is_uvec4 = are_same_template<T, glm::uvec4>::value;
	constexpr bool is_color = std::is_same<T, CColor>::value;
	constexpr bool is_colorint = std::is_same<T, CColorInt>::value;
	constexpr bool is_anycolor = is_color || is_colorint;
	constexpr bool is_vec_or_quat = is_glm_quat_v<T> || is_glm_vec_v<T>;
	if constexpr (is_char)
	{
	int v = val;
	sstream ss;
	ss << v;
	return ss.str();
	}
	else if constexpr (is_wstring && is_this_string)
	{
	return WstrToStr(val);
	}
	else if constexpr (is_string && is_this_wstring)
	{
	return StrToWstr(val);
	}
	else if constexpr (is_angle)
	{
	sstream strs;
	strs.precision(std::numeric_limits<T>::digits10);
	strs << std::fixed << val.asRadians();
	return strs.str();
	}
	else if constexpr (is_vec_or_quat || is_angles || is_anycolor)
	{
	sstream strs;
	for (int i = 0; i < val.length(); i++)
	{
	if constexpr (std::is_floating_point<typename T::value_type>::value)
	{
	strs.precision(std::numeric_limits<typename T::value_type>::digits10);
	strs << std::fixed;
	}
	strs << val[i];
	if (i != (val.length() - 1))
	{
	if constexpr (is_this_wstring)
	{
	strs << L' ';
	}
	else
	{
	strs << ' ';
	}
	}
	}
	return strs.str();
	}
	else if constexpr (is_double)
	{
	sstream strs;
	strs.precision(std::numeric_limits<T>::digits10);
	strs << std::fixed << val;
	return strs.str();
	}
	else
	{
	sstream ss;
	ss << val;
	return ss.str();
	}
	}
	}
	namespace CommandPreprocess
	{
	void Trim(std::wstring& str);
	void PreprocessEscapes(std::wstring& str);
	void ReplaceEscapes(std::wstring& str);
	std::vector<std::wstring> SplitCommands(const std::wstring& input);
	std::vector<std::wstring> ParseArguments(const std::wstring& command);
	std::vector<std::vector<std::wstring>> PreProcessString(std::wstring cmdline);
	}
	namespace ArgumentsPreprocess
	{
	void ReplaceEscapes(std::string& str);
	std::vector<std::string> ParseArguments(std::string cmdline);
	bool Compare(const std::string& str, const std::string& op, const std::string& arg);
	}