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

namespace Developpez.Dotnet.Security
{
    /// <summary>
    /// Fournit des services de protection de données
    /// </summary>
    public class DataProtectionProvider
    {
        private readonly DataProtectionScope _scope;
        private readonly Encoding _encoding;
        private readonly byte[] _entropy;

        /// <summary>
        /// Crée une instance de DataProtectionProvider avec les paramètres par
        /// défaut.
        /// </summary>
        public DataProtectionProvider() : this(default(DataProtectionScope))
        {
        }

        /// <summary>
        /// Crée une instance de DataProtectionProvider avec la portée spécifiée.
        /// </summary>
        /// <param name="scope">Portée de la protection</param>
        public DataProtectionProvider(DataProtectionScope scope)
            : this(scope, null)
        {
        }

        /// <summary>
        /// Crée une instance de DataProtectionProvider avec la portée et
        /// l'encodage spécifiés.
        /// </summary>
        /// <param name="scope">Portée de la protection</param>
        /// <param name="encoding">Encodage utilisé pour le texte</param>
        public DataProtectionProvider(DataProtectionScope scope, Encoding encoding)
            : this(scope, encoding, null)
        {
        }


        /// <summary>
        /// Crée une instance de DataProtectionProvider avec la portée,
        /// l'encodage et l'entropie spécifiés.
        /// </summary>
        /// <param name="scope">Portée de la protection</param>
        /// <param name="encoding">Encodage utilisé pour le texte</param>
        /// <param name="entropy">Entropie (optionnelle) pour augmenter la
        /// complexité du chiffrage</param>
        public DataProtectionProvider(DataProtectionScope scope, Encoding encoding, byte[] entropy)
        {
            _scope = scope;
            _entropy = entropy;
            _encoding = encoding ?? Encoding.UTF8;
        }

        /// <summary>
        /// Portée de la protection
        /// </summary>
        /// <value>
        /// Une valeur de DataProtectionScope indiquant si les données sont 
        /// protégées pour l'utilisateur courant ou pour la machine locale. La
        /// valeur par défaut est <c>CurrentUser</c>.
        /// </value>
        public DataProtectionScope Scope
        {
            get { return _scope; }
        }

        /// <summary>
        /// Encodage utilisé pour le texte
        /// </summary>
        /// <value>
        /// L'encodage utilisé pour le texte. La valeur par défaut est
        /// <c>Encoding.UTF8.</c>
        /// </value>
        public Encoding Encoding
        {
            get { return _encoding; }
        }

        /// <summary>
        /// Entropie du chiffrage
        /// </summary>
        /// <value>
        /// Un tableau d'octets qui sera combiné à la clé principale pour
        /// augmenter la complexité du chiffrage. La valeur par défaut est null.
        /// </value>
        public byte[] Entropy
        {
            get { return _entropy; }
        }

        /// <summary>
        /// Protège une chaine de caractères.
        /// </summary>
        /// <param name="s">La chaine à protéger</param>
        /// <returns>La chaine protégée, encodée en base64</returns>
        public string ProtectString(string s)
        {
            byte[] bytes = _encoding.GetBytes(s);
            byte[] protectedBytes = ProtectBytes(bytes);
            return Convert.ToBase64String(protectedBytes);
        }

        /// <summary>
        /// Déchiffre une chaine de caractères protégée.
        /// </summary>
        /// <param name="protectedString">La chaine protégée à déchiffrer</param>
        /// <returns>La chaine déchiffrée</returns>
        public string UnprotectString(string protectedString)
        {
            byte[] protectedBytes = Convert.FromBase64String(protectedString);
            byte[] bytes = UnprotectBytes(protectedBytes);
            return _encoding.GetString(bytes);
        }

        /// <summary>
        /// Protège des données binaires.
        /// </summary>
        /// <param name="bytes">Les données à protéger</param>
        /// <returns>Les données protégées</returns>
        public byte[] ProtectBytes(byte[] bytes)
        {
            return ProtectedData.Protect(bytes, _entropy, _scope);
        }

        /// <summary>
        /// Déchiffre des données binaires protégées.
        /// </summary>
        /// <param name="protectedBytes">Les données protégées à déchiffrer</param>
        /// <returns>Les données déchiffrées</returns>
        public byte[] UnprotectBytes(byte[] protectedBytes)
        {
            return ProtectedData.Unprotect(protectedBytes, _entropy, _scope);
        }
    }
}