String.cs

#region Related components
using System;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Collections.Generic;
using System.Globalization;
#endregion

namespace net.vieapps.Components.Utility
{
	/// <summary>
	/// Static servicing methods for working with string
	/// </summary>
	public static partial class StringService
	{
		/// <summary>
		/// Gets the default text encoding - UTF-8 without byte order mark
		/// </summary>
		public static Encoding UTF8NoBOM { get; } = new UTF8Encoding(false);

		#region Manipulations
		/// <summary>
		/// Gets left-side sub-string (just like VB does)
		/// </summary>
		/// <param name="string"></param>
		/// <param name="length"></param>
		/// <returns></returns>
		public static string Left(this string @string, int length)
			=> length < 0
				? throw new ArgumentException($"Argument '{nameof(length)}' must be greater or equal to zero")
				: @string.Equals("")
					? string.Empty
					: length >= @string.Length
						? @string
						: @string.Substring(0, length);

		/// <summary>
		/// Gets right-side sub-string (just like VB does)
		/// </summary>
		/// <param name="string"></param>
		/// <param name="length"></param>
		/// <returns></returns>
		public static string Right(this string @string, int length)
			=> length < 0
				? throw new ArgumentException($"Argument '{nameof(length)}' must be greater or equal to zero")
				: @string.Equals("")
					? string.Empty
					: length >= @string.Length
						? @string
						: @string.Substring(@string.Length - length);

		/// <summary>
		/// Returns a new string that right-aligns the characters in this instance by padding them with spaces on the left, for a specified total length
		/// </summary>
		/// <param name="string"></param>
		/// <param name="totalWidth"></param>
		/// <param name="paddingChar"></param>
		/// <returns></returns>
		public static string PadLeft(this string @string, int totalWidth, string paddingChar = null)
			=> string.IsNullOrWhiteSpace(@string)
				? ""
				: string.IsNullOrWhiteSpace(paddingChar)
					? @string.PadLeft(totalWidth)
					: @string.PadLeft(totalWidth, paddingChar[0]);

		/// <summary>
		/// Returns a new string that left-aligns the characters in this string by padding them with spaces on the right, for a specified total length
		/// </summary>
		/// <param name="string"></param>
		/// <param name="totalWidth"></param>
		/// <param name="paddingChar"></param>
		/// <returns></returns>
		public static string PadRight(this string @string, int totalWidth, string paddingChar = null)
			=> string.IsNullOrWhiteSpace(@string)
				? ""
				: string.IsNullOrWhiteSpace(paddingChar)
					? @string.PadRight(totalWidth)
					: @string.PadRight(totalWidth, paddingChar[0]);

		/// <summary>
		/// Replaces
		/// </summary>
		/// <param name="string"></param>
		/// <param name="comparisonType"></param>
		/// <param name="pattern"></param>
		/// <param name="replacement"></param>
		/// <returns></returns>
		public static string Replace(this string @string, StringComparison comparisonType, string pattern, string replacement)
		{
			if (string.IsNullOrWhiteSpace(@string))
				return string.Empty;

			if (string.IsNullOrWhiteSpace(pattern))
				return @string;

#if NETSTANDARD2_0
			var result = @string;
			var pos = result.IndexOf(pattern, comparisonType);
			while (pos > -1)
			{
				result = result.Remove(pos, pattern.Length);
				if (!string.IsNullOrWhiteSpace(replacement))
					result = result.Insert(pos, replacement);
				pos += string.IsNullOrWhiteSpace(replacement)
					? 1
					: replacement.Length;
				pos = pos < result.Length
					? result.IndexOf(pattern, pos, comparisonType)
					: -1;
			}
			return result;
#else
			return @string.Replace(pattern, replacement, comparisonType);
#endif
		}

		/// <summary>
		/// Counts the bytes of this string
		/// </summary>
		/// <param name="string"></param>
		/// <param name="encoding"></param>
		/// <returns></returns>
		public static int CountBytes(this string @string, Encoding encoding = null)
			=> @string == null ? -1 : (encoding ?? Encoding.UTF8).GetByteCount(@string);
		#endregion

		#region Comparisons
		/// <summary>
		/// Checks to see the string is numeric string or not
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		public static bool IsNumeric(this string @string)
			=> !string.IsNullOrWhiteSpace(@string) && double.TryParse(@string, out var number);

		/// <summary>
		/// Check to see its equals
		/// </summary>
		/// <param name="string"></param>
		/// <param name="compareTo"></param>
		/// <param name="comparisonType"></param>
		/// <returns></returns>
		public static bool IsEquals(this string @string, string compareTo, StringComparison comparisonType = StringComparison.OrdinalIgnoreCase)
			=> string.IsNullOrWhiteSpace(compareTo)
				? string.IsNullOrWhiteSpace(@string)
				: @string.Equals(compareTo, comparisonType);

		/// <summary>
		/// Check to see its contains
		/// </summary>
		/// <param name="string"></param>
		/// <param name="substring"></param>
		/// <param name="comparisonType"></param>
		/// <returns></returns>
		public static bool IsContains(this string @string, string substring, StringComparison comparisonType = StringComparison.OrdinalIgnoreCase)
			=> !string.IsNullOrWhiteSpace(@string) && !string.IsNullOrWhiteSpace(substring) && @string.IndexOf(substring, 0, comparisonType) > -1;

		/// <summary>
		/// Check to see its starts with
		/// </summary>
		/// <param name="string"></param>
		/// <param name="substring"></param>
		/// <param name="comparisonType"></param>
		/// <returns></returns>
		public static bool IsStartsWith(this string @string, string substring, StringComparison comparisonType = StringComparison.OrdinalIgnoreCase)
			=> !string.IsNullOrWhiteSpace(@string) && !string.IsNullOrWhiteSpace(substring) && @string.StartsWith(substring, comparisonType);

		/// <summary>
		/// Check to see its starts with
		/// </summary>
		/// <param name="string"></param>
		/// <param name="char"></param>
		/// <param name="comparisonType"></param>
		/// <returns></returns>
		public static bool IsStartsWith(this string @string, char @char, StringComparison comparisonType = StringComparison.OrdinalIgnoreCase)
			=> !string.IsNullOrWhiteSpace(@string) && @string.IsStartsWith($"{@char}", comparisonType);

		/// <summary>
		/// Check to see its ends with
		/// </summary>
		/// <param name="string"></param>
		/// <param name="substring"></param>
		/// <param name="comparisonType"></param>
		/// <returns></returns>
		public static bool IsEndsWith(this string @string, string substring, StringComparison comparisonType = StringComparison.OrdinalIgnoreCase)
			=> !string.IsNullOrWhiteSpace(@string) && !string.IsNullOrWhiteSpace(substring) && @string.EndsWith(substring, comparisonType);

		/// <summary>
		/// Check to see its ends with
		/// </summary>
		/// <param name="string"></param>
		/// <param name="char"></param>
		/// <param name="comparisonType"></param>
		/// <returns></returns>
		public static bool IsEndsWith(this string @string, char @char, StringComparison comparisonType = StringComparison.OrdinalIgnoreCase)
			=> !string.IsNullOrWhiteSpace(@string) && @string.IsEndsWith($"{@char}", comparisonType);

		/// <summary>
		/// Gets position of sub-string (index of sub-string)
		/// </summary>
		/// <param name="string"></param>
		/// <param name="substring"></param>
		/// <param name="startIndex"></param>
		/// <param name="comparisonType"></param>
		/// <returns></returns>
		public static int PositionOf(this string @string, string substring, int startIndex = 0, StringComparison comparisonType = StringComparison.OrdinalIgnoreCase)
			=> string.IsNullOrWhiteSpace(@string) || string.IsNullOrWhiteSpace(substring) || startIndex >= @string.Length
				? -1
				: @string.IndexOf(substring, startIndex < 0 ? 0 : startIndex, comparisonType);

		/// <summary>
		/// Counts the number of appearances of the sub-string
		/// </summary>
		/// <param name="string"></param>
		/// <param name="substring"></param>
		/// <param name="startIndex"></param>
		/// <param name="comparisonType"></param>
		/// <returns></returns>
		public static int Count(this string @string, string substring, int startIndex = 0, StringComparison comparisonType = StringComparison.OrdinalIgnoreCase)
		{
			if (string.IsNullOrWhiteSpace(@string) || string.IsNullOrWhiteSpace(substring))
				return 0;

			var count = 0;
			var start = @string.PositionOf(substring, startIndex < 0 ? 0 : startIndex, comparisonType);
			while (start > -1)
			{
				count++;
				start = @string.PositionOf(substring, start + 1, comparisonType);
			}
			return count;
		}
		#endregion

		#region Compressions
		/// <summary>
		/// Compresses the string
		/// </summary>
		/// <param name="string"></param>
		/// <param name="mode">Compression mode (zstd/br/gzip/deflate)</param>
		/// <returns>The compressed-string in Base64 format</returns>
		public static string Compress(this string @string, string mode = "zstd")
			=> string.IsNullOrWhiteSpace(@string)
				? ""
				: @string.ToBytes().Compress(mode).ToBase64();

		/// <summary>
		/// Decompresses the Base64 string
		/// </summary>
		/// <param name="string"></param>
		/// <param name="mode">Decompression mode (zstd/br/gzip/deflate)</param>
		/// <returns>The decompressed-string</returns>
		public static string Decompress(this string @string, string mode = "zstd")
			=> string.IsNullOrWhiteSpace(@string)
				? ""
				: @string.Base64ToBytes().Decompress(mode).GetString();
		#endregion

		#region Conversions
		/// <summary>
		/// Gets reversed string
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		public static string Reverse(this string @string)
		{
			if (@string.Equals("") || @string.Length < 2)
				return @string;
			var chars = @string.ToCharArray();
			Array.Reverse(chars);
			return new string(chars);
		}

		/// <summary>
		/// Gets the string with first-letter is capitalized
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		public static string GetCapitalizedFirstLetter(this string @string, bool wordsSeperatedByDots = true)
		{
			if (string.IsNullOrWhiteSpace(@string))
				return "";
			if (wordsSeperatedByDots)
				return @string.ToArray(".").Select(str =>
				{
					var chars = str.ToLower().ToCharArray();
					chars[0] = char.ToUpper(chars[0]);
					return new string(chars);
				}).Join(".");
			else
			{
				var chars = @string.ToLower().ToCharArray();
				chars[0] = char.ToUpper(chars[0]);
				return new string(chars);
			}
		}

		/// <summary>
		/// Gets the string with first-letter of all words is capitalized
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		public static string GetCapitalizedWords(this string @string)
			=> CultureInfo.CurrentCulture.TextInfo.ToTitleCase(@string);

		/// <summary>
		/// Converts this integer to enum type value
		/// </summary>
		/// <param name="int"></param>
		/// <param name="type">The type of enum</param>
		/// <returns></returns>
		public static object ToEnum(this int @int, Type type)
			=> type != null && type.IsEnum
				? Enum.ToObject(type, @int)
				: throw new ArgumentException($"The type '{nameof(type)}' is not enum");

		/// <summary>
		/// Converts this integer to enum type value
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="int"></param>
		/// <returns></returns>
		public static T ToEnum<T>(this int @int)
			=> (T)@int.ToEnum(typeof(T));

		/// <summary>
		/// Converts this enum-string to enum type value
		/// </summary>
		/// <param name="string"></param>
		/// <param name="type">The type of enum</param>
		/// <returns></returns>
		public static object ToEnum(this string @string, Type type)
			=> type != null && type.IsEnum
				? Enum.Parse(type, @string)
				: throw new ArgumentException($"The type '{nameof(type)}' is not enum");

		/// <summary>
		/// Converts this enum-string to enum type value
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="string"></param>
		/// <returns></returns>
		public static T ToEnum<T>(this string @string)
			=> (T)@string.ToEnum(typeof(T));

		/// <summary>
		/// Trys to converts this enum-string to enum-typed value
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="string"></param>
		/// <param name="value"></param>
		/// <returns></returns>
		public static bool TryToEnum<T>(this string @string, out T value) where T : struct
			=> typeof(T).IsEnum
				? Enum.TryParse(@string, out value)
				: throw new ArgumentException($"The type '{typeof(T).GetType()}' is not enum");

		/// <summary>
		/// Gets the string from array of bytes by specified encoding (default is UTF8)
		/// </summary>
		/// <param name="bytes"></param>
		/// <param name="count"></param>
		/// <param name="encoding"></param>
		/// <returns></returns>
		public static string GetString(this byte[] bytes, int count = 0, Encoding encoding = null)
			=> bytes == null ? null : bytes.Length < 1 ? string.Empty : (encoding ?? StringService.UTF8NoBOM).GetString(bytes, 0, count > 0 && count <= bytes.Length ? count : bytes.Length);

		/// <summary>
		/// Gets the string from array of bytes by specified encoding (default is UTF8)
		/// </summary>
		/// <param name="bytes"></param>
		/// <param name="count"></param>
		/// <param name="encoding"></param>
		/// <returns></returns>
		public static string GetString(this ArraySegment<byte> bytes, int count = 0, Encoding encoding = null)
			=> bytes.ToBytes(count).GetString(0, encoding);

		/// <summary>
		/// Gets the double braces (mustache-style - {{  }}) tokens
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		public static List<Tuple<string, string>> GetDoubleBracesTokens(this string @string)
		{
			var tokens = new List<Tuple<string, string>>();
			if (!string.IsNullOrWhiteSpace(@string))
			{
				var matches = new Regex("{{([^{}]*)}}", RegexOptions.IgnoreCase).Matches(@string);
				foreach (Match match in matches)
					tokens.Add(new Tuple<string, string>(match.Groups[0].Value, match.Groups[1].Value.Trim()));
			}
			return tokens;
		}

		/// <summary>
		/// Formats the string with parameters of double braces (mustache-style - {{  }}) tokens
		/// </summary>
		/// <param name="string"></param>
		/// <param name="params"></param>
		/// <returns></returns>
		public static string Format(this string @string, IDictionary<string, object> @params)
		{
			var tokens = @string?.GetDoubleBracesTokens();
			@params?.ForEach(kvp => tokens?.Where(token => token.Item2.IsEquals(kvp.Key)).ForEach(token => @string = @string?.Replace(StringComparison.OrdinalIgnoreCase, token.Item1, $"{kvp.Value}")));
			return @string;
		}
		#endregion

		#region Validations (Email/Phone)
		/// <summary>
		/// Validates an email address
		/// </summary>
		/// <param name="input"></param>
		/// <param name="output"></param>
		/// <returns></returns>
		public static bool IsValidEmail(this string input, out string output)
		{
			output = (input ?? "").Replace(" ", "").Replace("#", "").Trim().ToLower();
			var regex = new Regex("^(([^<>()[\\]\\.,;:\\s@\\\"]+(\\.[^<>()[\\]\\.,;:\\s@\\\"]+)*)|(\\\".+\\\"))@(([^<>()[\\]\\.,;:\\s@\\\"]+\\.)+[^<>()[\\]\\.,;:\\s@\\\"]{2,})$", RegexOptions.IgnoreCase);
			if (string.IsNullOrWhiteSpace(output) || !regex.IsMatch(output))
			{
				output = null;
				return false;
			}
			return true;
		}

		/// <summary>
		/// Validates a phone number
		/// </summary>
		/// <param name="input"></param>
		/// <param name="output"></param>
		/// <param name="phoneCountryCode"></param>
		/// <returns></returns>
		public static bool IsValidPhone(this string input, out string output, string phoneCountryCode = "84")
		{
			output = (input ?? "").Replace(" ", "").Replace("-", "").Replace(".", "").Trim();
			var regex = new Regex("^\\s*(?:\\+?(\\d{1,3}))?[-. (]*(\\d{3})[-. )]*(\\d{3})[-. ]*(\\d{4})(?: *x(\\d+))?\\s*$", RegexOptions.IgnoreCase);
			if (string.IsNullOrWhiteSpace(output) || !regex.IsMatch(output))
			{
				output = null;
				return false;
			}
			if (output.StartsWith("00"))
				output = $"+{output.Right(output.Length - 2)}";
			if (output.StartsWith("0"))
				output = $"+{phoneCountryCode ?? "84"}{output.Right(output.Length - 1)}";
			return true;
		}
		#endregion

		#region Conversions (Vietnamese)
		internal static string ConvertVietnamese(this string @string, int mode)
		{
			if (string.IsNullOrWhiteSpace(@string))
				return string.Empty;

			var utf8Literal = "à á ả ã ạ À Á Ả Ã Ạ â ầ ấ ẩ ẫ ậ Â Ầ Ấ Ẩ Ẫ Ậ ă ằ ắ ẳ ẵ ặ Ă Ằ Ắ Ẳ Ẵ Ặ "
				+ "ò ó ỏ õ ọ Ò Ó Ỏ Õ Ọ ô ồ ố ổ ỗ ộ Ô Ồ Ố Ổ Ỗ Ộ ơ ờ ớ ở ỡ ợ Ơ Ờ Ớ Ở Ỡ Ợ "
				+ "è é ẻ ẽ ẹ È É Ẻ Ẽ Ẹ ê ề ế ể ễ ệ Ê Ề Ế Ể Ễ Ệ "
				+ "ù ú ủ ũ ụ Ù Ú Ủ Ũ Ụ ư ừ ứ ử ữ ự Ư Ừ Ứ Ử Ữ Ự "
				+ "ì í ỉ ĩ ị Ì Í Ỉ Ĩ Ị ỳ ý ỷ ỹ ỵ Ỳ Ý Ỷ Ỹ Ỵ đ Đ "
				+ "“ ” – à ’ Á ÇŽ … aI";
			var utf8Literals = utf8Literal.Split(' ');

			var utf8Unicode = "à á ả ã ạ À Á Ả Ã Ạ â ầ ấ ẩ ẫ ậ Â Ầ Ấ Ẩ Ẫ Ậ ă ằ ắ ẳ ẵ ặ Ă Ằ Ắ Ẳ Ẵ Ặ "
				+ "ò ó ỏ õ ọ Ò Ó Ỏ Õ Ọ ô ồ ố ổ ỗ ộ Ô Ồ Ố Ổ Ỗ Ộ ơ ờ ớ ở ỡ ợ Ơ Ờ Ớ Ở Ỡ Ợ "
				+ "è é ẻ ẽ ẹ È É Ẻ Ẽ Ẹ ê ề ế ể ễ ệ Ê Ề Ế Ể Ễ Ệ "
				+ "ù ú ủ ũ ụ Ù Ú Ủ Ũ Ụ ư ừ ứ ử ữ ự Ư Ừ Ứ Ử Ữ Ự "
				+ "ì í ỉ ĩ ị Ì Í Ỉ Ĩ Ị ỳ ý ỷ ỹ ỵ Ỳ Ý Ỷ Ỹ Ỵ đ Đ "
				+ "“ ” – Á ’ Đ ă &nbsp; á";
			var utf8Unicodes = utf8Unicode.Split(' ');

			var utf8UnicodeComposite = "à á ả ã ạ À Á Ả Ã Ạ â ầ ấ ẩ ẫ ậ Â Ầ Ấ Ẩ Ẫ Ậ ă ằ ắ ẳ ẵ ặ Ă Ằ Ắ Ẳ Ẵ Ặ "
				+ "ò ó ỏ õ ọ Ò Ó Ỏ Õ Ọ ô ồ ố ổ ỗ ộ Ô Ồ Ố Ổ Ỗ Ộ ơ ờ ớ ở ỡ ợ Ơ Ờ Ớ Ở Ỡ Ợ "
				+ "è é ẻ ẽ ẹ È É Ẻ Ẽ Ẹ ê ề ế ể ễ ệ Ê Ề Ế Ể Ễ Ệ "
				+ "ù ú ủ ũ ụ Ù Ú Ủ Ũ Ụ ư ừ ứ ử ữ ự Ư Ừ Ứ Ử Ữ Ự "
				+ "ì í ỉ ĩ ị Ì Í Ỉ Ĩ Ị ỳ ý ỷ ỹ ỵ Ỳ Ý Ỷ Ỹ Ỵ đ Đ "
				+ "“ ” – Á ’ Đ ă &nbsp; á";
			var utf8UnicodeComposites = utf8UnicodeComposite.Split(' ');

			var ansi = "a a a a a A A A A A a a a a a a A A A A A A a a a a a a A A A A A A "
				+ "o o o o o O O O O O o o o o o o O O O O O O o o o o o o O O O O O O "
				+ "e e e e e E E E E E e e e e e e E E E E E E "
				+ "u u u u u U U U U U u u u u u u U U U U U U "
				+ "i i i i i I I I I I y y y y y Y Y Y Y Y d D "
				+ "\" \" - A ' D a &nbsp; a";
			var ansis = ansi.Split(' ');

			var decimalUnicode = "&#224; &#225; &#7843; &#227; &#7841; &#192; &#193; &#7842; &#195; &#7840; &#226; &#7847; &#7845; &#7849; &#7851; &#7853; &#194; &#7846; &#7844; &#7848; &#7850; &#7852; &#259; &#7857; &#7855; &#7859; &#7861; &#7863; &#258; &#7856; &#7854; &#7858; &#7860; &#7862; "
				+ "&#242; &#243; &#7887; &#245; &#7885; &#210; &#211; &#7886; &#213; &#7884; &#244; &#7891; &#7889; &#7893; &#7895; &#7897; &#212; &#7890; &#7888; &#7892; &#7894; &#7896; &#417; &#7901; &#7899; &#7903; &#7905; &#7907; &#416; &#7900; &#7898; &#7902; &#7904; &#7906; "
				+ "&#232; &#233; &#7867; &#7869; &#7865; &#200; &#201; &#7866; &#7868; &#7864; &#234; &#7873; &#7871; &#7875; &#7877; &#7879; &#202; &#7872; &#7870; &#7874; &#7876; &#7878; "
				+ "&#249; &#250; &#7911; &#361; &#7909; &#217; &#218; &#7910; &#360; &#7908; &#432; &#7915; &#7913; &#7917; &#7919; &#7921; &#431; &#7914; &#7912; &#7916; &#7918; &#7920; "
				+ "&#236; &#237; &#7881; &#297; &#7883; &#204; &#205; &#7880; &#296; &#7882; &#7923; &#253; &#7927; &#7929; &#7925; &#7922; &#221; &#7926; &#7928; &#7924; &#273; &#272; "
				+ "&#34; &#34; &#45; &#224; &#39; &#272; &#259; &#32; &#225;";
			var decimalUnicodes = decimalUnicode.Split(' ');

			var tcvn3 = "µ ¸ ¶ · ¹ µ ¸ ¶ · ¹ © Ç Ê È É Ë ¢ Ç Ê È É Ë ¨ » ¾ ¼ ½ Æ ¡ » ¾ ¼ ½ Æ "
				+ "ß ã á â ä ß ã á â ä « å è æ ç é ¤ å è æ ç é ¬ ê í ë ì î ¥ ê í ë ì î "
				+ "Ì Ð Î Ï Ñ Ì Ð Î Ï Ñ ª Ò Õ Ó Ô Ö £ Ò Õ Ó Ô Ö "
				+ "ï ó ñ ò ô ï ó ñ ò ô ­ õ ø ö ÷ ù ¦ õ ø ö ÷ ù "
				+ "× Ý Ø Ü Þ × Ý Ø Ü Þ ú ý û ü þ ú ý û ü þ ® § "
				+ "“ ” – ¸ ’ § ¨ &nbsp; ¸";
			var tcvn3s = tcvn3.Split(' ');

			int decodeLength;
			var result = @string.Trim();

			// convert
			switch (mode)
			{
				// UTF8 Literal to unicode
				case 0:
					decodeLength = utf8Unicodes.Length;
					for (int index = 0; index < decodeLength; index++)
						if (index < utf8Literals.Length)
							result = result.Replace(utf8Literals[index], utf8Unicodes[index]);
					break;

				// Unicode to UTF8 Literal
				case 1:
					decodeLength = utf8Literals.Length;
					for (int index = 0; index < decodeLength; index++)
						result = result.Replace(utf8Unicodes[index], utf8Literals[index]);
					break;

				// Unicode to ANSI
				case 2:
					decodeLength = utf8Unicodes.Length;
					for (int index = 0; index < decodeLength; index++)
						if (index < ansis.Length)
							result = result.Replace(utf8Unicodes[index], ansis[index]);
					break;

				// UTF8 Literal to ANSI
				case 3:
					decodeLength = utf8Literals.Length;
					for (int index = 0; index < decodeLength; index++)
						if (index < ansis.Length)
							result = result.Replace(utf8Literals[index], ansis[index]);
					break;

				// Unicode to Decimal
				case 4:
					decodeLength = utf8Unicodes.Length;
					for (int index = 0; index < decodeLength; index++)
						if (index < decimalUnicodes.Length)
							result = result.Replace(utf8Unicodes[index], decimalUnicodes[index]);
					result = result.Replace("Ð", "D");
					break;

				// Unicode Composite to ANSI
				case 5:
					decodeLength = utf8UnicodeComposites.Length;
					for (int index = 0; index < decodeLength; index++)
						if (index < ansis.Length)
							result = result.Replace(utf8UnicodeComposites[index], ansis[index]);
					result = result.Replace("Ð", "D");
					break;

				// Decimal to Unicode
				case 6:
					decodeLength = decimalUnicodes.Length;
					for (int index = 0; index < decodeLength; index++)
						if (index < utf8Unicodes.Length)
							result = result.Replace(decimalUnicodes[index], utf8Unicodes[index]);
					break;

				// TCVN3 to Unicode
				case 7:
					// first, convert to decimal
					decodeLength = tcvn3s.Length;
					for (int index = 0; index < decodeLength; index++)
						if (!tcvn3s[index].Equals("") && index < decimalUnicodes.Length)
							result = result.Replace(tcvn3s[index], decimalUnicodes[index]);
					// and then, convert from decimal to unicode
					decodeLength = decimalUnicodes.Length;
					for (int index = 0; index < decodeLength; index++)
						if (index < utf8Unicodes.Length)
							result = result.Replace(decimalUnicodes[index], utf8Unicodes[index]);
					break;

				// Unicode to Composite Unicode
				case 8:
					decodeLength = utf8Unicodes.Length;
					for (int index = 0; index < decodeLength; index++)
						if (index < utf8UnicodeComposites.Length)
							result = result.Replace(utf8Unicodes[index], utf8UnicodeComposites[index]);
					break;

				// Composite Unicode to Unicode
				case 9:
					decodeLength = utf8UnicodeComposites.Length;
					for (int index = 0; index < decodeLength; index++)
						if (index < utf8Unicodes.Length)
							result = result.Replace(utf8UnicodeComposites[index], utf8Unicodes[index]);
					break;

				default:
					break;
			}

			return result.Replace("&nbsp;", " ");
		}

		/// <summary>
		/// Converts this Vietnamese string from UTF8 to Unicode
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		public static string ConvertUTF8ToUnicode(this string @string)
			=> @string.ConvertVietnamese(0);

		/// <summary>
		/// Converts this Vietnamese string from Unicode to UTF8
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		public static string ConvertUnicodeToUTF8(this string @string)
			=> @string.ConvertVietnamese(1);

		/// <summary>
		/// Converts this Vietnamese string from Unicode to ANSI
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		public static string ConvertUnicodeToANSI(this string @string)
			=> @string.ConvertVietnamese(2).ConvertVietnamese(5);

		/// <summary>
		/// Converts this Vietnamese string from Unicode to Decimal
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		public static string ConvertUnicodeToDecimal(this string @string)
			=> @string.ConvertVietnamese(4);

		/// <summary>
		/// Converts this Vietnamese string from Decimal to Unicode
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		public static string ConvertDecimalToUnicode(this string @string)
			=> @string.ConvertVietnamese(6);

		/// <summary>
		/// Converts this Vietnamese string from TCVN3 to Unicode
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		public static string ConvertTCVN3ToUnicode(this string @string)
			=> @string.ConvertVietnamese(7);

		/// <summary>
		/// Converts this Vietnamese string from Pre-composed Unicode to Composite Unicode
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		public static string ConvertUnicodeToCompositeUnicode(this string @string)
			=> @string.ConvertVietnamese(8);

		/// <summary>
		/// Converts this Vietnamese string from Composite Unicode to Pre-composed Unicode
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		public static string ConvertCompositeUnicodeToUnicode(this string @string)
			=> @string.ConvertVietnamese(9);
		#endregion

		#region  Conversions (Uri)
		static Regex URICharacters { get; } = new Regex("[^a-zA-Z0-9_-]+");

		static Regex URICharactersWithDot { get; } = new Regex("[^a-zA-Z0-9._-]+");

		/// <summary>
		/// Generates the ANSI uri from this string (means remove all white spaces and special characters)
		/// </summary>
		/// <param name="string"></param>
		/// <param name="toLowerCase">true to return lower case</param>
		/// <param name="allowDotSymbols">true to allow dot symbols (.)</param>
		/// <param name="allowEmpty">true to allow empty (default is false - will be updated as a random value)</param>
		/// <param name="normalizeNumeric">true to normalize numberic</param>
		/// <param name="normalizeNumericGUID">true to normalize numberic GUID</param>
		/// <returns></returns>
		public static string GetANSIUri(this string @string, bool toLowerCase = true, bool allowDotSymbols = false, bool allowEmpty = false, bool normalizeNumeric = true, bool normalizeNumericGUID = false)
		{
			// convert Vietnamese characters
			var result = @string.Trim().ConvertUnicodeToANSI();

			// remove all special characters
			result = result.Replace(StringComparison.OrdinalIgnoreCase, "C#", "CSharp").Replace(StringComparison.OrdinalIgnoreCase, "F#", "FSharp").Replace(StringComparison.OrdinalIgnoreCase, "Q#", "QSharp").Replace(" ", "-");
			result = allowDotSymbols
				? StringService.URICharactersWithDot.Replace(result, "")
				: StringService.URICharacters.Replace(result, "");

			// remove duplicate characters
			while (result.Contains("--"))
				result = result.Replace("--", "-");
			while (result.Contains("__"))
				result = result.Replace("__", "_");

			// normalize first & last characters
			while (result.StartsWith("-") || result.StartsWith("_"))
				result = result.Right(result.Length - 1);
			while (result.EndsWith("-") || result.EndsWith("_"))
				result = result.Left(result.Length - 1);

			// add timestamp if has no value
			if (result.Equals("") && !allowEmpty)
				result = $"v{DateTime.Now.ToUnixTimestamp()}";

			// numeric
			else if (result.IsNumeric() && normalizeNumeric)
			{
				var normalize = !result.IsValidUUID() || normalizeNumericGUID;
				result = (normalize ? $"v{DateTime.Now.ToUnixTimestamp()}" : "") + result;
			}

			return toLowerCase
				? result.ToLower()
				: result;
		}

		/// <summary>
		/// Validate the ANSI uri
		/// </summary>
		/// <param name="ansiUri">The string that presents an ANSI uri to check</param>
		/// <param name="allowDotSymbols">true to allow dot symbols (.)</param>
		/// <returns>true if valid; otherwise false.</returns>
		public static bool IsValidANSIUri(this string ansiUri, bool allowDotSymbols = false)
			=> !string.IsNullOrWhiteSpace(ansiUri) && ansiUri.IsEquals(allowDotSymbols ? StringService.URICharactersWithDot.Replace(ansiUri, "") : StringService.URICharacters.Replace(ansiUri, ""));
		#endregion

		/// <summary>
		/// Returns the unique hash code for this string
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		/// <exception cref="ArgumentNullException"></exception>
		unsafe public static int GetUniqueHash(this string @string)
		{
			if (@string == null)
				throw new ArgumentNullException(nameof(@string));
			const uint M = 0x5bd1e995;
			const int R = 24;
			int length = @string.Length * 2;
			uint seed = (uint)(0xdeadbeef * length);
			uint hash = seed ^ (uint)length;
			fixed (char* c = @string)
			{
				byte* data = (byte*)c;
				int count = length >> 2;
				uint* ptr = (uint*)data;
				while (count-- > 0)
				{
					uint k = *ptr++;
					k *= M;
					k ^= k >> R;
					k *= M;
					hash *= M;
					hash ^= k;
				}
				byte* tail = (byte*)ptr;
				switch (length & 3)
				{
					case 3:
						hash ^= (uint)(tail[2] << 16);
						goto case 2;
					case 2:
						hash ^= (uint)(tail[1] << 8);
						goto case 1;
					case 1:
						hash ^= tail[0];
						hash *= M;
						break;
				}
			}
			hash ^= hash >> 13;
			hash *= M;
			hash ^= hash >> 15;
			return (int)(hash & 0x7fffffff);
		}

	}
}