using System;
using System.Collections.Generic;

namespace Developpez.Dotnet.Collections
{
    /// <summary>
    /// Fournit des méthodes d'extension pour travailler avec des IComparer&lt;T&gt; et des Comparison&lt;T&gt;
    /// </summary>
    public static class CompareExtensions
    {
        /// <summary>
        /// Obtient un IComparer&lt;T&gt; à 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 IComparer&lt;T&gt; qui utilise la comparaison spécifiée</returns>
        public static IComparer<T> ToComparer<T>(this Comparison<T> comparison)
        {
            return new ComparisonComparer<T>(comparison);
        }

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

        /// <summary>
        /// Inverse le IComparer&lt;T&gt; 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)
        {
            return new ReverseComparer<T>(comparer);
        }

        /// <summary>
        /// Inverse la Comparison&lt;T&gt; 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)
        {
            return (x, y) => comparison(y, x);
        }
    }
}