using System.Collections.Generic;

namespace Developpez.Dotnet.Collections
{
    /// <summary>
    /// Classe de base pour implémenter des dictionnaires personnalisés, sans avoir à implémenter
    /// chaque méthode de IDictionary&lt;K, V&gt;. Toutes les méthodes et propriétés sont virtuelles,
    /// et délèguent leur implémentation à un IDictionary&lt;K, V&gt; passé en paramètre du constructeur
    /// protégé.
    /// </summary>
    /// <typeparam name="TKey">Type de la clé</typeparam>
    /// <typeparam name="TValue">Type de la valeur</typeparam>
    public abstract class DictionaryBase<TKey, TValue> : IDictionary<TKey, TValue>
    {
        private readonly IDictionary<TKey, TValue> _dictionary;

        /// <summary>
        /// Initialise une nouvelle instance de DictionaryBase&lt;TKey, TValue&gt; qui délègue son implémentation
        /// au dictionaire passé en paramètre
        /// </summary>
        /// <param name="dictionary">Le dictionnaire auquel déléguer l'implémentation</param>
        protected DictionaryBase(IDictionary<TKey, TValue> dictionary)
            : this(dictionary, false)
        {
        }

        /// <summary>
        /// Initialise une nouvelle instance de DictionaryBase&lt;TKey, TValue&gt; qui délègue son implémentation
        /// au dictionaire passé en paramètre, ou a une copie de ce dictionnaire
        /// </summary>
        /// <param name="dictionary">Le dictionnaire auquel déléguer l'implémentation</param>
        /// <param name="copy">true pour réaliser une copie du dictionnaire original ; false pour simplement l'encapsuler</param>
        protected DictionaryBase(IDictionary<TKey, TValue> dictionary, bool copy)
        {
            dictionary.CheckArgumentNull("dictionary");
            if (copy)
                _dictionary = new Dictionary<TKey, TValue>(dictionary);
            else
                _dictionary = dictionary;
        }

        #region IDictionary<K,V> Members

        /// <summary>
        /// Ajoute la clé et la valeur spécifiées au dictionnaire. 
        /// </summary>
        /// <param name="key">Clé de l'élément à ajouter. </param>
        /// <param name="value">Valeur de l'élément à ajouter. La valeur peut être null pour les types référence.</param>
        public virtual void Add(TKey key, TValue value)
        {
            _dictionary.Add(key, value);
        }

        /// <summary>
        /// Détermine si le dictionnaire contient la clé spécifiée. 
        /// </summary>
        /// <param name="key">Clé à rechercher</param>
        /// <returns>true si le dictionnaire contient un élément correspondant à la clé spécifiée ; sinon, false.</returns>
        public virtual bool ContainsKey(TKey key)
        {
            return _dictionary.ContainsKey(key);
        }
        
        /// <summary>
        /// Obtient une collection contenant les clés du dictionnaire.
        /// </summary>
        public virtual ICollection<TKey> Keys
        {
            get { return _dictionary.Keys; }
        }

        /// <summary>
        /// Supprime du dictionnaire la valeur ayant la clé spécifiée. 
        /// </summary>
        /// <param name="key">Clé de l'élément à supprimer.</param>
        /// <returns>true si la recherche et la suppression de l'élément réussissent ; sinon, false.</returns>
        public virtual bool Remove(TKey key)
        {
            return _dictionary.Remove(key);
        }

        /// <summary>
        /// Obtient la valeur associée à la clé spécifiée. 
        /// </summary>
        /// <param name="key">Clé de la valeur à obtenir.</param>
        /// <param name="value">Paramètre de sortie auquel est affecté la valeur trouvée</param>
        /// <returns>true si le dictionnaire contient un élément correspondant à la clé spécifiée ; sinon, false.</returns>
        public virtual bool TryGetValue(TKey key, out TValue value)
        {
            return _dictionary.TryGetValue(key, out value);
        }

        /// <summary>
        /// Obtient une collection contenant les valeurs du dictionnaire.
        /// </summary>
        public virtual ICollection<TValue> Values
        {
            get { return _dictionary.Values; }
        }

        /// <summary>
        /// Obtient ou définit la valeur associée à la clé spécifiée.
        /// </summary>
        /// <param name="key">Clé de l'élément à obtenir ou à définir</param>
        /// <value>Valeur associée à la clé spécifiée. Si la clé spécifiée est introuvable, une opération Get retourne KeyNotFoundException et une opération Set crée un nouvel élément avec la clé spécifiée.</value>
        public virtual TValue this[TKey key]
        {
            get
            {
                return _dictionary[key];
            }
            set
            {
                _dictionary[key] = value;
            }
        }

        #endregion

        #region ICollection<KeyValuePair<K,V>> Members

        /// <summary>
        /// Ajoute la paire clé/valeur spécifiée au dictionnaire 
        /// </summary>
        /// <param name="item">Paire clé/valeur à ajouter</param>
        public virtual void Add(KeyValuePair<TKey, TValue> item)
        {
            _dictionary.Add(item);
        }

        /// <summary>
        /// Supprime toutes les clés et les valeurs du dictionnaire.
        /// </summary>
        public virtual void Clear()
        {
            _dictionary.Clear();
        }

        /// <summary>
        /// Détermine si le dictionnaire contient la paire clé/valeur spécifiée.
        /// </summary>
        /// <param name="item">Paire clé/valeur recherchée</param>
        /// <returns>true si le dictionnaire contient la paire clé/valeur, false sinon</returns>
        public virtual bool Contains(KeyValuePair<TKey, TValue> item)
        {
            return _dictionary.Contains(item);
        }

        /// <summary>
        /// Copie les éléments du dictionnaire dans un tableau, à partir de la position spécifiée
        /// </summary>
        /// <param name="array">Tableau de destination</param>
        /// <param name="arrayIndex">Index du tableau où commencer la copie</param>
        public virtual void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
        {
            _dictionary.CopyTo(array, arrayIndex);
        }

        /// <summary>
        /// Obtient le nombre de paires clé/valeur contenues dans le dictionnaire.
        /// </summary>
        public virtual int Count
        {
            get { return _dictionary.Count; }
        }

        /// <summary>
        /// Obtient une valeur indiquant si le dictionnaire est en lecture seule.
        /// </summary>
        public virtual bool IsReadOnly
        {
            get { return _dictionary.IsReadOnly; }
        }

        /// <summary>
        /// Supprime du dictionnaire la paire clé/valeur spécifiée.
        /// </summary>
        /// <param name="item">Paire clé/valeur</param>
        /// <returns>true si la recherche et la suppression de l'élément réussissent ; sinon, false.</returns>
        public virtual bool Remove(KeyValuePair<TKey, TValue> item)
        {
            return _dictionary.Remove(item);
        }

        #endregion

        #region IEnumerable<KeyValuePair<K,V>> Members

        /// <summary>
        /// Retourne un énumérateur qui parcourt le dictionnaire
        /// </summary>
        /// <returns>Un énumerateur pour parcourir le dictionnaire</returns>
        public virtual IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
        {
            return _dictionary.GetEnumerator();
        }

        #endregion

        #region IEnumerable Members

        /// <summary>
        /// Retourne un énumérateur qui parcourt le dictionnaire
        /// </summary>
        /// <returns>Un énumerateur pour parcourir le dictionnaire</returns>
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }

        #endregion

    }
}