using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Developpez.Dotnet.Properties;

namespace Developpez.Dotnet.Collections
{
    /// <summary>
    /// Représente un dictionnaire en lecture seule, qui encapsule un autre dictionnaire
    /// </summary>
    /// <typeparam name="TKey">Type de la clé</typeparam>
    /// <typeparam name="TValue">Type de la valeur</typeparam>
    public class ReadOnlyDictionary<TKey, TValue> : DictionaryBase<TKey, TValue>, IDictionary<TKey, TValue>
    {
        /// <summary>
        /// Initialise une nouvelle instance de ReadOnlyDictionary&lt;TKey, TValue&gt;.
        /// </summary>
        public ReadOnlyDictionary()
            : base(new Dictionary<TKey, TValue>())
        {
        }

        /// <summary>
        /// Initialise une nouvelle instance de ReadOnlyDictionary&lt;TKey, TValue&gt;
        /// </summary>
        /// <param name="dictionary">Le dictionnaire à encapsuler</param>
        public ReadOnlyDictionary(IDictionary<TKey, TValue> dictionary)
            : base(dictionary)
        {
        }

        /// <summary>
        /// Initialise une nouvelle instance de ReadOnlyDictionary&lt;TKey, TValue&gt;, en copiant éventuellement les données du dictionnaire original
        /// </summary>
        /// <param name="dictionary">Le dictionnaire à encapsuler ou copier</param>
        /// <param name="copy">true pour réaliser une copie du dictionnaire original ; false pour simplement l'encapsuler.</param>
        public ReadOnlyDictionary(IDictionary<TKey, TValue> dictionary, bool copy)
            : base(dictionary, copy)
        {
        }

        /// <summary>
        /// L'appel de cette méthode correspond à une opération illégale
        /// et lève une NotSupportedException.
        /// </summary>
        /// <param name="key">Clé à ajouter</param>
        /// <param name="value">Valeur à ajotuer</param>
        public override void Add(TKey key, TValue value)
        {
            throw ReadOnlyException();
        }

        /// <summary>
        /// L'appel de cette méthode correspond à une opération illégale
        /// et lève une NotSupportedException.
        /// </summary>
        /// <param name="key">Clé à supprimer</param>
        /// <returns>true si l'élément a été supprimé, false sinon</returns>
        public override bool Remove(TKey key)
        {
            throw ReadOnlyException();
        }

        /// <summary>
        /// Obtient la valeur correspondant à la clé spécifiée
        /// </summary>
        /// <param name="key">La clé pour laquelle on veut obtenir la valeur</param>
        /// <returns>La valeur correspondant à la clé</returns>
        public override TValue this[TKey key]
        {
            get
            {
                return base[key];
            }
            set
            {
                throw ReadOnlyException();
            }
        }

        /// <summary>
        /// L'appel de cette méthode correspond à une opération illégale
        /// et lève une NotSupportedException.
        /// </summary>
        public override void Clear()
        {
            throw ReadOnlyException();
        }

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

        /// <summary>
        /// L'appel de cette méthode correspond à une opération illégale
        /// et lève une NotSupportedException.
        /// </summary>
        /// <param name="item">L'élément à ajouter</param>
        public override void Add(KeyValuePair<TKey, TValue> item)
        {
            throw ReadOnlyException();
        }

        /// <summary>
        /// L'appel de cette méthode correspond à une opération illégale
        /// et lève une NotSupportedException.
        /// </summary>
        /// <param name="item">La paire clé/valeur à supprimer</param>
        /// <returns>true si l'élément a été supprimé, false sinon</returns>
        public override bool Remove(KeyValuePair<TKey, TValue> item)
        {
            throw ReadOnlyException();
        }

        private static Exception ReadOnlyException()
        {
            return new NotSupportedException(ExceptionMessages.DictionaryIsReadOnly);
        }

        /// <summary>
        /// Crée une nouvelle instance de ReadOnlyDictionary&lt;TKey, TValue&gt; à partir d'un dictionnaire non générique.
        /// Les données sont copiées à partir du dictionnaire d'origine.
        /// </summary>
        /// <param name="dictionary">le dictionnaire d'origine</param>
        /// <returns>Une instance de ReadOnlyDictionary&lt;TKey, TValue&gt; créée à partir du dictionnaire non générique spécifié</returns>
        /// <exception cref="System.InvalidCastException">Les données du dictionnaire d'origine ne correspondent pas aux paramètres de type générique spécifiés</exception>
        public static ReadOnlyDictionary<TKey, TValue> FromNonGenericDictionary(IDictionary dictionary)
        {
            var dic = 
                dictionary
                    .Cast<DictionaryEntry>()
                    .ToDictionary(
                        e => (TKey)e.Key,
                        e => (TValue)e.Value);

            return new ReadOnlyDictionary<TKey, TValue>(dic);
        }
    }
}