using System;
using System.Collections.Generic;

namespace Developpez.Dotnet.Collections
{
    /// <summary>
    /// Comparateur qui compare des objets selon la clé spécifiée
    /// </summary>
    /// <typeparam name="T">Type des objets comparés</typeparam>
    /// <typeparam name="TKey">Type de la clé de comparaison</typeparam>
    public class KeyComparer<T, TKey> : IComparer<T>
    {
        private readonly Func<T, TKey> _keySelector;
        private readonly IComparer<TKey> _keyComparer;

        /// <summary>
        /// Crée une nouvelle instance de <see cref="KeyComparer{T, TKey}"/>.
        /// </summary>
        /// <param name="keySelector">Fonction qui renvoie la clé à partir d'un objet</param>
        public KeyComparer(Func<T, TKey> keySelector) : this(keySelector, null)
        {
        }

        /// <summary>
        /// Crée une nouvelle instance de <see cref="KeyComparer{T, TKey}"/>.
        /// </summary>
        /// <param name="keySelector">Fonction qui renvoie la clé à partir d'un objet</param>
        /// /// <param name="keyComparer">Comparateur à utiliser pour comparer 2 clés.</param>
        /// <remarks>Si keyComparer est null, le comparateur par défaut est utilisé.</remarks>
        public KeyComparer(Func<T, TKey> keySelector, IComparer<TKey> keyComparer)
        {
            keySelector.CheckArgumentNull("keySelector");
            _keySelector = keySelector;
            _keyComparer = keyComparer ?? Comparer<TKey>.Default;
        }

        /// <summary>
        /// Compare deux objets et retourne une valeur indiquant si l'un d'entre eux est inférieur, égal ou supérieur à l'autre.
        /// </summary>
        /// <param name="x">Premier objet à comparer</param>
        /// <param name="y">Second objet à comparer</param>
        /// <returns>Entier signé qui indique les valeurs relatives de x et y, comme indiqué dans le tableau suivant.
        /// <list type="table">
        ///   <listheader>
        ///     <term>Valeur</term>
        ///     <description>Signification</description>
        ///   </listheader>
        ///   <item>
        ///     <term>Inférieure à zéro</term>
        ///     <description>x est inférieur à y.</description>
        ///   </item>
        ///   <item>
        ///     <term>Zéro</term>
        ///     <description>x est égal à y.</description>
        ///   </item>
        ///   <item>
        ///     <term>Supérieure à zéro</term>
        ///     <description>x est supérieur à y.</description>
        ///   </item>
        /// </list>
        /// </returns>
        public int Compare(T x, T y)
        {
            return _keyComparer.Compare(_keySelector(x), _keySelector(y));
        }
    }

    /// <summary>
    /// Classe statique pour faciliter la création de KeyComparer quand le type de la clé est anonyme
    /// </summary>
    /// <typeparam name="T">Type des objets comparés</typeparam>
    public static class KeyComparer<T>
    {
        /// <summary>
        /// Crée un KeyComparer qui utilise la clé spécifié
        /// </summary>
        /// <typeparam name="TKey">Type de la clé</typeparam>
        /// <param name="keySelector">Fonction qui renvoie la clé à partir d'un objet</param>
        /// <returns>Un comparateur qui utilise la clé spécifiée</returns>
        public static IComparer<T> Create<TKey>(Func<T, TKey> keySelector)
        {
            return Create(keySelector, null);
        }

        /// <summary>
        /// Crée un KeyComparer qui utilise la clé spécifié
        /// </summary>
        /// <typeparam name="TKey">Type de la clé</typeparam>
        /// <param name="keySelector">Fonction qui renvoie la clé à partir d'un objet</param>
        /// <param name="keyComparer">Comparateur à utiliser pour comparer 2 clés.</param>
        /// <returns>Un comparateur qui utilise la clé spécifiée</returns>
        /// <remarks>Si keyComparer est null, le comparateur par défaut est utilisé.</remarks>
        public static IComparer<T> Create<TKey>(Func<T, TKey> keySelector, IComparer<TKey> keyComparer)
        {
            return new KeyComparer<T, TKey>(keySelector, keyComparer);
        }
    }

    /// <summary>
    /// Classe statique pour faciliter la création de KeyComparer pour des objets de type anonyme
    /// </summary>
    public static class KeyComparer
    {
        /// <summary>
        /// Crée un KeyComparer qui utilise la clé spécifié
        /// </summary>
        /// <typeparam name="T">Type des objets comparés</typeparam>
        /// <typeparam name="TKey">Type de la clé</typeparam>
        /// <param name="dummy">Objet modèle pour déterminer le type des objets comparés</param>
        /// <param name="keySelector">Fonction qui renvoie la clé à partir d'un objet</param>
        /// <returns>Un comparateur qui utilise la clé spécifiée</returns>
        public static IComparer<T> Create<T, TKey>(T dummy, Func<T, TKey> keySelector)
        {
            return Create(dummy, keySelector, null);
        }

        /// <summary>
        /// Crée un KeyComparer qui utilise la clé spécifié
        /// </summary>
        /// <typeparam name="T">Type des objets comparés</typeparam>
        /// <typeparam name="TKey">Type de la clé</typeparam>
        /// <param name="dummy">Objet modèle pour déterminer le type des objets comparés</param>
        /// <param name="keySelector">Fonction qui renvoie la clé à partir d'un objet</param>
        /// <param name="keyComparer">Comparateur à utiliser pour comparer de 2 clés.</param>
        /// <returns>Un comparateur qui utilise la clé spécifiée</returns>
        /// <remarks>Si keyComparer est null, le comparateur par défaut est utilisé.</remarks>
        public static IComparer<T> Create<T, TKey>(T dummy, Func<T, TKey> keySelector, IComparer<TKey> keyComparer)
        {
            return new KeyComparer<T, TKey>(keySelector, keyComparer);
        }
    }

}