using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.ComponentModel;
using Developpez.Dotnet.Collections;

namespace Developpez.Dotnet
{
    /// <summary>
    /// Fournit des méthodes d'extension pour manipuler les énumérations
    /// </summary>
    public static class EnumExtensions
    {
        /// <summary>
        /// Cette classe permet de mettre en cache les informations d'un type
        /// d'énumération en particulier. Les informations ne sont évaluées
        /// qu'une fois par type, dans le constructeur statique
        /// </summary>
        /// <typeparam name="T">Le type d'énumération</typeparam>
        private static class EnumInfoCache<T> where T : struct
        {
            private static readonly bool _hasFlags;
            private static readonly IEnumerable<T> _values;
            private static readonly IDictionary<T, string> _descriptions;

            static EnumInfoCache()
            {
                _hasFlags = Attribute.IsDefined(typeof(T), typeof(FlagsAttribute));
                _values = Enum.GetValues(typeof(T)).Cast<T>();
                _descriptions = _values.ToDictionary(v => v, v => GetDescription(v)).AsReadOnly();
            }

            public static bool HasFlags
            {
                get { return _hasFlags; }
            }

            public static IEnumerable<T> Values
            {
                get { return _values; }
            }

            public static IDictionary<T, string> Descriptions
            {
                get { return _descriptions; }
            }

            private static string GetDescription(T value)
            {
                Type type = typeof(T);
                string name = Enum.GetName(type, value);
                if (name != null)
                {
                    FieldInfo field = type.GetField(name);
                    if (field != null)
                    {
                        DescriptionAttribute attr = Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute)) as DescriptionAttribute;
                        if (attr != null)
                        {
                            return attr.Description;
                        }
                    }
                }
                return null;
            }
        }

        /// <summary>
        /// Vérifie que le type spécifié est une énumération, et optionnellement s'il a l'attribut 'Flags'.
        /// Si ce n'est pas le cas, une exception est levée.
        /// </summary>
        /// <param name="withFlags">indique si le type à vérifier doit porter l'attribut Flags</param>
        /// <typeparam name="T">Le type à vérifier</typeparam>
        private static void CheckIsEnum<T>(bool withFlags) where T : struct
        {
            if (!typeof(T).IsEnum)
                throw new ArgumentException(string.Format(ExceptionMessages.TypeIsNotEnum, typeof(T).FullName));
            if (withFlags && !EnumInfoCache<T>.HasFlags)
                throw new ArgumentException(string.Format(ExceptionMessages.TypeNotDecoratedWithFlags, typeof(T).FullName));
        }

        /// <summary>
        /// Vérifie si le flag spécifié est présent dans la valeur
        /// </summary>
        /// <typeparam name="T">Le type de l'énumération</typeparam>
        /// <param name="value">La combinaison de flags à vérifier</param>
        /// <param name="flag">Le flag à vérifier</param>
        /// <returns>true si le flag est présent, false sinon</returns>
        public static bool HasFlag<T>(this T value, T flag) where T : struct
        {
            CheckIsEnum<T>(true);
            long lValue = Convert.ToInt64(value);
            long lFlag = Convert.ToInt64(flag);
            return (lValue & lFlag) != 0;
        }

        /// <summary>
        /// Convertit une combinaison de flags en une liste de valeurs de l'énumération
        /// </summary>
        /// <typeparam name="T">Le type de l'énumération</typeparam>
        /// <param name="value">La combinaison de flags à convertir</param>
        /// <returns>La liste des flags présents dans la combinaison</returns>
        public static IEnumerable<T> GetFlags<T>(this T value) where T : struct
        {
            CheckIsEnum<T>(true);
            return value.GetFlagsIterator<T>();
        }

        private static IEnumerable<T> GetFlagsIterator<T>(this T value) where T : struct
        {
            foreach (T flag in EnumInfoCache<T>.Values)
            {
                if (value.HasFlag(flag))
                    yield return flag;
            }
        }

        /// <summary>
        /// Définit la valeur d'un ou des flags dans une combinaison de flags
        /// </summary>
        /// <typeparam name="T">Le type de l'énumération</typeparam>
        /// <param name="value">La combinaison de flags à modifier</param>
        /// <param name="flags">Le ou les flags à définir</param>
        /// <param name="on">true pour ajouter le flag, false pour l'enlever</param>
        /// <returns>La combinaison résultant de l'ajout ou de la suppression des flags</returns>
        public static T SetFlags<T>(this T value, T flags, bool on) where T : struct
        {
            CheckIsEnum<T>(true);
            long lValue = Convert.ToInt64(value);
            long lFlag = Convert.ToInt64(flags);
            if (on)
            {
                lValue |= lFlag;
            }
            else
            {
                lValue &= (~lFlag);
            }
            return (T)Enum.ToObject(typeof(T), lValue);
        }

        /// <summary>
        /// Ajoute un ou des flags à une combinaison
        /// </summary>
        /// <typeparam name="T">Le type de l'énumération</typeparam>
        /// <param name="value">La combinaison de flags à modifier</param>
        /// <param name="flags">Le ou les flags à ajouter</param>
        /// <returns>La combinaison résultant de l'ajout des flags</returns>
        public static T SetFlags<T>(this T value, T flags) where T : struct
        {
            return value.SetFlags(flags, true);
        }

        /// <summary>
        /// Supprime un ou des flags d'une combinaison
        /// </summary>
        /// <typeparam name="T">Le type de l'énumération</typeparam>
        /// <param name="value">La combinaison de flags à modifier</param>
        /// <param name="flags">Le ou les flags à supprimer</param>
        /// <returns>La combinaison résultant de la suppression des flags</returns>
        public static T ClearFlags<T>(this T value, T flags) where T : struct
        {
            return value.SetFlags(flags, false);
        }

        /// <summary>
        /// Convertit une liste de flags en une combinaison de ces flags
        /// </summary>
        /// <typeparam name="T">Le type de l'énumération</typeparam>
        /// <param name="flags">La liste de flags à combiner</param>
        /// <returns>La combinaison des flags de la liste</returns>
        public static T CombineFlags<T>(this IEnumerable<T> flags) where T : struct
        {
            CheckIsEnum<T>(true);
            long lValue = 0;
            foreach (T flag in flags)
            {
                long lFlag = Convert.ToInt64(flag);
                lValue |= lFlag;
            }
            return (T)Enum.ToObject(typeof(T), lValue);
        }

        /// <summary>
        /// Renvoie, si elle est définie, la description d'une valeur d'une énumération, spécifiée par
        /// l'attribut DescriptionAttribute. Si la description n'est pas définie, renvoie null.
        /// </summary>
        /// <typeparam name="T">Le type de l'énumération</typeparam>
        /// <param name="value">la valeur pour laquelle obtenir une description</param>
        /// <returns>La description de la valeur si elle est définie, null sinon.</returns>
        public static string GetDescription<T>(this T value) where T : struct
        {
            return EnumInfoCache<T>.Descriptions[value];
        }

        /// <summary>
        /// Convertit une chaine en une valeur d'énumération, en ignorant éventuellement la casse
        /// </summary>
        /// <typeparam name="T">Type d'énumération souhaité</typeparam>
        /// <param name="stringValue">Chaine à convertir</param>
        /// <param name="ignoreCase">true pour ignorer la casse, false sinon</param>
        /// <returns>La valeur d'énumération correspondant à la chaine</returns>
        public static T ToEnum<T>(this string stringValue, bool ignoreCase) where T : struct
        {
            CheckIsEnum<T>(false);
            return (T)Enum.Parse(typeof(T), stringValue, ignoreCase);
        }

        /// <summary>
        /// Convertit une chaine en une valeur d'énumération
        /// </summary>
        /// <typeparam name="T">Type d'énumération souhaité</typeparam>
        /// <param name="stringValue">Chaine à convertir</param>
        /// <returns>La valeur d'énumération correspondant à la chaine</returns>
        public static T ToEnum<T>(this string stringValue) where T : struct
        {
            return stringValue.ToEnum<T>(false);
        }

        /// <summary>
        /// Convertit un entier signé sur 8 bits en une valeur d'énumération
        /// </summary>
        /// <typeparam name="T">Type d'énumération souhaité</typeparam>
        /// <param name="value">Valeur à convertir</param>
        /// <returns>La valeur d'énumération correspondant à la valeur</returns>
        public static T ToEnum<T>(this sbyte value) where T : struct
        {
            CheckIsEnum<T>(false);
            return (T)Enum.ToObject(typeof(T), value);
        }

        /// <summary>
        /// Convertit un entier signé sur 16 bits en une valeur d'énumération
        /// </summary>
        /// <typeparam name="T">Type d'énumération souhaité</typeparam>
        /// <param name="value">Valeur à convertir</param>
        /// <returns>La valeur d'énumération correspondant à la valeur</returns>
        public static T ToEnum<T>(this short value) where T : struct
        {
            CheckIsEnum<T>(false);
            return (T)Enum.ToObject(typeof(T), value);
        }

        /// <summary>
        /// Convertit un entier signé sur 32 bits en une valeur d'énumération
        /// </summary>
        /// <typeparam name="T">Type d'énumération souhaité</typeparam>
        /// <param name="value">Valeur à convertir</param>
        /// <returns>La valeur d'énumération correspondant à la valeur</returns>
        public static T ToEnum<T>(this int value) where T : struct
        {
            CheckIsEnum<T>(false);
            return (T)Enum.ToObject(typeof(T), value);
        }

        /// <summary>
        /// Convertit un entier signé sur 64 bits en une valeur d'énumération
        /// </summary>
        /// <typeparam name="T">Type d'énumération souhaité</typeparam>
        /// <param name="value">Valeur à convertir</param>
        /// <returns>La valeur d'énumération correspondant à la valeur</returns>
        public static T ToEnum<T>(this long value) where T : struct
        {
            CheckIsEnum<T>(false);
            return (T)Enum.ToObject(typeof(T), value);
        }

        /// <summary>
        /// Convertit un entier non signé sur 8 bits en une valeur d'énumération
        /// </summary>
        /// <typeparam name="T">Type d'énumération souhaité</typeparam>
        /// <param name="value">Valeur à convertir</param>
        /// <returns>La valeur d'énumération correspondant à la valeur</returns>
        public static T ToEnum<T>(this byte value) where T : struct
        {
            CheckIsEnum<T>(false);
            return (T)Enum.ToObject(typeof(T), value);
        }

        /// <summary>
        /// Convertit un entier non signé sur 16 bits en une valeur d'énumération
        /// </summary>
        /// <typeparam name="T">Type d'énumération souhaité</typeparam>
        /// <param name="value">Valeur à convertir</param>
        /// <returns>La valeur d'énumération correspondant à la valeur</returns>
        public static T ToEnum<T>(this ushort value) where T : struct
        {
            CheckIsEnum<T>(false);
            return (T)Enum.ToObject(typeof(T), value);
        }

        /// <summary>
        /// Convertit un entier non signé sur 32 bits en une valeur d'énumération
        /// </summary>
        /// <typeparam name="T">Type d'énumération souhaité</typeparam>
        /// <param name="value">Valeur à convertir</param>
        /// <returns>La valeur d'énumération correspondant à la valeur</returns>
        public static T ToEnum<T>(this uint value) where T : struct
        {
            CheckIsEnum<T>(false);
            return (T)Enum.ToObject(typeof(T), value);
        }

        /// <summary>
        /// Convertit un entier non signé sur 64 bits en une valeur d'énumération
        /// </summary>
        /// <typeparam name="T">Type d'énumération souhaité</typeparam>
        /// <param name="value">Valeur à convertir</param>
        /// <returns>La valeur d'énumération correspondant à la valeur</returns>
        public static T ToEnum<T>(this ulong value) where T : struct
        {
            CheckIsEnum<T>(false);
            return (T)Enum.ToObject(typeof(T), value);
        }
    }
}