using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using ZLPlugin_LisPacs_MR.Domain.Units;
namespace ZLPlugin_LisPacs_MR.Domain.Encript
{
    internal class AES
    {
        /// <summary>
        /// AES解密
        /// </summary>
        /// <param name="str">解密报文内容</param>
        /// <param name="key">加密密钥</param>
        /// <param name="reval">解密结果</param>
        /// <returns>是否成功</returns>
        public bool Decrypt(string str, string key, ref string reval)
        {
            try
            {
                var _keyByte = Encoding.UTF8.GetBytes(key);
                var _valueByte = Convert.FromBase64String(str);
                using (var aes = new RijndaelManaged())
                {
                    //aes.IV = !string.IsNullOrEmpty(iv) ? Convert.FromBase64String(iv) : Convert.FromBase64String(key);
                    aes.IV = Encoding.UTF8.GetBytes(key);
                    aes.BlockSize = 128;
                    aes.KeySize = 128;
                    aes.Key = _keyByte;
                    aes.Mode = CipherMode.CBC;
                    aes.Padding = PaddingMode.PKCS7;
                    var cryptoTransform = aes.CreateDecryptor();
                    var resultArray = cryptoTransform.TransformFinalBlock(_valueByte, 0, _valueByte.Length);
                    reval = Encoding.UTF8.GetString(resultArray);
                    return true;
                }
            }
            catch (Exception ex) { Log.Info(ex.Message); reval = ex.Message; return false; }
        }

        /// <summary>
        /// AES加密
        /// </summary>
        /// <param name="str">加密报文内容</param>
        /// <param name="key">加密密钥</param>
        /// <param name="reval">加密结果</param>
        /// <returns>是否成功</returns>
        public bool Encrypt(string str, string key, ref string reval)
        {
            try
            {
                var _keyByte = Encoding.UTF8.GetBytes(key);
                var _valueByte = Encoding.UTF8.GetBytes(str);
                using (var aes = new RijndaelManaged())
                {
                    //aes.IV = !string.IsNullOrEmpty(iv) ? Convert.FromBase64String(iv) : Convert.FromBase64String(key);
                    aes.IV = Encoding.UTF8.GetBytes(key);
                    aes.BlockSize = 128;
                    aes.KeySize = 128;
                    aes.Key = _keyByte;
                    aes.Mode = CipherMode.CBC;
                    aes.Padding = PaddingMode.PKCS7;
                    var cryptoTransform = aes.CreateEncryptor();
                    var resultArray = cryptoTransform.TransformFinalBlock(_valueByte, 0, _valueByte.Length);
                    reval = Convert.ToBase64String(resultArray);
                    return true;
                }
            }
            catch (Exception ex) { Log.Info(ex.Message); reval = ex.Message; return false; }
        }


        /// <summary>
        /// AES解密
        /// </summary>
        /// <param name="Data">被解密的密文</param>
        /// <param name="Key">密钥</param>
        /// <param name="Vector">向量</param>
        /// <returns>明文</returns>
        public static String AESDecrypt(String Data, String Key, String Vector, String mode = "ECB", String padding = "PKCS7")
        {
            if (string.IsNullOrEmpty(Vector))
                Vector = Key;
            //yte[] encryptedBytes = Encoding.UTF8.GetBytes(Data);
            Byte[] encryptedBytes = Convert.FromBase64String(Data);
            Byte[] bKey = new Byte[32];
            Array.Copy(Encoding.UTF8.GetBytes(Key.PadRight(bKey.Length)), bKey, bKey.Length);
            Byte[] bVector = new Byte[16];
            Array.Copy(Encoding.UTF8.GetBytes(Vector.PadRight(bVector.Length)), bVector, bVector.Length);
            Byte[] original = null; // 解密后的明文​
            Rijndael Aes = Rijndael.Create();
            switch (mode.ToUpper())
            {
                case "CBC": Aes.Mode = CipherMode.CBC; break;
                case "CFB": Aes.Mode = CipherMode.CFB; break;
                case "CTS": Aes.Mode = CipherMode.CTS; break;
                case "ECB": Aes.Mode = CipherMode.ECB; break;
                case "OFB": Aes.Mode = CipherMode.OFB; break;
                default: Aes.Mode = CipherMode.CBC; break;
            }
            switch (padding.ToUpper())
            {
                case "PKCS7": Aes.Padding = PaddingMode.PKCS7; break;
                case "NONE": Aes.Padding = PaddingMode.None; break;
                case "ANSIX923": Aes.Padding = PaddingMode.ANSIX923; break;
                case "ISO10126": Aes.Padding = PaddingMode.ISO10126; break;
                case "ZEROS": Aes.Padding = PaddingMode.Zeros; break;
                default: Aes.Padding = PaddingMode.PKCS7; break;
            }

            try
            {
                // 开辟一块内存流，存储密文
                using (MemoryStream Memory = new MemoryStream(encryptedBytes))
                {
                    // 把内存流对象包装成加密流对象
                    using (CryptoStream Decryptor = new CryptoStream(Memory,
                    Aes.CreateDecryptor(bKey, bVector),
                    CryptoStreamMode.Read))
                    {
                        // 明文存储区
                        using (MemoryStream originalMemory = new MemoryStream())
                        {
                            Byte[] Buffer = new Byte[1024];
                            Int32 readBytes = 0;
                            while ((readBytes = Decryptor.Read(Buffer, 0, Buffer.Length)) > 0)
                            {
                                originalMemory.Write(Buffer, 0, readBytes);
                            }
                            original = originalMemory.ToArray();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Info(ex.Message);
                return ex.Message;
            }
            return Encoding.UTF8.GetString(original);
        }

        /// <summary>
        /// AES加密
        /// </summary>
        /// <param name="Data">被加密的明文</param>
        /// <param name="Key">密钥</param>
        /// <param name="Vector">向量</param>
        /// <returns>密文</returns>
        public static String AESEncrypt(String Data, String Key, String Vector, String mode = "ECB", String padding = "PKCS7")
        {
            if (string.IsNullOrEmpty(Vector))
                Vector = Key;
            Byte[] plainBytes = Encoding.UTF8.GetBytes(Data);
            Byte[] bKey = new Byte[32];
            Array.Copy(Encoding.UTF8.GetBytes(Key.PadRight(bKey.Length)), bKey, bKey.Length);
            Byte[] bVector = new Byte[16];
            Array.Copy(Encoding.UTF8.GetBytes(Vector.PadRight(bVector.Length)), bVector, bVector.Length);
            Byte[] Cryptograph = null; // 加密后的密文
            Rijndael Aes = Rijndael.Create();

            switch (mode.ToUpper())
            {
                case "CBC": Aes.Mode = CipherMode.CBC; break;
                case "CFB": Aes.Mode = CipherMode.CFB; break;
                case "CTS": Aes.Mode = CipherMode.CTS; break;
                case "ECB": Aes.Mode = CipherMode.ECB; break;
                case "OFB": Aes.Mode = CipherMode.OFB; break;
                default: Aes.Mode = CipherMode.CBC; break;
            }
            switch (padding.ToUpper())
            {
                case "PKCS7": Aes.Padding = PaddingMode.PKCS7; break;
                case "NONE": Aes.Padding = PaddingMode.None; break;
                case "ANSIX923": Aes.Padding = PaddingMode.ANSIX923; break;
                case "ISO10126": Aes.Padding = PaddingMode.ISO10126; break;
                case "ZEROS": Aes.Padding = PaddingMode.Zeros; break;
                default: Aes.Padding = PaddingMode.PKCS7; break;
            }
            try
            {
                // 开辟一块内存流
                using (MemoryStream Memory = new MemoryStream())
                {
                    // 把内存流对象包装成加密流对象
                    using (CryptoStream Encryptor = new CryptoStream(Memory,
                    Aes.CreateEncryptor(bKey, bVector),
                    CryptoStreamMode.Write))
                    {
                        // 明文数据写入加密流
                        Encryptor.Write(plainBytes, 0, plainBytes.Length);
                        Encryptor.FlushFinalBlock();
                        Cryptograph = Memory.ToArray();
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Info(ex.Message);
                return ex.Message;
            }
            return Convert.ToBase64String(Cryptograph);
            //return Encoding.UTF8.GetString(Cryptograph);
        }
    }
}