using System;
using System.Collections.Generic;

namespace Developpez.Dotnet.Collections
{
    /// <summary>
    /// Fournit des méthodes d'extension pour travailler avec des <see cref="IComparer{T}"/> et des <see cref="Comparison{T}"/>
    /// </summary>
    public static class CompareExtensions
    {
        /// <summary>
        /// Obtient un <see cref="IComparer{T}"/> à partir de la comparaison spécifiée
        /// </summary>
        /// <typeparam name="T">Type des éléments à comparer</typeparam>
        /// <param name="comparison">La comparaison à utiliser</param>
        /// <returns>Un <see cref="IComparer{T}"/> qui utilise la comparaison spécifiée</returns>
        public static IComparer<T> ToComparer<T>(this Comparison<T> comparison)
        {
            comparison.CheckArgumentNull("comparison");
            return new ComparisonComparer<T>(comparison);
        }

        /// <summary>
        /// Obtient une <see cref="Comparison{T}"/> à partir du <see cref="IComparer{T}"/> spécifié
        /// </summary>
        /// <typeparam name="T">Type des éléments à comparer</typeparam>
        /// <param name="comparer">Comparateur à utiliser</param>
        /// <returns>La comparaison équivalente au <see cref="IComparer{T}"/> spécifié</returns>
        public static Comparison<T> ToComparison<T>(this IComparer<T> comparer)
        {
            comparer.CheckArgumentNull("comparer");
            return comparer.Compare;
        }

        /// <summary>
        /// Inverse le <see cref="IComparer{T}"/> spécifié
        /// </summary>
        /// <typeparam name="T">Le type des éléments à comparer</typeparam>
        /// <param name="comparer">Le comparateur à inverser</param>
        /// <returns>Un comparateur avec une logique inversée</returns>
        public static IComparer<T> Reverse<T>(this IComparer<T> comparer)
        {
            comparer.CheckArgumentNull("comparer");
            return new ReverseComparer<T>(comparer);
        }

        /// <summary>
        /// Inverse la <see cref="Comparison{T}"/> spécifiée
        /// </summary>
        /// <typeparam name="T">Le type des éléments à comparer</typeparam>
        /// <param name="comparison">La comparaison à inverser</param>
        /// <returns>Une comparaison avec une logique inversée</returns>
        public static Comparison<T> Reverse<T>(this Comparison<T> comparison)
        {
            comparison.CheckArgumentNull("comparison");
            return (x, y) => comparison(y, x);
        }

        /// <summary>
        /// Renvoie le maximum des deux arguments
        /// </summary>
        /// <typeparam name="T">Type des objets à comparer</typeparam>
        /// <param name="comparer">Comparateur à utiliser</param>
        /// <param name="x">Premier objet à comparer</param>
        /// <param name="y">Second objet à comparer</param>
        /// <returns>x si x &gt;= y selon le comparateur spécifié, sinon y</returns>
        public static T Max<T>(this IComparer<T> comparer, T x, T y)
        {
            comparer.CheckArgumentNull("comparer");
            if (comparer.Compare(x, y) >= 0)
                return x;
            return y;
        }

        /// <summary>
        /// Renvoie le minimum des deux arguments
        /// </summary>
        /// <typeparam name="T">Type des objets à comparer</typeparam>
        /// <param name="comparer">Comparateur à utiliser</param>
        /// <param name="x">Premier objet à comparer</param>
        /// <param name="y">Second objet à comparer</param>
        /// <returns>x si x &lt;= y selon le comparateur spécifié, sinon y</returns>
        public static T Min<T>(this IComparer<T> comparer, T x, T y)
        {
            comparer.CheckArgumentNull("comparer");
            if (comparer.Compare(x, y) <= 0)
                return x;
            return y;
        }
    }
}