using System;
using System.Collections.Generic;
using Chernobyl.Event;

namespace Chernobyl.Collections.Generic.Event
{
    /// <summary>
    /// Type that is designed to make the implementation of new 
    /// <see cref="IEventDictionary{TKey, TValue}"/> easier to create.
    /// </summary>
    /// <typeparam name="TKey">The type of the key.</typeparam>
    /// <typeparam name="TValue">The type of the value.</typeparam>
    public abstract class EventDictionary<TKey, TValue> : 
        EventCollection<KeyValuePair<TKey, TValue>>, IEventDictionary<TKey, TValue>
    {
        /// <summary>
        /// Adds an element with the provided key and value to the 
        /// <see cref="IDictionary{TKey, TValue}" />.
        /// </summary>
        /// <param name="key">The object to use as the key of the element to add.</param>
        /// <param name="value">The object to use as the value of the element to add.</param>
        /// <exception cref="ArgumentNullException">The key provided is null.</exception>
        /// <exception cref="ArgumentException">An element with the same key 
        /// already exists in the <see cref="IDictionary{TKey, TValue}" />.</exception>
        /// <exception cref="NotSupportedException">The 
        /// <see cref="IDictionary{TKey, TValue}" /> is read-only.</exception>
        public void Add(TKey key, TValue value)
        {
            var keyValue = new KeyValuePair<TKey, TValue>(key, value);
            DictionaryDecorated.Add(keyValue);

            if(ItemsAddedHandler != null)
                ItemsAddedHandler(this, new ItemsEventArgs<KeyValuePair<TKey, TValue>>(
                    keyValue));
        }

        /// <summary>
        /// Determines whether the <see cref="IDictionary{TKey, TValue}" /> 
        /// contains an element with the specified key.
        /// </summary>
        /// <param name="key">The key to locate in the 
        /// <see cref="IDictionary{TKey, TValue}" />.</param>
        /// <returns>
        /// True if the <see cref="IDictionary{TKey, TValue}" /> contains an 
        /// element with the key; otherwise, false.
        /// </returns>
        /// <exception cref="ArgumentNullException">The key provided is null.</exception>
        public bool ContainsKey(TKey key)
        {
            return DictionaryDecorated.ContainsKey(key);
        }

        /// <summary>
        /// Gets an <see cref="ICollection{TKey}" /> containing the keys of the 
        /// <see cref="IDictionary{TKey, TValue}" />.
        /// </summary>
        public ICollection<TKey> Keys
        {
            get { return DictionaryDecorated.Keys; }
        }

        /// <summary>
        /// Removes the element with the specified key from the 
        /// <see cref="IDictionary{TKey, TValue}" />.
        /// </summary>
        /// <param name="key">The key of the element to remove.</param>
        /// <returns>
        /// true if the element is successfully removed; otherwise, false.  This 
        /// method also returns false if <paramref name="key" /> was not found 
        /// in the original <see cref="IDictionary{TKey, TValue}" />.
        /// </returns>
        /// <exception cref="ArgumentNullException">The key provided is null.</exception>
        /// <exception cref="NotSupportedException">The 
        /// <see cref="IDictionary{TKey,TValue}"/> is read-only.</exception>
        public bool Remove(TKey key)
        {
            bool removed = false;

            TValue valueRemoved;
            if (DictionaryDecorated.TryGetValue(key, out valueRemoved))
            {
                removed = DictionaryDecorated.Remove(key);
                if (removed && ItemsRemovedHandler != null)
                    ItemsRemovedHandler(this, new ItemsEventArgs<KeyValuePair<TKey, TValue>>(
                        new KeyValuePair<TKey, TValue>(key, valueRemoved)));
            }

            return removed;
        }

        /// <summary>
        /// Gets the value associated with the specified key.
        /// </summary>
        /// <param name="key">The key whose value to get.</param>
        /// <param name="value">When this method returns, the value associated 
        /// with the specified key, if the key is found; otherwise, the default 
        /// value for the type of the <paramref name="value" /> parameter. This 
        /// parameter is passed uninitialized.</param>
        /// <returns>
        /// True if the object that implements <see cref="IDictionary{TKey, TValue}" /> 
        /// contains an element with the specified key; otherwise, false.
        /// </returns>
        /// <exception cref="ArgumentNullException">The key provided is null.</exception>
        public bool TryGetValue(TKey key, out TValue value)
        {
            return DictionaryDecorated.TryGetValue(key, out value);
        }

        /// <summary>
        /// Gets an <see cref="ICollection{TKey}" /> containing the values in the 
        /// <see cref="IDictionary{TKey, TValue}" />.
        /// </summary>
        public ICollection<TValue> Values
        {
            get { return DictionaryDecorated.Values; }
        }

        /// <summary>
        /// Gets or sets the element with the specified key.
        /// </summary>
        /// <param name="key">The key of the element to get or set.</param>
        /// <returns>The element with the specified key.</returns>
        /// <exception cref="ArgumentNullException">The key provided is null.</exception>
        /// <exception cref="KeyNotFoundException">The property is retrieved and 
        /// key is not found.</exception>
        /// <exception cref="NotSupportedException">The property is set and the 
        /// <see cref="IDictionary{TKey,TValue}"/> is read-only.</exception>
        public TValue this[TKey key]
        {
            get { return DictionaryDecorated[key]; }
            set
            {
                // Store the old item but only if we need to since the search
                // for that item could be expensive.
                ItemsEventArgs<KeyValuePair<TKey, TValue>> itemRemoved = null;
                if (ItemsRemovedHandler != null)
                    itemRemoved = new ItemsEventArgs<KeyValuePair<TKey, TValue>>(
                        new KeyValuePair<TKey, TValue>(key, DictionaryDecorated[key]));

                DictionaryDecorated[key] = value;

                if (ItemsRemovedHandler != null)
                    ItemsRemovedHandler(this, itemRemoved);

                if (ItemsAddedHandler != null)
                    ItemsAddedHandler(this, new ItemsEventArgs<KeyValuePair<TKey, TValue>>(
                        new KeyValuePair<TKey, TValue>(key, value)));
            }
        }

        /// <summary>
        /// The instance that is being decorated with event capabilities.
        /// </summary>
        protected abstract IDictionary<TKey, TValue> DictionaryDecorated { get; }

        /// <summary>
        /// The <see cref="ICollection{T}" /> being decorated or extended with
        /// event capabilities.
        /// </summary>
        protected override ICollection<KeyValuePair<TKey, TValue>> CollectionDecorated
        {
            get { return DictionaryDecorated; }
        }
    }
}