using System;
using System.Collections.Generic;
using System.Linq;

namespace Developpez.Dotnet.Collections
{
    /// <summary>
    /// Fournit des méthodes d'extension pour manipuler des dictionnaires
    /// </summary>
    public static class DictionaryExtensions
    {
        /// <summary>
        /// Renvoie la valeur correspondant à la clé spécifiée si celle-ci est présente dans le dictionnaire,
        /// ou la valeur par défaut spécifiée si la clé est absente.
        /// </summary>
        /// <typeparam name="TKey">Type de la clé</typeparam>
        /// <typeparam name="TValue">Type de la valeur</typeparam>
        /// <param name="dictionary">Le dictionnaire à partir duquel renvoyer la valeur</param>
        /// <param name="key">La clé recherchée</param>
        /// <param name="defaultValue">La valeur par défaut à renvoyer si la clé est absente du dictionnaire</param>
        /// <returns>Si la clé est présente, renvoie la valeur correspondante. Sinon, renvoie la valeur par défaut</returns>
        public static TValue GetValueOrDefault<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key, TValue defaultValue)
        {
            TValue value;
            if (!dictionary.TryGetValue(key, out value))
                value = defaultValue;
            return value;
        }

        /// <summary>
        /// Renvoie la valeur correspondant à la clé spécifiée si celle-ci est présente dans le dictionnaire,
        /// ou la valeur par défaut du type de la valeur si la clé est absente.
        /// </summary>
        /// <typeparam name="TKey">Type de la clé</typeparam>
        /// <typeparam name="TValue">Type de la valeur</typeparam>
        /// <param name="dictionary">Le dictionnaire à partir duquel renvoyer la valeur</param>
        /// <param name="key">La clé recherchée</param>
        /// <returns>Si la clé est présente, renvoie la valeur correspondante. Sinon, renvoie la valeur par défaut</returns>
        public static TValue GetValueOrDefault<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key)
        {
            return dictionary.GetValueOrDefault(key, default(TValue));
        }

        /// <summary>
        /// Renvoie la valeur correspondant à la clé spécifiée si celle-ci est présente dans le dictionnaire.
        /// Sinon, utilise la fonction fournie pour générer la valeur, l'ajoute au dictionnaire, et renvoie cette valeur.
        /// </summary>
        /// <typeparam name="TKey">Type de la clé</typeparam>
        /// <typeparam name="TValue">Type de la valeur</typeparam>
        /// <param name="dictionary">Le dictionnaire à partir duquel renvoyer la valeur</param>
        /// <param name="key">La clé recherchée</param>
        /// <param name="valueFactory">La fonction utilisée pour générer la valeur si la clé est absente.</param>
        /// <returns>La valeur correspondant à la clé. Si la clé demandée n'existe pas dans le dictionnaire, la valeur est générée par la fonction fournie et ajoutée au dictionnaire avant d'être renvoyée.</returns>
        public static TValue GetOrAdd<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TValue> valueFactory)
        {
            return dictionary.GetOrCreate(key, valueFactory, true);
        }

        /// <summary>
        /// Renvoie la valeur correspondant à la clé spécifiée si celle-ci est présente dans le dictionnaire.
        /// Sinon, utilise la fonction fournie pour générer la valeur et renvoie cette valeur. La valeur générée
        /// n'est pas ajoutée au dictionnaire.
        /// </summary>
        /// <typeparam name="TKey">Type de la clé</typeparam>
        /// <typeparam name="TValue">Type de la valeur</typeparam>
        /// <param name="dictionary">Le dictionnaire à partir duquel renvoyer la valeur</param>
        /// <param name="key">La clé recherchée</param>
        /// <param name="valueFactory">La fonction utilisée pour générer la valeur si la clé est absente.</param>
        /// <returns>La valeur correspondant à la clé. Si la clé demandée n'existe pas dans le dictionnaire, la valeur est générée par la fonction fournie.</returns>
        public static TValue GetOrCreate<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TValue> valueFactory)
        {
            return dictionary.GetOrCreate(key, valueFactory, false);
        }

        private static TValue GetOrCreate<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TValue> valueFactory, bool addIfMissing)
        {
            TValue value;
            if (!dictionary.TryGetValue(key, out value))
            {
                value = valueFactory(key);
                if (addIfMissing)
                    dictionary[key] = value;
            }
            return value;
        }

        /// <summary>
        /// Renvoie un wrapper en lecture seule pour un dictionnaire
        /// </summary>
        /// <typeparam name="TKey">Type de la clé</typeparam>
        /// <typeparam name="TValue">Type de la valeur</typeparam>
        /// <param name="dictionary">Le dictionnaire pour lequel renvoyer un wrapper</param>
        /// <returns>Un wrapper en lecture seule du dictionnaire</returns>
        public static ReadOnlyDictionary<TKey, TValue> AsReadOnly<TKey, TValue>(this IDictionary<TKey, TValue> dictionary)
        {
            return new ReadOnlyDictionary<TKey, TValue>(dictionary);
        }

        /// <summary>
        /// Renvoie un wrapper ou une copie en lecture seule pour un dictionnaire
        /// </summary>
        /// <typeparam name="TKey">Type de la clé</typeparam>
        /// <typeparam name="TValue">Type de la valeur</typeparam>
        /// <param name="dictionary">Le dictionnaire pour lequel renvoyer un wrapper</param>
        /// <param name="copy">true pour renvoyer une copie en lecture seule du dictionnaire ; false pour renvoyer simplement un wrapper du dictionnaire existant</param>
        /// <returns>Un wrapper ou une copie en lecture seule du dictionnaire</returns>
        public static ReadOnlyDictionary<TKey, TValue> AsReadOnly<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, bool copy)
        {
            return new ReadOnlyDictionary<TKey, TValue>(dictionary, copy);
        }

        /// <summary>
        /// Reconstruit un dictionnaire à partir d'une séquence de paires clé/valeur
        /// </summary>
        /// <typeparam name="TKey">Type de la clé</typeparam>
        /// <typeparam name="TValue">Type de la valeur</typeparam>
        /// <param name="source">Séquence de paires clé/valeur</param>
        /// <returns>Un dictionnaire qui contient les paires clé/valeur de la séquence d'origine</returns>
        public static IDictionary<TKey, TValue> ToDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source)
        {
            return source.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
        }
    }
}