using Serilog;
using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;

namespace Wood.Util
{
	public class CryptogramHelper
	{
		private static readonly string DESKey = "*change*"; // 8位或者16位
		private static readonly string DESIv = "1change1"; // 8位或者16位

		private static readonly string AESKey = "12345dontusethis"; // 16位或者32位
		private static readonly string AESIv = "youshouldchange!"; // 16位或者32位

		private static readonly string GMPublickey = "MIIBMzCB7AYHKoZIzj0CATCB4AIBATAsBgcqhkjOPQEBAiEA/////v////////////////////8AAAAA//////////8wRAQg/////v////////////////////8AAAAA//////////wEICjp+p6dn140TVqeS89lCafzl4n1FauPkt28vUFNlA6TBEEEMsSuLB8ZgRlfmQRGajnJlI/jC7/yZgvhcVpFiTNMdMe8Nzai9PZ3nFm9zuNraSFT0KmHfMYqR0AC3zLlITnwoAIhAP////7///////////////9yA99rIcYFK1O79Ak51UEjAgEBA0IABKB1MH2tvhV3AlUIadEiWVQUgILQD3gdRE+ywo44geyAJyxIfbxEsVyhTrTX4eg1QBjgfpWZW4RRBNSeU71lsmo=";


		private static readonly string GMPrivatekey = "MIICSwIBADCB7AYHKoZIzj0CATCB4AIBATAsBgcqhkjOPQEBAiEA/////v////////////////////8AAAAA//////////8wRAQg/////v////////////////////8AAAAA//////////wEICjp+p6dn140TVqeS89lCafzl4n1FauPkt28vUFNlA6TBEEEMsSuLB8ZgRlfmQRGajnJlI/jC7/yZgvhcVpFiTNMdMe8Nzai9PZ3nFm9zuNraSFT0KmHfMYqR0AC3zLlITnwoAIhAP////7///////////////9yA99rIcYFK1O79Ak51UEjAgEBBIIBVTCCAVECAQEEIOlD9P4tlhSw5V4EjAfuPGdFhTRdMZzkoVSeVGmOiuBMoIHjMIHgAgEBMCwGByqGSM49AQECIQD////+/////////////////////wAAAAD//////////zBEBCD////+/////////////////////wAAAAD//////////AQgKOn6np2fXjRNWp5Lz2UJp/OXifUVq4+S3by9QU2UDpMEQQQyxK4sHxmBGV+ZBEZqOcmUj+MLv/JmC+FxWkWJM0x0x7w3NqL09necWb3O42tpIVPQqYd8xipHQALfMuUhOfCgAiEA/////v///////////////3ID32shxgUrU7v0CTnVQSMCAQGhRANCAASgdTB9rb4VdwJVCGnRIllUFICC0A94HURPssKOOIHsgCcsSH28RLFcoU601+HoNUAY4H6VmVuEUQTUnlO9ZbJq";

		private static readonly GmCrypto GM = new GmCrypto(GMPublickey, GMPrivatekey);

		/// <summary>
		/// MD5 哈希
		/// </summary>
		public static byte[] MD5Hash(string input)
		{
			using (MD5 md5 = MD5.Create())
			{
				byte[] inputBytes = Encoding.UTF8.GetBytes(input);
				byte[] hashBytes = md5.ComputeHash(inputBytes);
				return hashBytes;
			}
		}

		/// <summary>
		/// MD5 哈希
		/// </summary>
		public static string MD5HashToHex(string input, int bit = 32)
		{
			byte[] byteArr = MD5Hash(input);
			string result = EncodingHelper.ByteArrToHexDefault(byteArr);
			if (bit == 16)
			{
				return result.Substring(8, 16).ToUpper();
			}
			else
			{
				return result.ToUpper();
			}
		}

		public static byte[]? AESEncrypt(string input, string key = "", string iv = "")
		{
			if (string.IsNullOrEmpty(key))
			{
				key = AESKey;
			}
			if (string.IsNullOrEmpty(iv))
			{
				iv = AESIv;
			}
			try
			{
				var encoding = new ASCIIEncoding();
				var keyByte = encoding.GetBytes(key);
				var ivByte = encoding.GetBytes(iv);
				using (var aesAlg = Aes.Create())
				{
					using (var encryptor = aesAlg.CreateEncryptor(keyByte, ivByte))
					{
						using (var msEncrypt = new MemoryStream())
						{
							using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))

							using (var swEncrypt = new StreamWriter(csEncrypt))
							{
								swEncrypt.Write(input);
							}
							return msEncrypt.ToArray();
						}
					}
				}
			}
			catch (Exception ex)
			{
				Log.Error(ex, "AESEncrypt加密失败：input({input})，key({key}),iv(iv)", input, key, iv);
			}
			return null;
		}

		public static string AESEncryptToBase64(string input, string key = "", string iv = "")
		{
			byte[]? byteArr = AESEncrypt(input, key, iv);
			if (byteArr != null)
			{
				return Convert.ToBase64String(byteArr);
			}
			return string.Empty;
		}

		public static string AESEncryptToHex(string input, string key = "", string iv = "")
		{
			byte[]? byteArr = AESEncrypt(input, key, iv);
			if (byteArr != null)
			{
				return EncodingHelper.ByteArrToHexDefault(byteArr);
			}
			return string.Empty;
		}

		public static string AESDecrypt(byte[] byteArr, string key = "", string iv = "")
		{
			if (string.IsNullOrEmpty(key))
			{
				key = AESKey;
			}
			if (string.IsNullOrEmpty(iv))
			{
				iv = AESIv;
			}
			try
			{
				var encoding = new ASCIIEncoding();
				var keyByte = encoding.GetBytes(key);
				var ivByte = encoding.GetBytes(iv);
				using (var aesAlg = Aes.Create())
				{
					using (var decryptor = aesAlg.CreateDecryptor(keyByte, ivByte))
					{
						string result;
						using (var msDecrypt = new MemoryStream(byteArr))
						{
							using (var csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
							{
								using (var srDecrypt = new StreamReader(csDecrypt))
								{
									result = srDecrypt.ReadToEnd();
								}
							}
						}
						return result;
					}
				}
			}
			catch (Exception ex)
			{
				Log.Error(ex, "AESDecrypt解密失败：byteArr({byteArr})，key({key}),iv(iv)", Convert.ToBase64String(byteArr), key, iv);
			}
			return string.Empty;
		}

		public static string AESDecryptFromBase64(string cipherText, string key = "", string iv = "")
		{
			var byteArr = Convert.FromBase64String(cipherText);
			return AESDecrypt(byteArr, key, iv);
		}

		public static string AESDecryptFromHex(string cipherText, string key = "", string iv = "")
		{
			var byteArr = EncodingHelper.HexToByteArrDefault(cipherText);
			return AESDecrypt(byteArr, key, iv);
		}

		public static byte[]? DESEncrypt(string input, string key = "", string iv = "")
		{
			if (string.IsNullOrEmpty(key))
			{
				key = DESKey;
			}
			if (string.IsNullOrEmpty(iv))
			{
				iv = DESIv;
			}
			try
			{
				using (Aes aesAlg = Aes.Create())
				{
					// 设置密钥和初始化向量
					aesAlg.Key = Encoding.UTF8.GetBytes(key);
					aesAlg.IV = Encoding.UTF8.GetBytes(iv);

					// 创建加密器
					ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

					// 加密数据
					using (MemoryStream msEncrypt = new MemoryStream())
					{
						using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
						{
							using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
							{
								// 写入所有数据到流中
								swEncrypt.Write(input);
							}
							return msEncrypt.ToArray();
						}
					}
				}
			}
			catch (Exception ex)
			{
				Log.Error(ex, "DESEncrypt加密失败：byteArr({input})，key({key}),iv(iv)", input, key, iv);
			}
			return null;
		}

		public static string DESEncryptToBase64(string input, string key = "", string iv = "")
		{
			byte[]? byteArr = DESEncrypt(input, key, iv);
			if (byteArr != null)
			{
				return Convert.ToBase64String(byteArr);
			}
			return string.Empty;
		}

		public static string DESEncryptToHex(string input, string key = "", string iv = "")
		{
			byte[]? byteArr = DESEncrypt(input, key, iv);
			if (byteArr != null)
			{
				return EncodingHelper.ByteArrToHexDefault(byteArr);
			}
			return string.Empty;
		}

		public static byte[]? DESDecrypt(byte[] byteArr, string key = "", string iv = "")
		{
			if (string.IsNullOrEmpty(key))
			{
				key = DESKey;
			}
			if (string.IsNullOrEmpty(iv))
			{
				iv = DESIv;
			}
			try
			{
				using (Aes aesAlg = Aes.Create())
				{
					// 设置密钥和初始化向量
					aesAlg.Key = Encoding.UTF8.GetBytes(key);
					aesAlg.IV = Encoding.UTF8.GetBytes(iv);

					// 创建解密器
					ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);

					// 解密数据
					using (MemoryStream msDecrypt = new MemoryStream(byteArr))
					{
						using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
						{
							using (MemoryStream output = new MemoryStream())
							{
								csDecrypt.CopyTo(output);
								return output.ToArray();
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				Log.Error(ex, "DESDecrypt解密失败：byteArr({byteArr})，key({key}),iv(iv)", Convert.ToBase64String(byteArr), key, iv);
			}
			return null;
		}

		public static string DESDecryptFromBase64(string cipherText, string key = "", string iv = "")
		{
			var byteArr = Convert.FromBase64String(cipherText);
			var result = DESDecrypt(byteArr, key, iv);
			if (result != null)
			{
				return Encoding.UTF8.GetString(result);
			}
			return string.Empty;
		}

		public static string DESDecryptFromHex(string cipherText, string key = "", string iv = "")
		{
			var byteArr = EncodingHelper.HexToByteArrDefault(cipherText);
			var result = DESDecrypt(byteArr, key, iv);
			if (result != null)
			{
				return Encoding.UTF8.GetString(result);
			}
			return string.Empty;
		}

		/// <summary>
		/// HMAC 256 哈希
		/// </summary>
		public static byte[] HMAC_SHA256(string encrypt, string key = "")
		{
			if (string.IsNullOrEmpty(key))
			{
				key = DESKey;
			}
			var encoding = new ASCIIEncoding();
			byte[] keyByte = encoding.GetBytes(key);
			byte[] encryptByte = encoding.GetBytes(encrypt);
			using (var hmacsha256 = new HMACSHA256(keyByte))
			{
				return hmacsha256.ComputeHash(encryptByte);
			}
		}

		/// <summary>
		/// HMAC 256 哈希
		/// </summary>
		public static string HMAC_SHA256ToHex(string encrypt, string key = "")
		{
			byte[] hash = HMAC_SHA256(encrypt, key);
			return EncodingHelper.ByteArrToHexDefault(hash);
		}

		/// <summary>
		/// 国密 SM2 加密
		/// Key值在CryptogramHelper中设置
		/// Key值GmCrypto中生成
		/// </summary>
		public static string GMSM2Encrypt(string data)
		{
			return Convert.ToBase64String(GM.EncryptSm2(data));
		}

		/// <summary>
		/// 国密 SM2 解密
		/// Key值在 CryptogramHelper 中设置
		/// Key值 GmCrypto 中生成 （需保存）
		/// </summary>
		public static string GMSM2Decrypt(string data)
		{
			var bytes = Convert.FromBase64String(data);
			return GM.DecryptSm2(bytes);
		}

		/// <summary>
		/// 国密 SM3 哈希
		/// </summary>
		public static string GMSM3Hash(string data)
		{
			return GM.HashSm3(data);
		}

		/// <summary>
		/// 国密 SM4 加密
		/// 默认Key值在 GmCrypto 中设置
		/// 设置 key iv 后不会使用默认值
		/// </summary>
		public static string GMSM4Encrypt(string data, string? key = null, string? iv = null)
		{
			return Convert.ToBase64String(GM.EncryptSM4(data, key, iv));
		}
		/// <summary>
		/// 国密 SM4 解密
		/// 默认Key值在 GmCrypto 中设置
		/// 设置 key iv 后不会使用默认值
		/// </summary>
		public static string GMSM4Decrypt(string data, string? key = null, string? iv = null)
		{
			var bytes = Convert.FromBase64String(data);
			return Encoding.UTF8.GetString(GM.DecryptSM4(bytes, key, iv));
		}

		/// <summary>
		/// 生成一个指定长度的随机字符串，包含大小写字母、数字、运算符号、括号和斜杠
		/// </summary>
		/// <param name="length">随机字符串的长度</param>
		/// <returns>生成的随机字符串</returns>
		public static string GenerateRandomString(int length)
		{
			// 定义可用字符集
			const string validChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-*/()[]{}|\\<>?:;.,=!@#$%^&~`_";

			// 使用 RNGCryptoServiceProvider 提供高随机性的随机数生成器
			using (RandomNumberGenerator rng = RandomNumberGenerator.Create())
			{
				// 创建一个字节数组来存储随机字节
				byte[] data = new byte[length];
				rng.GetBytes(data);

				// 使用 StringBuilder 提高性能
				StringBuilder sb = new StringBuilder(length);

				// 循环生成每个字符
				foreach (byte b in data)
				{
					// 将字节映射到有效字符集中
					char c = validChars[b % validChars.Length];
					sb.Append(c);
				}

				// 返回生成的随机字符串
				return sb.ToString();
			}
		}

	}
}