using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
using System.IO;

namespace Developpez.Dotnet.Security.Cryptography
{
    /// <summary>
    /// DESCrypting class
    /// </summary>
    public class DESCrypting : ICrypting
    {
        #region Properties
        /// <summary>Secret key</summary>
        public byte[] RgbKey { private get; set; }
        /// <summary>Initialisation vector</summary>
        public byte[] RgbIV { private get; set; }
        #endregion

        #region Constructor
        /// <summary>
        /// DESCrypting constructor
        /// </summary>
        /// <param name="secretKey">Secret key</param>
        /// <param name="initialisationVector">Initialisation vector</param>
        public DESCrypting(string secretKey, string initialisationVector)
        {
            if (string.IsNullOrEmpty(secretKey)) throw new ArgumentNullException("The secret key cannot be null.");
            if (string.IsNullOrEmpty(initialisationVector)) throw new ArgumentNullException("The initialisation vector cannot be null.");

            RgbKey = new UnicodeEncoding().GetBytes(secretKey);

            if (RgbKey.Length != 8) throw new ArgumentException("For Single DES the key is fixed size of 8 bytes.");

            RgbIV = new UnicodeEncoding().GetBytes(initialisationVector);
        }
        #endregion

        #region Encrypting
        /// <summary>Encrypt an object by using DES encrypting</summary>
        /// <param name="objectToEncrypt">Object to encrypt</param>
        /// <returns>Encrypted text</returns>
        public string EncryptContent(object objectToEncrypt)
        {
            if (objectToEncrypt == null) return null;

            var encryptedContent = "";
            var serviceProvider = new DESCryptoServiceProvider();
            using (var msEncrypt = new MemoryStream())
            {
                using (var encryptor = serviceProvider.CreateEncryptor(RgbKey, RgbIV))
                using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                using (var swEncrypt = new StreamWriter(csEncrypt))
                    swEncrypt.Write(objectToEncrypt);
                encryptedContent = Convert.ToBase64String(msEncrypt.ToArray());
            }
            serviceProvider.Clear();
            return encryptedContent;
        }
        /// <summary>Encrypt a file and replace its content</summary>
        /// <param name="path">Path of the file</param>
        public void Encrypt(string path)
        {
            Encrypt(path, path);
        }
        /// <summary>Encrypt an non-crypted file into a new one</summary>
        /// <param name="pathInput">Path of the input file</param>
        /// <param name="pathOutput">Path of the output file</param>
        public void Encrypt(string pathInput, string pathOutput)
        {
            if (!File.Exists(pathInput)) throw new FileNotFoundException("The file " + pathInput + " cannot be found.");

            var encryptedContent = EncryptContent(File.ReadAllText(pathInput));
            File.WriteAllText(pathOutput, encryptedContent);
        }
        #endregion

        #region Decrypting
        /// <summary>
        /// Decrypt a text.
        /// Example:
        /// <code>
        /// var decrypter = new DESCrypting("abcd", "efgh");
        /// var xdocument = XDocument.Parse(decrypter.DecryptContent(File.OpenText("FilePath").ReadToEnd));
        /// </code>
        /// </summary>
        /// <param name="encryptedtext">Encrypted text</param>
        /// <returns>Decrypted text</returns>
        public string DecryptContent(string encryptedtext)
        {
            if (string.IsNullOrEmpty(encryptedtext)) return null;
            byte[] buffer;
            try
            {
                buffer = Convert.FromBase64String(encryptedtext);
            }
            catch (FormatException)
            {
                throw new ArgumentException("This is not an encrypted content.");
            }

            var decryptedContent = "";
            var serviceProvider = new DESCryptoServiceProvider();
            using (var msEncrypt = new MemoryStream(buffer))
            using (var decryptor = serviceProvider.CreateDecryptor(RgbKey, RgbIV))
            using (var csDecrypt = new CryptoStream(msEncrypt, decryptor, CryptoStreamMode.Read))
            using (var swDecrypt = new StreamReader(csDecrypt))
            {
                try
                {
                    decryptedContent = swDecrypt.ReadToEnd();
                }
                catch (CryptographicException)
                {
                    throw new CryptographicException("Invalid key or vector.");
                }
                finally
                {
                    serviceProvider.Clear();
                }
            }
            return decryptedContent;
        }
        /// <summary>Decrypt a file and replace its content</summary>
        /// <param name="path">Path of the file</param>
        public void Decrypt(string path)
        {
            Decrypt(path, path);
        }
        /// <summary>Decrypt an encrypted file into a new one</summary>
        /// <param name="pathInput">Path of the input file</param>
        /// <param name="pathOutput">Path of the output file</param>
        public void Decrypt(string pathInput, string pathOutput)
        {
            if (!File.Exists(pathInput)) throw new FileNotFoundException("The file " + pathInput + " cannot be found.");

            var decryptedContent = DecryptContent(File.ReadAllText(pathInput));
            File.WriteAllText(pathOutput, decryptedContent);
        }
        #endregion
    }
}