using System;
using System.Collections.Generic;

namespace Developpez.Dotnet
{
    /// <summary>
    /// Fournit des méthodes d'extension pour les fonctions et actions
    /// </summary>
    public static partial class FuncExtensions
    {
        #region Mise en cache des résultats

        /// <summary>
        /// Renvoie un wrapper de la fonction qui met en cache le résultat,
        /// de façon à n'appeler la fonction qu'une seule fois
        /// </summary>
        /// <typeparam name="TResult">Le type de retour de la fonction</typeparam>
        /// <param name="function">La fonction à mettre en cache</param>
        /// <returns>La valeur de retour de la fonction</returns>
        public static Func<TResult> AsCached<TResult>(this Func<TResult> function)
        {
            TResult result = default(TResult);
            bool evaluated = false;
            object lck = new object();

            return () =>
            {
                lock (lck)
                {
                    if (!evaluated)
                    {
                        result = function();
                        evaluated = true;
                    }
                }
                return result;
            };
        }

        /// <summary>
        /// Renvoie un wrapper de la fonction qui met en cache le résultat
        /// pour chaque valeur de l'argument, de façon à n'appeler la fonction
        /// qu'une seule fois pour chaque valeur d'argument
        /// </summary>
        /// <typeparam name="T">Le type du paramètre</typeparam>
        /// <typeparam name="TResult">Le type de retour de la fonction</typeparam>
        /// <param name="function">La fonction à mettre en cache</param>
        /// <returns>La valeur de retour de la fonction</returns>
        public static Func<T, TResult> AsCached<T, TResult>(this Func<T, TResult> function)
        {
            var cachedResults = new Dictionary<T, TResult>();
            return (argument) =>
            {
                TResult result;
                lock (cachedResults)
                {
                    if (!cachedResults.TryGetValue(argument, out result))
                    {
                        result = function(argument);
                        cachedResults.Add(argument, result);
                    }
                }
                return result;
            };
        }

        #endregion

        #region Prédicats

        /// <summary>
        /// Convertit un délégué <![CDATA[Func<T, bool>]]> en délégué <![CDATA[Predicate<T>]]>
        /// </summary>
        /// <typeparam name="T">Le type du paramètre</typeparam>
        /// <param name="function">La fonction à convertir</param>
        /// <returns>Un prédicat équivalent à la fonction</returns>
        public static Predicate<T> ToPredicate<T>(this Func<T, bool> function)
        {
            return x => function(x);
        }

        /// <summary>
        /// Convertit un délégué <![CDATA[Predicate<T>]]> en délégué <![CDATA[Func<T, bool>]]>
        /// </summary>
        /// <typeparam name="T">Le type du paramètre</typeparam>
        /// <param name="predicate">Le prédicat à convertir</param>
        /// <returns>Une fonction équivalente au prédicat</returns>
        public static Func<T, bool> ToFunc<T>(this Predicate<T> predicate)
        {
            return x => predicate(x);
        }

        /// <summary>
        /// Renvoie la négation d'un prédicat
        /// </summary>
        /// <typeparam name="T">Le type de paramètre du prédicat</typeparam>
        /// <param name="function">Le prédicat dont on veut obtenir la négation</param>
        /// <returns>La négation du prédicat</returns>
        public static Func<T, bool> Negate<T>(this Func<T, bool> function)
        {
            return x => !function(x);
        }

        /// <summary>
        /// Renvoie la négation d'un prédicat
        /// </summary>
        /// <typeparam name="T">Le type de paramètre du prédicat</typeparam>
        /// <param name="predicate">Le prédicat dont on veut obtenir la négation</param>
        /// <returns>La négation du prédicat</returns>
        public static Predicate<T> Negate<T>(this Predicate<T> predicate)
        {
            return x => !predicate(x);
        }

        #endregion

        #region Comparaisons

        /// <summary>
        /// Convertit un délégué <![CDATA[Func<T, T, int>]]> en délégué <![CDATA[Comparison<T>]]>
        /// </summary>
        /// <typeparam name="T">Le type des paramètres</typeparam>
        /// <param name="function">La fonction à convertir</param>
        /// <returns>Une comparaison équivalente à la fonction</returns>
        public static Comparison<T> ToComparison<T>(this Func<T, T, int> function)
        {
            return (a, b) => function(a, b);
        }

        /// <summary>
        /// Convertit un délégué <![CDATA[Comparison<T>]]> en délégué <![CDATA[Func<T, T, int>]]>
        /// </summary>
        /// <typeparam name="T">Le type des paramètres</typeparam>
        /// <param name="comparison">La comparaison à convertir</param>
        /// <returns>Une fonction équivalente à la comparaison</returns>
        public static Func<T, T, int> ToFunc<T>(this Comparison<T> comparison)
        {
            return (a, b) => comparison(a, b);
        }

        #endregion
    }
}