using System;
using System.Text;
using System.Security.Cryptography;
using System.Linq;

namespace EP.Enterprise.Security.TH
{
    /// <summary>
    /// AES256 class uses the AES algorithm with a provided 256 bit key and a random 128 bit IV to meet PCI standards
    /// The IV is randomly generated before each encryption and encoded with the final encrypted string
    /// </summary>
    
    public class AES256
    {
        // Symmetric algorithm interface is used to store the AES service provider

        private SymmetricAlgorithm AESProvider;

        /// <summary>
        /// Constructor for AES class that takes a 32 byte ( 64 hex chars ) key
        /// </summary>
        /// <param name="HexKey">(Hex string length 64)</param>

        public AES256(string HexKey)
        {
            byte[] key = HexStringToByteArray(HexKey);

            // Throw error if key is not 256 bits
            if (key.Length != 32) throw new CryptographicException("Key must be 256 bits (32 bytes)");
            // Initialize AESProvider with AES algorithm service

            AESProvider = new AesCryptoServiceProvider();
            AESProvider.KeySize = 256;

            // Set the key for AESProvider
            AESProvider.Key = key;

        }


        public string[] Encrypt(string plainText)
        {

            string[] result = new string[2];

            // Create new random IV
            AESProvider.GenerateIV();

            result[0] = Convert.ToBase64String(AESProvider.IV);



            // Initialize encryptor now that the IV is set
            ICryptoTransform encryptor = AESProvider.CreateEncryptor();

            // Convert string to bytes
            byte[] plainBytes = UTF8Encoding.UTF8.GetBytes(plainText);

            // Encrypt plain bytes
            byte[] secureBytes = encryptor.TransformFinalBlock(plainBytes, 0, plainBytes.Length);


            result[1] = Convert.ToBase64String(secureBytes);
            return result;

        }


        /// <summary>
        /// Decrypts a string with AES algorithm
        /// </summary>
        /// <param name="secureText">Encrypted string with IV prefix</param>
        /// <returns>Decrypted string</returns>
       
      
        public string Decrypt(string Msg, string IV)
        {

            // Convert encrypted string to bytes
            byte[] secureBytes = Convert.FromBase64String(Msg);

            // Take IV from beginning of secureBytes
            AESProvider.IV = Convert.FromBase64String(IV);

            // Initialize decryptor now that the IV is set
            ICryptoTransform decryptor = AESProvider.CreateDecryptor();

            // Decrypt bytes after the IV
            byte[] plainBytes = decryptor.TransformFinalBlock(secureBytes, 0, secureBytes.Length);

            return UTF8Encoding.UTF8.GetString(plainBytes);


        }

        private byte[] HexStringToByteArray(string hex)
        {
            if (hex.Length % 2 == 1)
                throw new Exception("The binary key cannot have an odd number of digits");

            byte[] arr = new byte[hex.Length >> 1];

            for (int i = 0; i < hex.Length >> 1; ++i)
            {
                arr[i] = (byte)((GetHexVal(hex[i << 1]) << 4) + (GetHexVal(hex[(i << 1) + 1])));
            }

            return arr;
        }
        private int GetHexVal(char hex)
        {
            int val = (int)hex;
            //For uppercase A-F letters: 
            return val - (val < 58 ? 48 : 55);
            //For lowercase a-f letters: 
            //return val - (val < 58 ? 48 : 87); 
            //Or the two combined, but a bit slower: 
            //return val - (val < 58 ? 48 : (val < 97 ? 55 : 87)); 
        }

    }

}

            string TextToEncrypt = "?Key=" + txtAccountCode.Text.Trim() + "|" + txtToken.Text.Trim() + "&inputs=" + txtTextToEncrypt.Text.Trim();
            string query = TextToEncrypt;
            string EncryptedParameters = "";
                                                    

            AES256 EP = new AES256(Encryption-Key);
            try
            {
                string[] encQuery = EP.Encrypt(query);
                EncryptedParameters = "m=" + encQuery[1].ToString() + "&i=" + encQuery[0].ToString();
            }
            catch (Exception ee)
            {
                MessageBox.Show(ee.Message);
                return;
            }
            
            
            string EncryptedURL = txtURL.Text + EncryptedParameters;
            txtEncryptedURL.Text = EncryptedURL + "&Eindex=300";

            int FindStart = txtEncryptedResponse.Text.Trim().IndexOf('?');
            string QryString = txtEncryptedResponse.Text.Trim().Substring(FindStart);

            NameValueCollection Items = HttpUtility.ParseQueryString(QryString);

            string m = Items["m"];
            string i = Items["i"];



            string FullQuery = "";



             AES256 EP = new AES256(Encryption-Key);

            try
            {
                /// note always replace any SPACE characters with + characters since these base 64 chars get translated over the web 
                FullQuery = EP.Decrypt(m.Replace(" ", "+"), i.Replace(" ", "+"));
            }
            catch (Exception ee)
            {
                MessageBox.Show(ee.Message);
                return;
            }