using System;
using System.Collections.Generic;

namespace Developpez.Dotnet.Collections
{
    /// <summary>
    /// Représente un dictionnaire dont toutes les clés sont supposées définies. Si la clé demandée
    /// n'existe pas dans le dictionnaire, une valeur par défaut est renvoyée. Cette valeur par défaut
    /// est automatiquement ajoutée au dictionnaire avec la clé associée, sauf indication contraire.
    /// </summary>
    /// <typeparam name="TKey">Type de la clé</typeparam>
    /// <typeparam name="TValue">Type de la valeur</typeparam>
    public class DefaultDictionary<TKey, TValue> : DictionaryBase<TKey, TValue>
    {
        private readonly bool _addMissingKeys;
        private readonly Func<TKey, TValue> _defaultValueGenerator;

        /// <summary>
        /// Initialise une nouvelle instance de DefaultDictionary&lt;T&gt;. Si la clé demandée est absente,
        /// la valeur par défaut du type <c>V</c> est renvoyée.
        /// </summary>
        public DefaultDictionary()
            : this(k => default(TValue), true)
        {
        }

        /// <summary>
        /// Initialise une nouvelle instance de DefaultDictionary&lt;T&gt;. Si la clé demandée est absente,
        /// la valeur par défaut du type <c>V</c> est renvoyée. Si <c>addMissingKeys</c> vaut true, la valeur
        /// par défaut est ajoutée au dictionnaire avec la clé associée.
        /// </summary>
        /// <param name="addMissingKeys">true pour ajouter automatiquement au dictionnaire les clés manquantes et leur valeur associée ; sinon, false</param>
        public DefaultDictionary(bool addMissingKeys)
            : this(k => default(TValue), addMissingKeys)
        {
        }

        /// <summary>
        /// Initialise une nouvelle instance de DefaultDictionary&lt;T&gt;. Si la clé demandée est absente,
        /// la valeur par défaut spécifiée est renvoyée.
        /// </summary>
        /// <param name="defaultValue">La valeur par défaut à utiliser pour les clés absentes</param>
        public DefaultDictionary(TValue defaultValue)
            : this(k => defaultValue, true)
        {
        }

        /// <summary>
        /// Initialise une nouvelle instance de DefaultDictionary&lt;T&gt;. Si la clé demandée est absente,
        /// la valeur par défaut spécifiée est renvoyée. Si <c>addMissingKeys</c> vaut true, la valeur
        /// par défaut est ajoutée au dictionnaire avec la clé associée.
        /// </summary>
        /// <param name="defaultValue">La valeur par défaut à utiliser pour les clés absentes</param>
        /// <param name="addMissingKeys">true pour ajouter automatiquement au dictionnaire les clés manquantes et leur valeur associée ; sinon, false</param>
        public DefaultDictionary(TValue defaultValue, bool addMissingKeys)
            : this(k => defaultValue, addMissingKeys)
        {
        }

        /// <summary>
        /// Initialise une nouvelle instance de DefaultDictionary&lt;T&gt;. Si la clé demandée est absente,
        /// la valeur générée par le delegate fourni en paramètre est renvoyée.
        /// </summary>
        /// <param name="defaultValueGenerator">Une fonction qui renvoie une valeur initiale pour une clé absente</param>
        public DefaultDictionary(Func<TKey, TValue> defaultValueGenerator)
            : this(defaultValueGenerator, true)
        {
        }

        /// <summary>
        /// Initialise une nouvelle instance de DefaultDictionary&lt;T&gt;. Si la clé demandée est absente,
        /// la valeur générée par le delegate fourni en paramètre est renvoyée. Si <c>addMissingKeys</c> vaut true, la valeur
        /// par défaut est ajoutée au dictionnaire avec la clé associée.
        /// </summary>
        /// <param name="defaultValueGenerator">Une fonction qui renvoie une valeur initiale pour une clé absente</param>
        /// <param name="addMissingKeys">true pour ajouter automatiquement au dictionnaire les clés manquantes et leur valeur associée ; sinon, false</param>
        public DefaultDictionary(Func<TKey, TValue> defaultValueGenerator, bool addMissingKeys)
            : base(new Dictionary<TKey, TValue>())
        {
            _defaultValueGenerator = defaultValueGenerator;
            _addMissingKeys = addMissingKeys;
        }

        /// <summary>
        /// Renvoie une valeur indiquant si ce dictionnaire ajoute automatiquement
        /// les clés manquantes et leur valeur associée lorsqu'elles sont demandées
        /// </summary>
        public bool AddMissingKeys
        {
            get { return _addMissingKeys; }
        }

        /// <summary>
        /// Obtient la valeur associée à la clé spécifiée. Si la clé n'existe pas, une valeur par défaut est renvoyée
        /// </summary>
        /// <param name="key">La clé pour laquelle retourner une valeur</param>
        /// <returns>La valeur correspondant à la clé</returns>
        public override TValue this[TKey key]
        {
            get
            {
                TValue value;
                if (!base.TryGetValue(key, out value))
                {
                    value = _defaultValueGenerator(key);
                    if (_addMissingKeys)
                        this[key] = value;
                }
                return value;
            }
            set
            {
                base[key] = value;
            }
        }

        /// <summary>
        /// Obtient la valeur associée à la clé spécifiée. Si la clé n'existe pas, une valeur par défaut est renvoyée.
        /// </summary>
        /// <param name="key">La clé recherchée</param>
        /// <param name="value">Paramètre de sortie auquel la valeur trouvée est affectée</param>
        /// <returns>Toujours true</returns>
        public override bool TryGetValue(TKey key, out TValue value)
        {
            value = this[key];
            return true;
        }
    }
}