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

namespace Neo.Afx.Security
{
    /// <summary>
    /// A utility class for working with asymmetric encryption and decryption.
    /// </summary>
    public static class RsaProvider
    {
        #region GetKeyAlgorithm

        /// <summary>
        /// Gets the RSA KeyAlgorithm for the given RSA key blob.
        /// </summary>
        /// <param name="keyBlob">A byte array that represents an RSA key blob.</param>
        /// <returns>The RSA KeyAlgorithm for the given RSA key blob.</returns>
        public static RSACryptoServiceProvider GetKeyAlgorithm(byte[] keyBlob)
        {
            var rsa = new RSACryptoServiceProvider();
            rsa.ImportCspBlob(keyBlob);
            return rsa;
        }

        /// <summary>
        /// Gets the RSA KeyAlgorithm for the given RSA key xml.
        /// </summary>
        /// <param name="keyXml">An xml string that represents an RSA key.</param>
        /// <returns>The RSA KeyAlgorithm for the given RSA key xml.</returns>
        public static RSACryptoServiceProvider GetKeyAlgorithm(string keyXml)
        {
            var rsa = new RSACryptoServiceProvider();
            var xml = XElement.Parse(keyXml);
            var parameters = new RSAParameters();
            string value;

            if((value = GetValue(xml, "Modulus")) != null)
            {
                parameters.Modulus = Convert.FromBase64String(value);
            }
            if((value = GetValue(xml, "Exponent")) != null)
            {
                parameters.Exponent = Convert.FromBase64String(value);
            }
            if((value = GetValue(xml, "P")) != null)
            {
                parameters.P = Convert.FromBase64String(value);
            }
            if((value = GetValue(xml, "Q")) != null)
            {
                parameters.Q = Convert.FromBase64String(value);
            }
            if((value = GetValue(xml, "DP")) != null)
            {
                parameters.DP = Convert.FromBase64String(value);
            }
            if((value = GetValue(xml, "DQ")) != null)
            {
                parameters.DQ = Convert.FromBase64String(value);
            }
            if((value = GetValue(xml, "InverseQ")) != null)
            {
                parameters.InverseQ = Convert.FromBase64String(value);
            }
            if((value = GetValue(xml, "D")) != null)
            {
                parameters.D = Convert.FromBase64String(value);
            }

            rsa.ImportParameters(parameters);
            return rsa;
        }


        static string GetValue(XElement parent, string name)
        {
            var element = parent.Element(name);
            return element == null ? null : element.Value;
        }

        #endregion

        #region CreateKeys

        /// <summary>
        /// Creates a public and private key pair for the RSA algorithm.
        /// </summary>
        /// <param name="publicKey">When the method returns, this contains the public key blob.</param>
        /// <param name="privateKey">When the method returns, this contains the private key blob.</param>
        /// <returns>The <see cref="RSAParameters "/> as xml.</returns>
        public static string CreateKeys(out byte[] publicKey, out byte[] privateKey)
        {
            var rsa = new RSACryptoServiceProvider();
            publicKey = rsa.ExportCspBlob(false);
            privateKey = rsa.ExportCspBlob(true);
            return ExportParameters(rsa, true);
        }

        /// <summary>
        /// Creates a public and private key pair for the RSA algorithm.
        /// </summary>
        /// <param name="publicKey">When the method returns, this contains the base64-encoded public key blob.</param>
        /// <param name="privateKey">When the method returns, this contains the base64-encoded private key blob.</param>
        /// <returns>The <see cref="RSAParameters "/> as xml.</returns>
        public static string CreateKeys(out string publicKey, out string privateKey)
        {
            byte[] publicBuffer;
            byte[] privateBuffer;

            var xml = CreateKeys(out publicBuffer, out privateBuffer);

            publicKey = Convert.ToBase64String(publicBuffer);
            privateKey = Convert.ToBase64String(privateBuffer);
            return xml;
        }

        #endregion

        #region ExportParameters

        /// <summary>
        /// Exports the parameters.
        /// </summary>
        /// <param name="rsa">The RSA cryptographic provider.</param>
        /// <param name="includePrivateParameters"><see langword="true"/> to include private parameters; otherwise, <see langword="false"/>.</param>
        /// <returns>The <see cref="RSAParameters "/> as xml.</returns>
        public static string ExportParameters(RSACryptoServiceProvider rsa, bool includePrivateParameters)
        {
            var parameters = rsa.ExportParameters(includePrivateParameters);
            var xml = new StringBuilder();
            xml.AppendLine("<?xml version=\"1.0\" encoding=\"utf-8\" ?>");
            xml.AppendLine("<RSAKeyValue>");
            xml.AppendFormat("    <Modulus>{0}</Modulus>{1}", Convert.ToBase64String(parameters.Modulus), Environment.NewLine);
            xml.AppendFormat("    <Exponent>{0}</Exponent>{1}", Convert.ToBase64String(parameters.Exponent), Environment.NewLine);
            if(includePrivateParameters)
            {
                xml.AppendFormat("    <P>{0}</P>{1}", Convert.ToBase64String(parameters.P), Environment.NewLine);
                xml.AppendFormat("    <Q>{0}</Q>{1}", Convert.ToBase64String(parameters.Q), Environment.NewLine);
                xml.AppendFormat("    <DP>{0}</DP>{1}", Convert.ToBase64String(parameters.DP), Environment.NewLine);
                xml.AppendFormat("    <DQ>{0}</DQ>{1}", Convert.ToBase64String(parameters.DQ), Environment.NewLine);
                xml.AppendFormat("    <InverseQ>{0}</InverseQ>{1}", Convert.ToBase64String(parameters.InverseQ), Environment.NewLine);
                xml.AppendFormat("    <D>{0}</D>{1}", Convert.ToBase64String(parameters.D), Environment.NewLine);
            }
            xml.AppendLine("</RSAKeyValue>");
            return xml.ToString();
        }
        #endregion

        #region Encrypt

        /// <summary>
        /// Encrypts the data with the public key.
        /// </summary>
        /// <param name="publicKey">The public key to be used.</param>
        /// <param name="data">The data to be encrypted.</param>
        /// <returns>The encrypted data.</returns>
        public static byte[] Encrypt(byte[] publicKey, byte[] data)
        {
            var rsa = GetKeyAlgorithm(publicKey);

            //OAEP padding is only available on Microsoft Windows XP or later.  
            var encryptedData = rsa.Encrypt(data, true);
            rsa.Clear();

            return encryptedData;
        }

        /// <summary>
        /// Encrypts the plain text with the public key. 
        /// </summary>
        /// <param name="publicKey">The public key to be used.</param>
        /// <param name="plainText">The plain text to be encrypted.</param>
        /// <returns>Returns the cipher of the plain text.</returns>
        public static string Encrypt(string publicKey, string plainText)
        {
            var key = Convert.FromBase64String(publicKey);
            var data = Encoding.UTF8.GetBytes(plainText);
            var encryptedData = Encrypt(key, data);

            return Convert.ToBase64String(encryptedData);
        }

        /// <summary>
        /// Encrypts the data with the public key.
        /// </summary>
        /// <param name="publicKeyXml">The public key xml to be used.</param>
        /// <param name="plainText">The plain text to be encrypted.</param>
        /// <returns>The encrypted data.</returns>
        public static string EncryptXml(string publicKeyXml, string plainText)
        {
            var rsa = GetKeyAlgorithm(publicKeyXml);
            var data = Encoding.UTF8.GetBytes(plainText);

            //OAEP padding is only available on Microsoft Windows XP or later.  
            var encryptedData = rsa.Encrypt(data, false);
            rsa.Clear();

            return Convert.ToBase64String(encryptedData);
        }

        #endregion

        #region Decrypt

        /// <summary>
        /// Decrypts the given encrypted data.
        /// </summary>
        /// <param name="privateKey">The private key to be used.</param>
        /// <param name="encryptedData">The data to be decrypted.</param>
        /// <returns>The decrypted data.</returns>
        public static byte[] Decrypt(byte[] privateKey, byte[] encryptedData)
        {
            var rsa = GetKeyAlgorithm(privateKey);

            //OAEP padding is only available on Microsoft Windows XP or later.  
            var decryptedData = rsa.Decrypt(encryptedData, true);
            rsa.Clear();

            return decryptedData;
        }

        /// <summary>
        /// Decrypts the cipher.
        /// </summary>
        /// <param name="privateKey">The private key to be used.</param>
        /// <param name="cipher">The cipher to be decrypted.</param>
        /// <returns>The plain text of the cipher.</returns>
        public static string Decrypt(string privateKey, string cipher)
        {
            var key = Convert.FromBase64String(privateKey);
            var encryptedData = Convert.FromBase64String(cipher);
            var decryptedData = Decrypt(key, encryptedData);

            return decryptedData == null ? null : Encoding.UTF8.GetString(decryptedData);
        }

        /// <summary>
        /// Decrypts the cipher.
        /// </summary>
        /// <param name="privateKeyXml">The private key xml to be used.</param>
        /// <param name="cipher">The cipher to be decrypted.</param>
        /// <returns>The plain text of the cipher.</returns>
        public static string DecryptXml(string privateKeyXml, string cipher)
        {
            var rsa = GetKeyAlgorithm(privateKeyXml);

            var encryptedData = Convert.FromBase64String(cipher);

            //OAEP padding is only available on Microsoft Windows XP or later.  
            var decryptedData = rsa.Decrypt(encryptedData, false);
            rsa.Clear();

            return decryptedData == null ? null : Encoding.UTF8.GetString(decryptedData);
        }

        #endregion


    }
}