using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using Developpez.Dotnet.Properties;

namespace Developpez.Dotnet.Reflection
{
    /// <summary>
    /// Fournit des méthodes d'extension pour faciliter l'utilisation de la réflexion
    /// </summary>
    public static class ReflectionExtensions
    {
        #region Type extensions

        /// <summary>
        /// Détermine si un type hérite d'un autre type, ou implémente une interface
        /// </summary>
        /// <param name="type">Le type à vérifier</param>
        /// <param name="superType">Le type de base dont <c>type</c> doit hériter</param>
        /// <returns>true si <c>type</c> est <c>superType</c>, hérite de <c>superType</c>, ou implémente <c>superType</c>. Sinon, false</returns>
        public static bool Is(this Type type, Type superType)
        {
            return superType.IsAssignableFrom(type);
        }

        /// <summary>
        /// Détermine si un type hérite d'un autre type, ou implémente une interface
        /// </summary>
        /// <typeparam name="T">Le type de base dont <c>type</c> doit hériter</typeparam>
        /// <param name="type">Le type à vérifier</param>
        /// <returns>true si <c>type</c> est <c>T</c>, hérite de <c>T</c>, ou implémente <c>T</c>. Sinon, false</returns>
        public static bool Is<T>(this Type type)
        {
            return type.Is(typeof(T));
        }

        /// <summary>
        /// Vérifie si <c>type</c> est implicitement convertible à partir de <c>sourceType</c>.
        /// </summary>
        /// <param name="type">Type cible</param>
        /// <param name="sourceType">Type source</param>
        /// <returns><c>true</c> s'il existe une conversion implicite de <c>sourceType</c> vers <c>type</c>, ou si aucune conversion n'est nécessaire ; sinon, <c>false</c>.</returns>
        public static bool IsImplicitlyConvertibleFrom(this Type type, Type sourceType)
        {
            return type.IsConvertibleFrom(sourceType, ConversionType.Implicit);
        }

        /// <summary>
        /// Vérifie si <c>type</c> est implicitement convertible à partir de <c>T</c>.
        /// </summary>
        /// <typeparam name="T">Type source</typeparam>
        /// <param name="type">Type cible</param>
        /// <returns><c>true</c> s'il existe une conversion implicite de <c>T</c> vers <c>type</c>, ou si aucune conversion n'est nécessaire ; sinon, <c>false</c>.</returns>
        public static bool IsImplicitlyConvertibleFrom<T>(this Type type)
        {
            return type.IsImplicitlyConvertibleFrom(typeof (T));
        }

        /// <summary>
        /// Vérifie si <c>type</c> est convertible (implicitement ou explicitement) à partir de <c>sourceType</c>.
        /// </summary>
        /// <param name="type">Type cible</param>
        /// <param name="sourceType">Type source</param>
        /// <returns><c>true</c> s'il existe une conversion (implicite ou explicite) de <c>sourceType</c> vers <c>type</c>, ou si aucune conversion n'est nécessaire ; sinon, <c>false</c>.</returns>
        public static bool IsConvertibleFrom(this Type type, Type sourceType)
        {
            return type.IsConvertibleFrom(sourceType, ConversionType.Any);
        }

        /// <summary>
        /// Vérifie si <c>type</c> est convertible (implicitement ou explicitement) à partir de <c>T</c>.
        /// </summary>
        /// <typeparam name="T">Type source</typeparam>
        /// <param name="type">Type cible</param>
        /// <returns><c>true</c> s'il existe une conversion (implicite ou explicite) de <c>T</c> vers <c>type</c>, ou si aucune conversion n'est nécessaire ; sinon, <c>false</c>.</returns>
        public static bool IsConvertibleFrom<T>(this Type type)
        {
            return type.IsConvertibleFrom(typeof(T));
        }

        /// <summary>
        /// Vérifie si <c>type</c> est implicitement convertible en <c>targetType</c>.
        /// </summary>
        /// <param name="type">Type source</param>
        /// <param name="targetType">Type cible</param>
        /// <returns><c>true</c> s'il existe une conversion implicite de <c>type</c> vers <c>T</c>, ou si aucune conversion n'est nécessaire ; sinon, <c>false</c>.</returns>
        public static bool IsImplicitlyConvertibleTo(this Type type, Type targetType)
        {
            return targetType.IsConvertibleFrom(type, ConversionType.Implicit);
        }

        /// <summary>
        /// Vérifie si <c>type</c> est implicitement convertible en <c>T</c>.
        /// </summary>
        /// <typeparam name="T">Type cible</typeparam>
        /// <param name="type">Type source</param>
        /// <returns><c>true</c> s'il existe une conversion implicite de <c>type</c> vers <c>targetType</c>, ou si aucune conversion n'est nécessaire ; sinon, <c>false</c>.</returns>
        public static bool IsImplicitlyConvertibleTo<T>(this Type type)
        {
            return type.IsImplicitlyConvertibleTo(typeof(T));
        }

        /// <summary>
        /// Vérifie si <c>type</c> est convertible (implicitement ou explicitement) en <c>targetType</c>.
        /// </summary>
        /// <param name="type">Type source</param>
        /// <param name="targetType">Type cible</param>
        /// <returns><c>true</c> s'il existe une conversion (implicite ou explicite) de <c>type</c> vers <c>targetType</c>, ou si aucune conversion n'est nécessaire ; sinon, <c>false</c>.</returns>
        public static bool IsConvertibleTo(this Type type, Type targetType)
        {
            return targetType.IsConvertibleFrom(type, ConversionType.Any);
        }

        /// <summary>
        /// Vérifie si <c>type</c> est convertible (implicitement ou explicitement) en <c>T</c>.
        /// </summary>
        /// <typeparam name="T">Type cible</typeparam>
        /// <param name="type">Type source</param>
        /// <returns><c>true</c> s'il existe une conversion (implicite ou explicite) de <c>type</c> vers <c>targetType</c>, ou si aucune conversion n'est nécessaire ; sinon, <c>false</c>.</returns>
        public static bool IsConvertibleTo<T>(this Type type)
        {
            return type.IsConvertibleTo(typeof(T));
        }

        private enum ConversionType
        {
            Explicit,
            Implicit,
            Any
        }
        
        private static bool IsConvertibleFrom(this Type type, Type sourceType, ConversionType conversionType)
        {
            return type.IsAssignableFrom(sourceType)
                   || type.HasCustomConversionFrom(sourceType, conversionType)
                   || sourceType.HasCustomConversionTo(type, conversionType);
        }

        private static bool HasCustomConversionFrom(this Type type, Type sourceType, ConversionType conversionType)
        {
            string operatorName;
            switch (conversionType)
            {
                case ConversionType.Explicit:
                    operatorName = "op_Explicit";
                    break;
                case ConversionType.Implicit:
                    operatorName = "op_Implicit";
                    break;
                case ConversionType.Any:
                    return type.HasCustomConversionFrom(sourceType, ConversionType.Implicit)
                           || type.HasCustomConversionFrom(sourceType, ConversionType.Explicit);
                default:
                    throw new ArgumentException(ExceptionMessages.UnknownConversionType, "conversionType");
            }
            return type.GetMethod(operatorName, new[] { sourceType }) != null;
        }

        private static bool HasCustomConversionTo(this Type type, Type targetType, ConversionType conversionType)
        {
            string operatorName;
            switch (conversionType)
            {
                case ConversionType.Explicit:
                    operatorName = "op_Explicit";
                    break;
                case ConversionType.Implicit:
                    operatorName = "op_Implicit";
                    break;
                case ConversionType.Any:
                    return type.HasCustomConversionTo(targetType, ConversionType.Implicit)
                           || type.HasCustomConversionTo(targetType, ConversionType.Explicit);
                default:
                    throw new ArgumentException(ExceptionMessages.UnknownConversionType, "conversionType");
            }
            return type.GetMethods()
                       .Where(m => m.Name == operatorName
                                && m.ReturnType == targetType)
                       .Any();
        }

        /// <summary>
        /// Indique si un type est nullable.
        /// </summary>
        /// <param name="type">Type dont on veut vérifier s'il est nullable</param>
        /// <returns>true si <c>type</c> est un type référence ou un type générique Nullable&lt;T&gt;, false sinon</returns>
        public static bool IsNullable(this Type type)
        {
            if (type.IsValueType)
            {
                return type.IsGenericType
                    && type.GetGenericTypeDefinition() == typeof(Nullable<>);
            }
            return true;
        }

        /// <summary>
        /// Renvoie la valeur par défaut du type spécifié
        /// </summary>
        /// <param name="type">Le type dont on veut récupérer la valeur par défaut</param>
        /// <returns>La valeur par défaut du type</returns>
        public static object GetDefaultValue(this Type type)
        {
            if (type.IsValueType && type != typeof(void))
                return Activator.CreateInstance(type);
            return null;
        }

        /// <summary>
        /// Indique si un type est statique.
        /// </summary>
        /// <param name="type">Le type à tester</param>
        /// <returns>true si le type est statique, false sinon</returns>
        public static bool IsStatic(this Type type)
        {
            return type.IsAbstract && type.IsSealed;
        }

        #endregion

        #region ICustomAttributeProvider extensions

        /// <summary>
        /// Détermine si un attribut est appliqué à un objet de réflexion.
        /// </summary>
        /// <param name="reflectionObject">L'objet de réflexion à vérifier</param>
        /// <param name="attributeType">Le type de l'attribut à rechercher</param>
        /// <returns>true si l'attribut spécifié est appliqué à l'objet de réflexion, false sinon</returns>
        public static bool HasAttribute(this ICustomAttributeProvider reflectionObject, Type attributeType)
        {
            return reflectionObject.IsDefined(attributeType, true);
        }

        /// <summary>
        /// Détermine si un attribut est appliqué à un objet de réflexion.
        /// </summary>
        /// <param name="reflectionObject">L'objet de réflexion à vérifier</param>
        /// <param name="attributeType">Le type de l'attribut à rechercher</param>
        /// <param name="inherit">true pour rechercher aussi dans les ancêtres, false sinon</param>
        /// <returns>true si l'attribut spécifié est appliqué à l'objet de réflexion, false sinon</returns>
        public static bool HasAttribute(this ICustomAttributeProvider reflectionObject, Type attributeType, bool inherit)
        {
            return reflectionObject.IsDefined(attributeType, inherit);
        }

        /// <summary>
        /// Récupère les attributs appliqués à un objet de réflexion.
        /// </summary>
        /// <param name="reflectionObject">L'objet de réflexion dont on veut récupérer les attributs</param>
        /// <returns>Une liste des attributs appliqués à l'objet de réflexion</returns>
        public static IEnumerable<Attribute> GetAttributes(this ICustomAttributeProvider reflectionObject)
        {
            return reflectionObject.GetAttributes(true);
        }

        /// <summary>
        /// Récupère les attributs appliqués à un objet de réflexion.
        /// </summary>
        /// <param name="reflectionObject">L'objet de réflexion dont on veut récupérer les attributs</param>
        /// <param name="inherit">true pour rechercher aussi dans les ancêtres, false sinon</param>
        /// <returns>Une liste des attributs du type demandé appliqués à l'objet de réflexion</returns>
        public static IEnumerable<Attribute> GetAttributes(this ICustomAttributeProvider reflectionObject, bool inherit)
        {
            return reflectionObject.GetCustomAttributes(inherit).Cast<Attribute>();
        }

        /// <summary>
        /// Récupère les attributs appliqués à un objet de réflexion.
        /// </summary>
        /// <param name="reflectionObject">L'objet de réflexion dont on veut récupérer les attributs</param>
        /// <param name="attributeType">Le type de l'attribut recherché</param>
        /// <returns>Une liste des attributs du type demandé appliqués à l'objet de réflexion</returns>
        public static IEnumerable<Attribute> GetAttributes(this ICustomAttributeProvider reflectionObject, Type attributeType)
        {
            return reflectionObject.GetAttributes(attributeType, true);
        }

        /// <summary>
        /// Récupère les attributs appliqués à un objet de réflexion.
        /// </summary>
        /// <param name="reflectionObject">L'objet de réflexion dont on veut récupérer les attributs</param>
        /// <param name="attributeType">Le type de l'attribut recherché</param>
        /// <param name="inherit">true pour rechercher aussi dans les ancêtres, false sinon</param>
        /// <returns>Une liste des attributs du type demandé appliqués à l'objet de réflexion</returns>
        public static IEnumerable<Attribute> GetAttributes(this ICustomAttributeProvider reflectionObject, Type attributeType, bool inherit)
        {
            return reflectionObject.GetCustomAttributes(attributeType, inherit).Cast<Attribute>();
        }

        /// <summary>
        /// Récupère un attribut appliqué à un objet de réflexion.
        /// </summary>
        /// <param name="reflectionObject">L'objet de réflexion dont on veut récupérer un attribut</param>
        /// <param name="attributeType">Le type de l'attribut recherché</param>
        /// <returns>L'attribut recherché s'il existe, null sinon</returns>
        public static Attribute GetAttribute(this ICustomAttributeProvider reflectionObject, Type attributeType)
        {
            return reflectionObject.GetAttribute(attributeType, true);
        }

        /// <summary>
        /// Récupère un attribut appliqué à un objet de réflexion.
        /// </summary>
        /// <param name="reflectionObject">L'objet de réflexion dont on veut récupérer un attribut</param>
        /// <param name="attributeType">Le type de l'attribut recherché</param>
        /// <param name="inherit">true pour rechercher aussi dans les ancêtres, false sinon</param>
        /// <returns>L'attribut recherché s'il existe, null sinon</returns>
        public static Attribute GetAttribute(this ICustomAttributeProvider reflectionObject, Type attributeType, bool inherit)
        {
            return reflectionObject.GetCustomAttributes(attributeType, inherit).Cast<Attribute>().FirstOrDefault();
        }

        /// <summary>
        /// Détermine si un attribut est appliqué à un objet de réflexion.
        /// </summary>
        /// <typeparam name="T">Le type de l'attribut à rechercher</typeparam>
        /// <param name="reflectionObject">L'objet de réflexion à vérifier</param>
        /// <returns>true si l'attribut spécifié est appliqué à l'objet de réflexion, false sinon</returns>
        public static bool HasAttribute<T>(this ICustomAttributeProvider reflectionObject)
            where T : Attribute
        {
            return reflectionObject.HasAttribute(typeof(T));
        }

        /// <summary>
        /// Détermine si un attribut est appliqué à un objet de réflexion.
        /// </summary>
        /// <typeparam name="T">Le type de l'attribut à rechercher</typeparam>
        /// <param name="reflectionObject">L'objet de réflexion à vérifier</param>
        /// <param name="inherit">true pour rechercher aussi dans les ancêtres, false sinon</param>
        /// <returns>true si l'attribut spécifié est appliqué à l'objet de réflexion, false sinon</returns>
        public static bool HasAttribute<T>(this ICustomAttributeProvider reflectionObject, bool inherit)
            where T : Attribute
        {
            return reflectionObject.HasAttribute(typeof(T), inherit);
        }

        /// <summary>
        /// Récupère les attributs appliqués à un objet de réflexion.
        /// </summary>
        /// <typeparam name="T">Le type de l'attribut recherché</typeparam>
        /// <param name="reflectionObject">L'objet de réflexion dont on veut récupérer les attributs</param>
        /// <returns>Une liste des attributs du type demandé appliqués à l'objet de réflexion</returns>
        public static IEnumerable<T> GetAttributes<T>(this ICustomAttributeProvider reflectionObject)
            where T : Attribute
        {
            return reflectionObject.GetAttributes(typeof(T)).Cast<T>();
        }

        /// <summary>
        /// Récupère les attributs appliqués à un objet de réflexion.
        /// </summary>
        /// <typeparam name="T">Le type de l'attribut recherché</typeparam>
        /// <param name="reflectionObject">L'objet de réflexion dont on veut récupérer les attributs</param>
        /// <param name="inherit">true pour rechercher aussi dans les ancêtres, false sinon</param>
        /// <returns>Une liste des attributs du type demandé appliqués à l'objet de réflexion</returns>
        public static IEnumerable<T> GetAttributes<T>(this ICustomAttributeProvider reflectionObject, bool inherit)
            where T : Attribute
        {
            return reflectionObject.GetAttributes(typeof(T), inherit).Cast<T>();
        }

        /// <summary>
        /// Récupère un attribut appliqué à un objet de réflexion.
        /// </summary>
        /// <typeparam name="T">Le type de l'attribut recherché</typeparam>
        /// <param name="reflectionObject">L'objet de réflexion dont on veut récupérer un attribut</param>
        /// <returns>L'attribut recherché s'il existe, null sinon</returns>
        public static T GetAttribute<T>(this ICustomAttributeProvider reflectionObject)
            where T : Attribute
        {
            return reflectionObject.GetAttribute(typeof(T)) as T;
        }

        /// <summary>
        /// Récupère un attribut appliqué à un objet de réflexion.
        /// </summary>
        /// <typeparam name="T">Le type de l'attribut recherché</typeparam>
        /// <param name="reflectionObject">L'objet de réflexion dont on veut récupérer un attribut</param>
        /// <param name="inherit">true pour rechercher aussi dans les ancêtres, false sinon</param>
        /// <returns>L'attribut recherché s'il existe, null sinon</returns>
        public static T GetAttribute<T>(this ICustomAttributeProvider reflectionObject, bool inherit)
            where T : Attribute
        {
            return reflectionObject.GetAttribute(typeof(T), inherit) as T;
        }

        #endregion

        #region PropertyInfo extensions

        /// <summary>
        /// Définit la valeur d'une propriété pour un objet. Equivalent à <c>PropertyInfo.GetValue</c>,
        /// mais fonctionne aussi pour les types valeur.
        /// </summary>
        /// <typeparam name="T">Type de l'objet</typeparam>
        /// <param name="propertyInfo">Descripteur de la propriété</param>
        /// <param name="instance">objet pour lequel on définit la valeur de la propriété</param>
        /// <param name="value">Nouvelle valeur de la propriété</param>
        public static void SetValue<T>(this PropertyInfo propertyInfo, ref T instance, object value)
        {
            SetValue(propertyInfo, ref instance, value, null);
        }

        /// <summary>
        /// Définit la valeur d'une propriété pour un objet. Equivalent à <c>PropertyInfo.GetValue</c>,
        /// mais fonctionne aussi pour les types valeur.
        /// </summary>
        /// <typeparam name="T">Type de l'objet</typeparam>
        /// <param name="propertyInfo">Descripteur de la propriété</param>
        /// <param name="instance">objet pour lequel on définit la valeur de la propriété</param>
        /// <param name="value">Nouvelle valeur de la propriété</param>
        /// <param name="index">Index pour la propriété indexée, ou null si la propriété n'est pas indexée</param>
        public static void SetValue<T>(this PropertyInfo propertyInfo, ref T instance, object value, object[] index)
        {
            object obj = instance;
            propertyInfo.SetValue(obj, value, index);
            instance = (T)obj;
        }

        #endregion

        #region FieldInfo extensions

        /// <summary>
        /// Définit la valeur d'un champ pour un objet. Equivalent à <c>FieldInfo.GetValue</c>,
        /// mais fonctionne aussi pour les types valeur.
        /// </summary>
        /// <typeparam name="T">Type de l'objet</typeparam>
        /// <param name="fieldInfo">Descripteur du champ</param>
        /// <param name="instance">objet pour lequel on définit la valeur du champ</param>
        /// <param name="value">Nouvelle valeur du champ</param>
        public static void SetValue<T>(this FieldInfo fieldInfo, ref T instance, object value)
        {
            object obj = instance;
            fieldInfo.SetValue(obj, value);
            instance = (T)obj;
        }

        #endregion
    }
}