using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using Developpez.Dotnet.Properties;
using JetBrains.Annotations;
using CH = Developpez.Dotnet.CompatibilityHelper;
#if !NETFX_CORE
using System.ComponentModel;
using Developpez.Dotnet.Collections;
#endif

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>
#if NETFX_CORE
            where T : struct, IComparable, IFormattable
#else
            where T : struct, IComparable, IFormattable, IConvertible
#endif
        {
            // ReSharper disable StaticFieldInGenericType
            private static readonly bool _isEnum;
            private static readonly bool _hasFlags;
            private static readonly Type _underlyingType;
            private static readonly T[] _values;
            private static readonly T[] _flagValues;
#if !NETFX_CORE
            private static readonly IDictionary<T, string> _descriptions;
#endif
            public static readonly Func<T, T, T> And;
            public static readonly Func<T, T, T> Or;
            public static readonly Func<T, T> Not;
            // ReSharper restore StaticFieldInGenericType

            static EnumInfoCache()
            {
                
#if NETFX_CORE
                _isEnum = typeof(T).GetTypeInfo().IsEnum;
#else
                _isEnum = typeof(T).IsEnum;
#endif

                if (_isEnum)
                {
                    _underlyingType = Enum.GetUnderlyingType(typeof(T));
                    _values = CH.Enum.GetValues(typeof(T)).Cast<T>().ToArray();
                    _flagValues = _values.Where(x => IsPowerOfTwo(Convert.ToUInt64(x))).ToArray();
#if NETFX_CORE
                    _hasFlags = typeof (T).GetTypeInfo().IsDefined(typeof(FlagsAttribute));
#else
                    _hasFlags = Attribute.IsDefined(typeof(T), typeof(FlagsAttribute));
                    _descriptions = new DefaultDictionary<T, string>(false);
                    foreach (var v in _values)
                    {
                        _descriptions.Add(v, GetDescription(v));
                    }
#endif

                    And = CreateFunc(Expression.And);
                    Or = CreateFunc(Expression.Or);
                    Not = CreateFunc(Expression.Not);
                }
            }

            private static Func<T, T> CreateFunc(Func<Expression, UnaryExpression> expressionFactory)
            {
                var arg = Expression.Parameter(typeof(T), "x");
                var castArg = Expression.Convert(arg, _underlyingType);
                var body = expressionFactory(castArg);
                var castBody = Expression.Convert(body, typeof(T));
                var expr = Expression.Lambda<Func<T, T>>(castBody, arg);
                return expr.Compile();
            }

            private static Func<T, T, T> CreateFunc(Func<Expression, Expression, BinaryExpression> expressionFactory)
            {
                var left = Expression.Parameter(typeof(T), "x");
                var right = Expression.Parameter(typeof(T), "y");
                var castLeft = Expression.Convert(left, _underlyingType);
                var castRight = Expression.Convert(right, _underlyingType);
                var body = expressionFactory(castLeft, castRight);
                var castBody = Expression.Convert(body, typeof(T));
                var expr = Expression.Lambda<Func<T, T, T>>(castBody, left, right);
                return expr.Compile();
            }

            public static bool IsEnum
            {
                get { return _isEnum; }
            }

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

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

            public static IEnumerable<T> FlagValues
            {
                get { return _flagValues; }
            }

#if !NETFX_CORE
            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;
            }
#endif
            private static bool IsPowerOfTwo(ulong x)
            {
                return (x != 0) && (x & (x - 1)) == 0;
            }
        }
        /// <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>
        [AssertionMethod]
        private static void CheckIsEnum<T>(bool withFlags)
#if NETFX_CORE
            where T : struct, IComparable, IFormattable
#else
            where T : struct, IComparable, IFormattable, IConvertible
#endif
        {
            if (!EnumInfoCache<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)
#if NETFX_CORE
            where T : struct, IComparable, IFormattable
#else
            where T : struct, IComparable, IFormattable, IConvertible
#endif
        {
            CheckIsEnum<T>(true);
            return !EnumInfoCache<T>.And(value, flag).Equals(default(T));
        }

        /// <summary>
        /// Convertit une combinaison de flags en une liste de valeurs de l'énumération, en
        /// excluant les combinaisons prédéfinies.
        /// </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)
#if NETFX_CORE
            where T : struct, IComparable, IFormattable
#else
            where T : struct, IComparable, IFormattable, IConvertible
#endif
        {
            CheckIsEnum<T>(true);
            return value.GetFlagsIterator(true);
        }

        /// <summary>
        /// Convertit une combinaison de flags en une liste de valeurs de l'énumération, en
        /// excluant optionnellement les combinaisons prédéfinies.
        /// </summary>
        /// <typeparam name="T">Le type de l'énumération</typeparam>
        /// <param name="value">La combinaison de flags à convertir</param>
        /// <param name="flagsOnly">Indique si seuls les flags simples sont renvoyés, en excluant les combinaisons connues.</param>
        /// <returns>La liste des flags présents dans la combinaison</returns>
        public static IEnumerable<T> GetFlags<T>(this T value, bool flagsOnly)
#if NETFX_CORE
            where T : struct, IComparable, IFormattable
#else
            where T : struct, IComparable, IFormattable, IConvertible
#endif
        {
            CheckIsEnum<T>(true);
            return value.GetFlagsIterator(flagsOnly);
        }

        private static IEnumerable<T> GetFlagsIterator<T>(this T value, bool flagsOnly)
#if NETFX_CORE
            where T : struct, IComparable, IFormattable
#else
            where T : struct, IComparable, IFormattable, IConvertible
#endif
        {
            var values = flagsOnly
                            ? EnumInfoCache<T>.FlagValues
                            : EnumInfoCache<T>.Values;
            foreach (T flag in 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)
#if NETFX_CORE
            where T : struct, IComparable, IFormattable
#else
            where T : struct, IComparable, IFormattable, IConvertible
#endif
        {
            CheckIsEnum<T>(true);
            if (on)
                return EnumInfoCache<T>.Or(value, flags);
            return EnumInfoCache<T>.And(value, EnumInfoCache<T>.Not(flags));
        }

        /// <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)
#if NETFX_CORE
            where T : struct, IComparable, IFormattable
#else
            where T : struct, IComparable, IFormattable, IConvertible
#endif
        {
            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)
#if NETFX_CORE
            where T : struct, IComparable, IFormattable
#else
            where T : struct, IComparable, IFormattable, IConvertible
#endif
        {
            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)
#if NETFX_CORE
            where T : struct, IComparable, IFormattable
#else
            where T : struct, IComparable, IFormattable, IConvertible
#endif
        {
            CheckIsEnum<T>(true);
            T tmp = default(T);
            foreach (T flag in flags)
            {
                tmp = EnumInfoCache<T>.Or(tmp, flag);
            }
            return tmp;
        }

#if !NETFX_CORE
        /// <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, IComparable, IFormattable, IConvertible
        {
            CheckIsEnum<T>(false);
            return EnumInfoCache<T>.Descriptions[value];
        }
#endif

        /// <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)
#if NETFX_CORE
            where T : struct, IComparable, IFormattable
#else
            where T : struct, IComparable, IFormattable, IConvertible
#endif
        {
            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)
#if NETFX_CORE
            where T : struct, IComparable, IFormattable
#else
            where T : struct, IComparable, IFormattable, IConvertible
#endif
        {
            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)
#if NETFX_CORE
            where T : struct, IComparable, IFormattable
#else
            where T : struct, IComparable, IFormattable, IConvertible
#endif
        {
            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)
#if NETFX_CORE
            where T : struct, IComparable, IFormattable
#else
            where T : struct, IComparable, IFormattable, IConvertible
#endif
        {
            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)
#if NETFX_CORE
            where T : struct, IComparable, IFormattable
#else
            where T : struct, IComparable, IFormattable, IConvertible
#endif
        {
            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)
#if NETFX_CORE
            where T : struct, IComparable, IFormattable
#else
            where T : struct, IComparable, IFormattable, IConvertible
#endif
        {
            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)
#if NETFX_CORE
            where T : struct, IComparable, IFormattable
#else
            where T : struct, IComparable, IFormattable, IConvertible
#endif
        {
            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)
#if NETFX_CORE
            where T : struct, IComparable, IFormattable
#else
            where T : struct, IComparable, IFormattable, IConvertible
#endif
        {
            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)
#if NETFX_CORE
            where T : struct, IComparable, IFormattable
#else
            where T : struct, IComparable, IFormattable, IConvertible
#endif
        {
            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)
#if NETFX_CORE
            where T : struct, IComparable, IFormattable
#else
            where T : struct, IComparable, IFormattable, IConvertible
#endif
        {
            CheckIsEnum<T>(false);
            return (T)Enum.ToObject(typeof(T), value);
        }
    }
}