using System;
using System.Collections.Generic;

namespace Developpez.Dotnet.Collections
{
    /// <summary>
    /// Comparateur d'égalité qui comparer 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 KeyEqualityComparer<T, TKey> : IEqualityComparer<T>
    {
        private readonly Func<T, TKey> _keySelector;
        private readonly IEqualityComparer<TKey> _keyComparer;

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

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

        /// <summary>
        /// Détermine si les objets spécifiés sont égaux.
        /// </summary>
        /// <param name="x">Le premier objet à comparer</param>
        /// <param name="y">Le deuxième objet à comparer</param>
        /// <returns>true si les objets spécifiés sont égaux ; sinon, false.</returns>
        public bool Equals(T x, T y)
        {
            return _keyComparer.Equals(_keySelector(x), _keySelector(y));
        }

        /// <summary>
        /// Retourne un code de hachage pour l'objet spécifié.
        /// </summary>
        /// <param name="obj">Objet pour lequel un code de hachage doit être retourné.</param>
        /// <returns>Code de hachage pour l'objet spécifié.</returns>
        public int GetHashCode(T obj)
        {
            return _keyComparer.GetHashCode(_keySelector(obj));
        }
    }

    /// <summary>
    /// Classe statique pour faciliter la création de KeyEqualityComparer quand le type de la clé est anonyme
    /// </summary>
    /// <typeparam name="T">Type des objets comparés</typeparam>
    public static class KeyEqualityComparer<T>
    {
        /// <summary>
        /// Crée un KeyEqualityComparer 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 d'égalité qui utilise la clé spécifiée</returns>
        public static IEqualityComparer<T> Create<TKey>(Func<T, TKey> keySelector)
        {
            return Create(keySelector, null);
        }

        /// <summary>
        /// Crée un KeyEqualityComparer 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 tester l'égalité de 2 clés.</param>
        /// <returns>Un comparateur d'égalité qui utilise la clé spécifiée</returns>
        /// <remarks>Si keyComparer est null, le comparateur par défaut est utilisé.</remarks>
        public static IEqualityComparer<T> Create<TKey>(Func<T, TKey> keySelector, IEqualityComparer<TKey> keyComparer)
        {
            return new KeyEqualityComparer<T, TKey>(keySelector, keyComparer);
        }
    }

    /// <summary>
    /// Classe statique pour faciliter la création de KeyEqualityComparer pour des objets de type anonyme
    /// </summary>
    public static class KeyEqualityComparer
    {
        /// <summary>
        /// Crée un KeyEqualityComparer 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 d'égalité qui utilise la clé spécifiée</returns>
        public static IEqualityComparer<T> Create<T, TKey>(T dummy, Func<T, TKey> keySelector)
        {
            return Create(dummy, keySelector, null);
        }

        /// <summary>
        /// Crée un KeyEqualityComparer 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 tester l'égalité de 2 clés.</param>
        /// <returns>Un comparateur d'égalité qui utilise la clé spécifiée</returns>
        /// <remarks>Si keyComparer est null, le comparateur par défaut est utilisé.</remarks>
        public static IEqualityComparer<T> Create<T, TKey>(T dummy, Func<T, TKey> keySelector, IEqualityComparer<TKey> keyComparer)
        {
            return new KeyEqualityComparer<T, TKey>(keySelector, keyComparer);
        }
    }
}