Encoding.cs

#region Related components
using System;
using System.IO;
using System.Net;
using System.Text;
using System.Linq;
using System.Buffers;
using System.Numerics;
using System.Globalization;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using System.Runtime.InteropServices;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
#endregion

namespace net.vieapps.Components.Utility
{
	/// <summary>
	/// Static servicing methods for working with encoding
	/// </summary>
	public static partial class EncodingService
	{

		static EncodingService()
		{
			for (byte @byte = 0; @byte < 255; @byte++)
				EncodingService.HexToByte[EncodingService.ByteToHex[@byte]] = @byte;
			EncodingService.HexToByte["ff"] = 255;
		}

		static string[] ByteToHex { get; } = 
		{
			"00", "01", "02", "03", "04", "05", "06", "07",
			"08", "09", "0a", "0b", "0c", "0d", "0e", "0f",
			"10", "11", "12", "13", "14", "15", "16", "17",
			"18", "19", "1a", "1b", "1c", "1d", "1e", "1f",
			"20", "21", "22", "23", "24", "25", "26", "27",
			"28", "29", "2a", "2b", "2c", "2d", "2e", "2f",
			"30", "31", "32", "33", "34", "35", "36", "37",
			"38", "39", "3a", "3b", "3c", "3d", "3e", "3f",
			"40", "41", "42", "43", "44", "45", "46", "47",
			"48", "49", "4a", "4b", "4c", "4d", "4e", "4f",
			"50", "51", "52", "53", "54", "55", "56", "57",
			"58", "59", "5a", "5b", "5c", "5d", "5e", "5f",
			"60", "61", "62", "63", "64", "65", "66", "67",
			"68", "69", "6a", "6b", "6c", "6d", "6e", "6f",
			"70", "71", "72", "73", "74", "75", "76", "77",
			"78", "79", "7a", "7b", "7c", "7d", "7e", "7f",
			"80", "81", "82", "83", "84", "85", "86", "87",
			"88", "89", "8a", "8b", "8c", "8d", "8e", "8f",
			"90", "91", "92", "93", "94", "95", "96", "97",
			"98", "99", "9a", "9b", "9c", "9d", "9e", "9f",
			"a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
			"a8", "a9", "aa", "ab", "ac", "ad", "ae", "af",
			"b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7",
			"b8", "b9", "ba", "bb", "bc", "bd", "be", "bf",
			"c0", "c1", "c2", "c3", "c4", "c5", "c6", "c7",
			"c8", "c9", "ca", "cb", "cc", "cd", "ce", "cf",
			"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
			"d8", "d9", "da", "db", "dc", "dd", "de", "df",
			"e0", "e1", "e2", "e3", "e4", "e5", "e6", "e7",
			"e8", "e9", "ea", "eb", "ec", "ed", "ee", "ef",
			"f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
			"f8", "f9", "fa", "fb", "fc", "fd", "fe", "ff"
		};

		static Dictionary<string, byte> HexToByte { get; } = new Dictionary<string, byte>(StringComparer.OrdinalIgnoreCase);

		#region To Bytes
		/// <summary>
		/// Converts this read-only memory to array of bytes
		/// </summary>
		/// <param name="bytes"></param>
		/// <returns></returns>
		public static byte[] ToBytes<T>(this ReadOnlyMemory<T> bytes) where T : struct
			=> typeof(T) == typeof(byte)
				? MemoryMarshal.TryGetArray(bytes, out ArraySegment<T> segment) && segment.Array is byte[] array && segment.Offset == 0 && segment.Count == array.Length
					? array
					: bytes.Span.ToArray() as byte[]
				: MemoryMarshal.AsBytes(bytes.Span).ToArray();

		/// <summary>
		/// Converts this sequence of bytes to array of bytes
		/// </summary>
		/// <param name="bytes"></param>
		/// <param name="length"></param>
		/// <returns></returns>
		public static byte[] ToBytes(this ReadOnlySequence<byte> bytes, int length = 0)
		{
			length = length > 0 ? length : checked((int)bytes.Length);
			var buffer = new byte[length];
			bytes.CopyTo(buffer);
			return buffer;
		}

		/// <summary>
		/// Converts this array segment of bytes to array of bytes
		/// </summary>
		/// <param name="bytes"></param>
		/// <param name="count"></param>
		/// <returns></returns>
		public static byte[] ToBytes(this ArraySegment<byte> bytes, int count = 0)
		{
			var array = bytes.Array;

			if (array == null || bytes.Count == 0)
				return Array.Empty<byte>();

			if ((uint)count > (uint)bytes.Count || count <= 0)
				count = bytes.Count;

			if (bytes.Offset == 0 && count == array.Length)
				return array;

			return new ReadOnlySpan<byte>(array, bytes.Offset, count).ToArray();
		}

		/// <summary>
		/// Converts this memory stream to array of bytes
		/// </summary>
		/// <param name="stream"></param>
		/// <returns></returns>
		public static byte[] ToBytes(this MemoryStream stream)
		{
			byte[] bytes = null;
			if (stream is Microsoft.IO.RecyclableMemoryStream recyclableMemoryStream)
			{
				var length = checked((int)recyclableMemoryStream.Length);
				if (length > 0)
					bytes = recyclableMemoryStream.GetReadOnlySequence().ToBytes(length);
			}
			else
			{
				if (stream.CanSeek)
					stream.Seek(0, SeekOrigin.Begin);
				if (stream.TryGetBuffer(out var buffer) && buffer.Array != null)
				{
					var length = checked((int)stream.Length);
					bytes = buffer.Offset == 0 && length == buffer.Array.Length
						? buffer.Array
						: new ArraySegment<byte>(buffer.Array, buffer.Offset, length).ToBytes();
				}
				bytes = bytes != null && bytes.Length > 0 ? bytes : stream.ToArray(); ;
			}
			return bytes ?? Array.Empty<byte>();
		}

		/// <summary>
		/// Converts this JSON to array of bytes
		/// </summary>
		/// <param name="object"></param>
		/// <param name="tag"></param>
		/// <param name="capacity"></param>
		/// <param name="formatting"></param>
		/// <returns></returns>
		public static byte[] ToBytes(this JToken @object, string tag = null, int capacity = 0, Formatting formatting = Formatting.None)
		{
			using (var stream = UtilityService.CreateMemoryStream(tag, capacity))
			{
				@object.WriteTo(stream, formatting);
				return stream.ToBytes();
			}
		}

		/// <summary>
		/// Converts this JSON to array of bytes
		/// </summary>
		/// <param name="object"></param>
		/// <param name="formatting"></param>
		/// <returns></returns>
		public static byte[] ToBytes(this JToken @object, Formatting formatting)
			=> @object.ToBytes(null, 0, formatting);

		/// <summary>
		/// Converts this string to array of bytes
		/// </summary>
		/// <param name="string"></param>
		/// <param name="encoding"></param>
		/// <returns></returns>
		public static byte[] ToBytes(this string @string, Encoding encoding = null)
			=> string.IsNullOrEmpty(@string)
				? Array.Empty<byte>()
				: (encoding ?? StringService.UTF8NoBOM).GetBytes(@string);

		/// <summary>
		/// Converts this boolean to array of bytes
		/// </summary>
		/// <param name="bool"></param>
		/// <returns></returns>
		public static byte[] ToBytes(this bool @bool)
			=> BitConverter.GetBytes(@bool);

		/// <summary>
		/// Converts this char to array of bytes
		/// </summary>
		/// <param name="char"></param>
		/// <returns></returns>
		public static byte[] ToBytes(this char @char)
			=> BitConverter.GetBytes(@char);

		/// <summary>
		/// Converts this byte to array of bytes
		/// </summary>
		/// <param name="byte"></param>
		/// <returns></returns>
		public static byte[] ToBytes(this byte @byte)
			=> BitConverter.GetBytes((ushort)@byte);

		/// <summary>
		/// Converts this sbyte to array of bytes
		/// </summary>
		/// <param name="sbyte"></param>
		/// <returns></returns>
		public static byte[] ToBytes(this sbyte @sbyte)
			=> BitConverter.GetBytes((short)@sbyte);

		/// <summary>
		/// Converts this short to array of bytes
		/// </summary>
		/// <param name="short"></param>
		/// <returns></returns>
		public static byte[] ToBytes(this short @short)
			=> BitConverter.GetBytes(@short);

		/// <summary>
		/// Converts this ushort to array of bytes
		/// </summary>
		/// <param name="ushort"></param>
		/// <returns></returns>
		public static byte[] ToBytes(this ushort @ushort)
			=> BitConverter.GetBytes(@ushort);

		/// <summary>
		/// Converts this int to array of bytes
		/// </summary>
		/// <param name="int"></param>
		/// <returns></returns>
		public static byte[] ToBytes(this int @int)
			=> BitConverter.GetBytes(@int);

		/// <summary>
		/// Converts this uint to array of bytes
		/// </summary>
		/// <param name="uint"></param>
		/// <returns></returns>
		public static byte[] ToBytes(this uint @uint)
			=> BitConverter.GetBytes(@uint);

		/// <summary>
		/// Converts this long to array of bytes
		/// </summary>
		/// <param name="long"></param>
		/// <returns></returns>
		public static byte[] ToBytes(this long @long)
			=> BitConverter.GetBytes(@long);

		/// <summary>
		/// Converts this ulong to array of bytes
		/// </summary>
		/// <param name="ulong"></param>
		/// <returns></returns>
		public static byte[] ToBytes(this ulong @ulong)
			=> BitConverter.GetBytes(@ulong);

		/// <summary>
		/// Converts this float to array of bytes
		/// </summary>
		/// <param name="float"></param>
		/// <returns></returns>
		public static byte[] ToBytes(this float @float)
			=> BitConverter.GetBytes(@float);

		/// <summary>
		/// Converts this double to array of bytes
		/// </summary>
		/// <param name="double"></param>
		/// <returns></returns>
		public static byte[] ToBytes(this double @double)
			=> BitConverter.GetBytes(@double);

		/// <summary>
		/// Converts this decimal to array of bytes
		/// </summary>
		/// <param name="decimal"></param>
		/// <returns></returns>
		public static byte[] ToBytes(this decimal @decimal)
		{
			var bytes = Array.Empty<byte>();
			Decimal.GetBits(@decimal).ForEach(@int => bytes = bytes.Concat(@int.ToBytes()));
			return bytes;
		}

		/// <summary>
		/// Converts this date-time to array of bytes
		/// </summary>
		/// <param name="datetime"></param>
		/// <returns></returns>
		public static byte[] ToBytes(this DateTime datetime)
			=> datetime.ToBinary().ToBytes();

		/// <summary>
		/// Converts this big-integer to array of bytes
		/// </summary>
		/// <param name="bigInt"></param>
		/// <param name="toUnsigned"></param>
		/// <returns></returns>
		public static byte[] ToBytes(this BigInteger bigInt, bool toUnsigned = false)
		{
			var bytes = bigInt.ToByteArray();
			if (toUnsigned && bytes[bytes.Length - 1] == 0x00)
				Array.Resize(ref bytes, bytes.Length - 1);
			if (BitConverter.IsLittleEndian)
				Array.Reverse(bytes, 0, bytes.Length);
			return bytes;
		}

		/// <summary>
		/// Converts this big-integer to unsigned array of bytes
		/// </summary>
		/// <param name="bigInt"></param>
		/// <returns></returns>
		public static byte[] ToUnsignedBytes(this BigInteger bigInt)
			=> bigInt.ToBytes(true);

		/// <summary>
		/// Converts this Base64 string to array of bytes
		/// </summary>
		/// <param name="string"></param>
		/// <param name="isBase64Url"></param>
		/// <returns></returns>
		public static byte[] Base64ToBytes(this string @string, bool isBase64Url = false)
		{
			var base64 = (isBase64Url ? @string?.Replace('-', '+').Replace('_', '/') : @string) ?? throw new ArgumentException("Invalid base64 string");
			if (isBase64Url)
				switch (base64.Length % 4)
				{
					case 0:
						break;
					case 2:
						base64 += "==";
						break;
					case 3:
						base64 += "=";
						break;
					default:
						throw new ArgumentException("Invalid base64url string!");
				}
			return Convert.FromBase64String(base64);
		}

		/// <summary>
		/// Converts this Base64Url string to array of bytes
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		public static byte[] Base64UrlToBytes(this string @string)
			=> string.IsNullOrEmpty(@string)
				? Array.Empty<byte>()
				: @string.Base64ToBytes(true);
		#endregion

		#region To Hex
		/// <summary>
		/// Converts this array of bytes to hexa string
		/// </summary>
		/// <param name="bytes"></param>
		/// <returns></returns>
		public static string ToHex(this byte[] bytes)
		{
			if (bytes == null || bytes.Length < 1)
				return string.Empty;
			var hex = new StringBuilder(bytes.Length * 2);
			foreach (var @byte in bytes)
				hex.Append(EncodingService.ByteToHex[@byte]);
			return hex.ToString();
		}

		/// <summary>
		/// Converts this string to hexa string
		/// </summary>
		/// <param name="string"></param>
		/// <param name="isBase64"></param>
		/// <returns></returns>
		public static string ToHex(this string @string, bool isBase64 = false)
			=> string.IsNullOrEmpty(@string)
				? string.Empty
				: (isBase64 ? @string.Base64ToBytes() : @string.ToBytes())?.ToHex();

		/// <summary>
		/// Converts this big-integer to hexa string
		/// </summary>
		/// <param name="bigInt"></param>
		/// <returns></returns>
		public static string ToHex(this BigInteger bigInt)
			=> bigInt.ToUnsignedBytes().ToHex();

		/// <summary>
		/// Converts this hexa-string to array of bytes
		/// </summary>
		/// <param name="hex"></param>
		/// <returns></returns>
		public static byte[] HexToBytes(this string hex)
		{
			hex = (hex.Length % 2 != 0 ? "0" + hex : hex).ToLower();
			var bytes = new byte[hex.Length / 2];
			for (var index = 0; index < hex.Length / 2; index++)
			{
				var key = hex.Substring(index * 2, 2);
				if (!EncodingService.HexToByte.TryGetValue(key, out var value))
					throw new ArgumentException($"Invalid hex @object => {hex}");
				bytes[index] = value;
			}
			return bytes;
		}
		#endregion

		#region Encode/Decode Base32
		/// <summary>
		/// Encodes this array of bytes to Base32 string
		/// </summary>
		/// <param name="bytes"></param>
		/// <param name="addChecksum"></param>
		/// <param name="hashAlgorithm">Name of a hash algorithm (md5, sha1, sha256, sha384, sha512, ripemd/ripemd160, blake128, blake/blake256, blake384, blake512) for working with check-sum</param>
		/// <returns></returns>
		public static string Base32Encode(this byte[] bytes, bool addChecksum = false, string hashAlgorithm = "SHA1")
		{
			if (bytes == null || bytes.Length < 1)
				throw new ArgumentException("Invalid @object for Base32 encoding", nameof(bytes));

			var data = addChecksum
				? bytes.Concat(bytes.GetCheckSum(hashAlgorithm, 2))
				: bytes;

			var base32Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
			var builder = new StringBuilder((data.Length + 7) * 8 / 5);
			int pos = 0, index = 0;
			while (pos < data.Length)
			{
				var current = data[pos];
				int digit;

				// is the current digit going to span a byte boundary?
				if (index > (8 - 5))
				{
					var next = (pos + 1) < data.Length ? data[pos + 1] : 0;
					digit = current & (0xFF >> index);
					index = (index + 5) % 8;
					digit <<= index;
					digit |= next >> (8 - index);
					pos++;
				}
				else
				{
					digit = (current >> (8 - (index + 5))) & 0x1F;
					index = (index + 5) % 8;
					if (index == 0)
						pos++;
				}
				builder.Append(base32Alphabet[digit]);
			}
			return builder.ToString();
		}

		/// <summary>
		/// Decodes this Base32 string to array of bytes
		/// </summary>
		/// <param name="string"></param>
		/// <param name="verifyChecksum"></param>
		/// <param name="hashAlgorithm">Name of a hash algorithm (md5, sha1, sha256, sha384, sha512, ripemd/ripemd160, blake128, blake/blake256, blake384, blake512) for working with check-sum</param>
		/// <returns></returns>
		public static byte[] Base32Decode(this string @string, bool verifyChecksum = false, string hashAlgorithm = "SHA1")
		{
			if (string.IsNullOrWhiteSpace(@string))
				throw new ArgumentException("Invalid @object for Base32 encoding", nameof(@string));

			var base32 = @string.ToUpperInvariant();
			var bytes = new byte[base32.Length * 5 / 8];
			if (bytes.Length == 0)
				throw new ArgumentException("The specified string is not valid Base32 format because it doesn't have enough @object to construct a complete byte array");

			var pos = 0;
			var subPos = 0;
			var outputPos = 0;
			var outputSubPos = 0;
			var base32Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";

			while (outputPos < bytes.Length)
			{
				var current = base32Alphabet.IndexOf(base32[pos]);
				if (current < 0)
					throw new FormatException($"Invalid Base32 character \"{@string[pos]}\" at position {pos}");

				var bits = Math.Min(5 - subPos, 8 - outputSubPos);
				bytes[outputPos] <<= bits;
				bytes[outputPos] |= (byte)(current >> (5 - (subPos + bits)));
				outputSubPos += bits;

				if (outputSubPos >= 8)
				{
					outputPos++;
					outputSubPos = 0;
				}

				subPos += bits;
				if (subPos >= 5)
				{
					pos++;
					subPos = 0;
				}
			}

			// verify with check-sum
			if (verifyChecksum)
			{
				var givenChecksum = bytes.Take(bytes.Length - 2);
				bytes = bytes.Take(0, bytes.Length - 2);
				var correctChecksum = bytes.GetCheckSum(hashAlgorithm, 2);
				if (!givenChecksum.SequenceEqual(correctChecksum))
					throw new ArgumentException("Invalid checksum (base32 decode)", nameof(@string));
			}
			return bytes;
		}

		/// <summary>
		/// Converts this array of bytes to Base32 string
		/// </summary>
		/// <param name="bytes"></param>
		/// <param name="addChecksum"></param>
		/// <param name="hashAlgorithm">Name of a hash algorithm (md5, sha1, sha256, sha384, sha512, ripemd/ripemd160, blake128, blake/blake256, blake384, blake512) for working with check-sum</param>
		/// <returns></returns>
		public static string ToBase32(this byte[] bytes, bool addChecksum = false, string hashAlgorithm = "SHA1")
			=> bytes == null || bytes.Length < 1
				? string.Empty
				: bytes.Base32Encode(addChecksum, hashAlgorithm);

		/// <summary>
		/// Converts this string to Base32 string
		/// </summary>
		/// <param name="string"></param>
		/// <param name="addChecksum"></param>
		/// <param name="hashAlgorithm">Name of a hash algorithm (md5, sha1, sha256, sha384, sha512, ripemd/ripemd160, blake128, blake/blake256, blake384, blake512) for working with check-sum</param>
		/// <returns></returns>
		public static string ToBase32(this string @string, bool addChecksum = false, string hashAlgorithm = "SHA1")
			=> string.IsNullOrEmpty(@string)
			? string.Empty
			: @string.ToBytes().ToBase32(addChecksum, hashAlgorithm);

		/// <summary>
		/// Converts this Base32 string to plain string
		/// </summary>
		/// <param name="string"></param>
		/// <param name="verifyChecksum"></param>
		/// <param name="hashAlgorithm">Name of a hash algorithm (md5, sha1, sha256, sha384, sha512, ripemd/ripemd160, blake128, blake/blake256, blake384, blake512) for working with check-sum</param>
		/// <returns></returns>
		public static string FromBase32(this string @string, bool verifyChecksum = false, string hashAlgorithm = "SHA1")
			=> string.IsNullOrEmpty(@string)
			? string.Empty
			: @string.Base32Decode(verifyChecksum, hashAlgorithm).GetString();
		#endregion

		#region Encode/Decode Base58
		/// <summary>
		/// Encodes this array of bytes to Base58 string
		/// </summary>
		/// <param name="bytes">The array of bytes to encode</param>
		/// <param name="addChecksum">true to add checksum</param>
		/// <param name="hashAlgorithm">Name of a hash algorithm (md5, sha1, sha256, sha384, sha512, ripemd/ripemd160, blake128, blake/blake256, blake384, blake512) for working with check-sum</param>
		/// <returns></returns>
		public static string Base58Encode(this byte[] bytes, bool addChecksum = true, string hashAlgorithm = "SHA256")
		{
			// add prefix / surfix
			var data = bytes ?? Array.Empty<byte>();

			// add check-sum
			if (addChecksum)
				data = data.Concat(data.GetCheckSum(hashAlgorithm, 4));

			// decode byte[] to BigInteger and encode BigInteger to Base58 string
			var bigInt = data.Aggregate<byte, BigInteger>(0, (current, t) => current * 256 + t);
			var base58Alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
			var result = "";
			while (bigInt > 0)
			{
				result = base58Alphabet[(int)(bigInt % 58)] + result;
				bigInt /= 58;
			}

			// append `1` for each leading 0 byte
			for (var index = 0; index < data.Length && data[index] == 0; index++)
				result = '1' + result;

			return result;
		}

		/// <summary>
		/// Decodes this Base58 string to array of bytes
		/// </summary>
		/// <param name="string">The string to decode</param>
		/// <param name="verifyChecksum">true to verify checksum</param>
		/// <param name="hashAlgorithm">Name of a hash algorithm (md5, sha1, sha256, sha384, sha512, ripemd/ripemd160, blake128, blake/blake256, blake384, blake512) for working with check-sum</param>
		/// <returns></returns>
		public static byte[] Base58Decode(this string @string, bool verifyChecksum = true, string hashAlgorithm = "SHA256")
		{
			// decode Base58 string to BigInteger 
			var base58Alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
			var bigInt = new BigInteger(0);
			for (var index = 0; index < @string.Length; index++)
			{
				var digit = base58Alphabet.IndexOf(@string[index]);
				if (digit < 0)
					throw new FormatException($"Invalid Base58 character \"{@string[index]}\" at position {index}");
				bigInt = bigInt * 58 + digit;
			}

			// encode BigInteger to byte[] - leading zero bytes get encoded as leading `1` characters
			var zeros = Enumerable.Repeat((byte)0, @string.TakeWhile(c => c == '1').Count());
			var bytes = zeros.Concat(bigInt.ToBytes().Reverse().SkipWhile(b => b == 0)).ToArray();

			// verify with check-sum
			if (verifyChecksum)
			{
				var givenChecksum = bytes.Take(bytes.Length - 4);
				bytes = bytes.Take(0, bytes.Length - 4);
				var correctChecksum = bytes.GetCheckSum(hashAlgorithm, 4);
				if (!givenChecksum.SequenceEqual(correctChecksum))
					throw new ArgumentException("Invalid checksum", nameof(@string));
			}
			return bytes;
		}

		/// <summary>
		/// Converts this array of bytes to Base58 string
		/// </summary>
		/// <param name="bytes">The array of bytes to convert</param>
		/// <param name="addChecksum">true to add checksum</param>
		/// <param name="hashAlgorithm">Name of a hash algorithm (md5, sha1, sha256, sha384, sha512, ripemd/ripemd160, blake128, blake/blake256, blake384, blake512) for working with check-sum</param>
		/// <returns></returns>
		public static string ToBase58(this byte[] bytes, bool addChecksum = true, string hashAlgorithm = "SHA256")
			=> bytes == null || bytes.Length < 1
				? string.Empty
				: bytes.Base58Encode(addChecksum, hashAlgorithm);

		/// <summary>
		/// Converts this string to Base58 string
		/// </summary>
		/// <param name="string">The string to convert</param>
		/// <param name="addChecksum">true to add checksum</param>
		/// <param name="hashAlgorithm">Name of a hash algorithm (md5, sha1, sha256, sha384, sha512, ripemd/ripemd160, blake128, blake/blake256, blake384, blake512) for working with check-sum</param>
		/// <returns></returns>
		public static string ToBase58(this string @string, bool addChecksum = true, string hashAlgorithm = "SHA256")
			=> string.IsNullOrEmpty(@string)
				? string.Empty
				: @string.ToBytes()?.ToBase58(addChecksum, hashAlgorithm);

		/// <summary>
		/// Converts this Base58 string to plain string
		/// </summary>
		/// <param name="string">The string to convert</param>
		/// <param name="verifyChecksum">true to verify checksum</param>
		/// <param name="hashAlgorithm">Name of a hash algorithm (md5, sha1, sha256, sha384, sha512, ripemd/ripemd160, blake128, blake/blake256, blake384, blake512) for working with check-sum</param>
		/// <returns></returns>
		public static string FromBase58(this string @string, bool verifyChecksum = true, string hashAlgorithm = "SHA256")
			=> string.IsNullOrEmpty(@string)
				? string.Empty
				: @string.Base58Decode(verifyChecksum, hashAlgorithm)?.GetString();
		#endregion

		#region Encode/Decode Base64
		/// <summary>
		/// Encodes this array of bytes to base64 string
		/// </summary>
		/// <param name="bytes">The array of bytes to encode</param>
		/// <param name="addChecksum">true to add checksum</param>
		/// <param name="hashAlgorithm">Name of a hash algorithm (md5, sha1, sha256, sha384, sha512, ripemd/ripemd160, blake128, blake/blake256, blake384, blake512) for working with check-sum</param>
		/// <returns></returns>
		public static string Base64Encode(this byte[] bytes, bool addChecksum = false, string hashAlgorithm = "SHA256")
		{
			if (bytes == null || bytes.Length < 1)
				throw new ArgumentException("Invalid @object (null or empty for Base64 encoding)");
			return Convert.ToBase64String(addChecksum ? bytes.Concat(bytes.GetCheckSum(hashAlgorithm, 4)) : bytes);
		}

		/// <summary>
		/// Decodes this base64 string to array of bytes
		/// </summary>
		/// <param name="string">The string to decode</param>
		/// <param name="verifyChecksum">true to verify checksum</param>
		/// <param name="hashAlgorithm">Name of a hash algorithm (md5, sha1, sha256, sha384, sha512, ripemd/ripemd160, blake128, blake/blake256, blake384, blake512) for working with check-sum</param>
		/// <returns></returns>
		public static byte[] Base64Decode(this string @string, bool verifyChecksum = false, string hashAlgorithm = "SHA256")
		{
			var bytes = @string?.Base64ToBytes() ?? throw new ArgumentException("Invalid @object (base64 decode)", nameof(@string));
			if (verifyChecksum)
			{
				var givenChecksum = bytes.Take(bytes.Length - 4);
				bytes = bytes.Take(0, bytes.Length - 4);
				var correctChecksum = bytes.GetCheckSum(hashAlgorithm, 4);
				if (!givenChecksum.SequenceEqual(correctChecksum))
					throw new ArgumentException("Invalid checksum (base64 decode)", nameof(@string));
			}
			return bytes;
		}

		/// <summary>
		/// Converts this array of bytes to Base64 string
		/// </summary>
		/// <param name="bytes"></param>
		/// <param name="addChecksum">true to add checksum</param>
		/// <param name="hashAlgorithm">Name of a hash algorithm (md5, sha1, sha256, sha384, sha512, ripemd/ripemd160, blake128, blake/blake256, blake384, blake512) for working with check-sum</param>
		/// <returns></returns>
		public static string ToBase64(this byte[] bytes, bool addChecksum = false, string hashAlgorithm = "SHA256")
			=> bytes == null || bytes.Length < 1
				? string.Empty
				: bytes.Base64Encode(addChecksum, hashAlgorithm);

		/// <summary>
		/// Converts this string to Base64 string
		/// </summary>
		/// <param name="string"></param>
		/// <param name="isHex"></param>
		/// <param name="isBase64Url"></param>
		/// <param name="addChecksum"></param>
		/// <param name="hashAlgorithm">Name of a hash algorithm (md5, sha1, sha256, sha384, sha512, ripemd/ripemd160, blake128, blake/blake256, blake384, blake512) for working with check-sum</param>
		/// <returns></returns>
		public static string ToBase64(this string @string, bool isHex = false, bool isBase64Url = false, bool addChecksum = false, string hashAlgorithm = "SHA256")
		{
			var bytes = string.IsNullOrEmpty(@string)
				? Array.Empty<byte>()
				: (isHex
					? @string.HexToBytes()
					: isBase64Url
						? @string.Base64ToBytes(true)
						: @string.ToBytes()) ?? throw new ArgumentException("Invalid @object (base64 encode)", nameof(@string));
			return bytes.ToBase64(addChecksum, hashAlgorithm);
		}

		/// <summary>
		/// Converts this string to Base64Url string
		/// </summary>
		/// <param name="string"></param>
		/// <param name="isBase64"></param>
		/// <param name="isHex"></param>
		/// <param name="addChecksum"></param>
		/// <param name="hashAlgorithm">Name of a hash algorithm (md5, sha1, sha256, sha384, sha512, ripemd/ripemd160, blake128, blake/blake256, blake384, blake512) for working with check-sum</param>
		/// <returns></returns>
		public static string ToBase64Url(this string @string, bool isBase64 = false, bool isHex = false, bool addChecksum = false, string hashAlgorithm = "SHA256")
		{
			var base64 = (isBase64 ? @string : @string?.ToBase64(isHex, false, addChecksum, hashAlgorithm)) ?? throw new ArgumentException("Invalid @object (base64url encode)", nameof(@string));
			return base64.Split('=').First().Replace('+', '-').Replace('/', '_');
		}

		/// <summary>
		/// Converts this array of bytes to Base64Url string
		/// </summary>
		/// <param name="bytes"></param>
		/// <param name="addChecksum"></param>
		/// <param name="hashAlgorithm">Name of a hash algorithm (md5, sha1, sha256, sha384, sha512, ripemd/ripemd160, blake128, blake/blake256, blake384, blake512) for working with check-sum</param>
		/// <returns></returns>
		public static string ToBase64Url(this byte[] bytes, bool addChecksum = false, string hashAlgorithm = "SHA256")
			=> bytes == null || bytes.Length < 1
			? string.Empty
			: bytes.ToBase64(addChecksum, hashAlgorithm).ToBase64Url(true);

		/// <summary>
		/// Converts this Base64 string to plain string
		/// </summary>
		/// <param name="string"></param>
		/// <param name="isBase64Url"></param>
		/// <param name="verifyChecksum"></param>
		/// <param name="hashAlgorithm">Name of a hash algorithm (md5, sha1, sha256, sha384, sha512, ripemd/ripemd160, blake128, blake/blake256, blake384, blake512) for working with check-sum</param>
		/// <returns></returns>
		public static string FromBase64(this string @string, bool isBase64Url = false, bool verifyChecksum = false, string hashAlgorithm = "SHA256")
			=> string.IsNullOrEmpty(@string)
				? string.Empty
				: (isBase64Url ? @string.ToBase64(false, true) : @string).Base64Decode(verifyChecksum, hashAlgorithm).GetString();

		/// <summary>
		/// Converts this Base64Url string to plain string
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		public static string FromBase64Url(this string @string)
			=> string.IsNullOrEmpty(@string)
				? string.Empty
				: @string?.FromBase64(true);
		#endregion

		#region Encode/Decode by URL/HTML/ASCII
		/// <summary>
		/// Encodes this string to use in url
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		public static string UrlEncode(this string @string)
			=> string.IsNullOrWhiteSpace(@string)
				? ""
				: WebUtility.UrlEncode(@string).Replace("+", "%20").Replace(" ", "%20");

		/// <summary>
		/// Decodes this url-encoded string
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		public static string UrlDecode(this string @string)
			=> string.IsNullOrWhiteSpace(@string)
				? ""
				: WebUtility.UrlDecode(@string).Replace("+", " ").Replace("%20", " ");

		/// <summary>
		/// Encodes this string to Base64Url string
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		public static string Url64Encode(this string @string)
			=> string.IsNullOrWhiteSpace(@string)
				? ""
				: @string.ToBase64Url();

		/// <summary>
		/// Decodes this Base64Url string
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		public static string Url64Decode(this string @string)
			=> string.IsNullOrWhiteSpace(@string)
				? ""
				: @string.Base64ToBytes(true).GetString();

		/// <summary>
		/// Encodes this string to HTML string
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		public static string HtmlEncode(this string @string)
			=> string.IsNullOrWhiteSpace(@string)
				? ""
				: WebUtility.HtmlEncode(@string);

		/// <summary>
		/// Decodes this HTML string
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		public static string HtmlDecode(this string @string)
			=> string.IsNullOrWhiteSpace(@string)
				? ""
				: WebUtility.HtmlDecode(@string.Trim());

		/// <summary>
		/// Encodes this string to ASCII encoded string
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		public static string AsciiEncode(this string @string)
		{
			var builder = new StringBuilder();
			foreach (char @char in @string)
				builder.Append(@char > 127 ? "\\u" + ((int)@char).ToString("x4") : @char.ToString());
			return builder.ToString();
		}

		static Regex AsciiDecodeRegex { get; } = new Regex("\\\\u(?<Value>[a-zA-Z0-9]{4})", RegexOptions.Compiled);

		/// <summary>
		/// Decodes this ASCII encoded string
		/// </summary>
		/// <param name="string"></param>
		/// <returns></returns>
		public static string AsciiDecode(this string @string)
			=> EncodingService.AsciiDecodeRegex.Replace(@string, match => ((char)int.Parse(match.Groups["Value"].Value, NumberStyles.HexNumber)).ToString());
		#endregion

	}
}