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

namespace Developpez.Dotnet.Linq
{
    /// <summary>
    /// Fournit des méthodes pour travailler avec Linq et les expressions lambda
    /// </summary>
    public static partial class LinqHelper
    {
        /// <summary>
        /// Obtient le nom d'une propriété à partir d'une <c>Expression&lt;Func&lt;T&gt;&gt;</c>
        /// </summary>
        /// <typeparam name="T">Le type de la propriété à renvoyer (habituellement déterminé par l'inférence de type)</typeparam>
        /// <param name="expression">Une expression qui représente l'accès à une propriété</param>
        /// <returns>Le nom de la propriété accédée par l'expression</returns>
        public static string GetPropertyName<T>(Expression<Func<T>> expression)
        {
            return GetProperty(expression).Name;
        }

        /// <summary>
        /// Obtient les informations d'une propriété à partir d'une <c>Expression&lt;Func&lt;T&gt;&gt;</c>
        /// </summary>
        /// <typeparam name="T">Le type de la propriété à renvoyer (habituellement déterminé par l'inférence de type)</typeparam>
        /// <param name="expression">Une expression qui représente l'accès à une propriété</param>
        /// <returns>Les informations de la propriété accédée par l'expression</returns>
        public static PropertyInfo GetProperty<T>(Expression<Func<T>> expression)
        {
            var mExpr = expression.Body as MemberExpression;
            if (mExpr == null)
                throw new ArgumentException(ExceptionMessages.ExpressionMustBePropertyAccess);
            return (PropertyInfo)mExpr.Member;
        }

        /// <summary>
        /// Obtient le nom d'une méthode à partir d'une <c>Expression&lt;Func&lt;T&gt;&gt;</c>
        /// </summary>
        /// <typeparam name="T">Le type de retour de la méthode à renvoyer (habituellement déterminé par l'inférence de type)</typeparam>
        /// <param name="expression">Une expression qui représente l'appel à une méthode</param>
        /// <returns>Le nom de la méthode appelée par l'expression</returns>
        public static string GetMethodName<T>(Expression<Func<T>> expression)
        {
            return GetMethod(expression).Name;
        }

        /// <summary>
        /// Obtient les informations d'une méthode à partir d'une <c>Expression&lt;Func&lt;T&gt;&gt;</c>
        /// </summary>
        /// <typeparam name="T">Le type de retour de la méthode à renvoyer (habituellement déterminé par l'inférence de type)</typeparam>
        /// <param name="expression">Une expression qui représente l'appel à une méthode</param>
        /// <returns>Les informations de la méthode appelée par l'expression</returns>
        public static MethodInfo GetMethod<T>(Expression<Func<T>> expression)
        {
            var callExpr = expression.Body as MethodCallExpression;
            if (callExpr == null)
                throw new ArgumentException(ExceptionMessages.ExpressionMustBeMethodCall);
            return callExpr.Method;
        }

        /// <summary>
        /// Obtient le nom d'une méthode à partir d'une <c>Expression&lt;Action&gt;</c>
        /// </summary>
        /// <param name="expression">Une expression qui représente l'appel à une méthode</param>
        /// <returns>Le nom de la méthode appelée par l'expression</returns>
        public static string GetMethodName(Expression<Action> expression)
        {
            return GetMethod(expression).Name;
        }

        /// <summary>
        /// Obtient les informations d'une méthode à partir d'une <c>Expression&lt;Action&gt;</c>
        /// </summary>
        /// <param name="expression">Une expression qui représente l'appel à une méthode</param>
        /// <returns>Les  informations de la méthode appelée par l'expression</returns>
        public static MethodInfo GetMethod(Expression<Action> expression)
        {
            var callExpr = expression.Body as MethodCallExpression;
            if (callExpr == null)
                throw new ArgumentException(ExceptionMessages.ExpressionMustBeMethodCall);
            return callExpr.Method;
        }

        /// <summary>
        /// Renvoie l'argument tel quel. Utile pour passer une projection à l'identique à une méthode telle que Select, OrderBy ou GroupBy.
        /// </summary>
        /// <typeparam name="T">Type de l'argument</typeparam>
        /// <param name="arg">Argument à renvoyer</param>
        /// <returns>L'argument tel quel</returns>
        public static T Identity<T>(T arg) { return arg; }

        /// <summary>
        /// Génère une séquence en en générant chaque état à partir d'un état
        /// initial tant que la condition est vérifiée.
        /// </summary>
        /// <typeparam name="TState">Type des états</typeparam>
        /// <typeparam name="TResult">Type des résultats</typeparam>
        /// <param name="initialState">État initial</param>
        /// <param name="condition">Prédicat qui doit être vérifié pour que l'itération continue</param>
        /// <param name="iterate">Fonction qui génère l'état suivant à partir de l'état actuel</param>
        /// <param name="resultSelector">Fonction qui séléctionne un résultat à partir de l'état actuel</param>
        /// <returns>Séquence contenant les résultats générés</returns>
        public static IEnumerable<TResult> Generate<TState, TResult>(
            TState initialState,
            Func<TState, bool> condition,
            Func<TState, TState> iterate,
            Func<TState, TResult> resultSelector)
        {
            TState state = initialState;
            while (condition(state))
            {
                yield return resultSelector(state);
                state = iterate(state);
            }
        }

        #region Expr and Func helpers

        /// <summary>
        /// Renvoie l'expression passée en paramètre, de façon à profiter de l'inférence de type
        /// </summary>
        /// <typeparam name="T">Le type de retour de l'expression</typeparam>
        /// <param name="expr">L'expression dont on veut inférer le type</param>
        /// <returns>L'expression passée en paramètre</returns>
        public static Expression<Func<T>> Expr<T>(Expression<Func<T>> expr)
        {
            return expr;
        }

        /// <summary>
        /// Renvoie l'expression passée en paramètre, de façon à profiter de l'inférence de type
        /// </summary>
        /// <typeparam name="T">Le type du paramètre de l'expression</typeparam>
        /// <typeparam name="TResult">Le type de retour de l'expression</typeparam>
        /// <param name="expr">L'expression dont on veut inférer le type</param>
        /// <returns>L'expression passée en paramètre</returns>
        public static Expression<Func<T, TResult>> Expr<T, TResult>(Expression<Func<T, TResult>> expr)
        {
            return expr;
        }

        /// <summary>
        /// Renvoie l'expression passée en paramètre, de façon à profiter de l'inférence de type
        /// </summary>
        /// <typeparam name="T">Le type du paramètre de l'expression</typeparam>
        /// <typeparam name="TResult">Le type de retour de l'expression</typeparam>
        /// <param name="dummyArg">Objet utilisé comme modèle pour déterminer le type du paramètre</param>
        /// <param name="expr">L'expression dont on veut inférer le type</param>
        /// <returns>L'expression passée en paramètre</returns>
        public static Expression<Func<T, TResult>> Expr<T, TResult>(T dummyArg, Expression<Func<T, TResult>> expr)
        {
            return expr;
        }

        /// <summary>
        /// Renvoie la fonction passée en paramètre, de façon à profiter de l'inférence de type
        /// </summary>
        /// <typeparam name="T">Le type de retour de la fonction</typeparam>
        /// <param name="func">La fonction dont on veut inférer le type</param>
        /// <returns>La fonction passée en paramètre</returns>
        public static Func<T> Func<T>(Func<T> func)
        {
            return func;
        }

        /// <summary>
        /// Renvoie la fonction passée en paramètre, de façon à profiter de l'inférence de type
        /// </summary>
        /// <typeparam name="T">Le type du paramètre de la fonction</typeparam>
        /// <typeparam name="TResult">Le type de retour de la fonction</typeparam>
        /// <param name="func">La fonction dont on veut inférer le type</param>
        /// <returns>La fonction passée en paramètre</returns>
        public static Func<T, TResult> Func<T, TResult>(Func<T, TResult> func)
        {
            return func;
        }

        /// <summary>
        /// Renvoie la fonction passée en paramètre, de façon à profiter de l'inférence de type
        /// </summary>
        /// <typeparam name="T">Le type du paramètre de la fonction</typeparam>
        /// <typeparam name="TResult">Le type de retour de la fonction</typeparam>
        /// <param name="dummyArg">Objet utilisé comme modèle pour déterminer le type du paramètre</param>
        /// <param name="func">La fonction dont on veut inférer le type</param>
        /// <returns>La fonction passée en paramètre</returns>
        public static Func<T, TResult> Func<T, TResult>(T dummyArg, Func<T, TResult> func)
        {
            return func;
        }

        #endregion
    }
}