using System;
using System.Collections;
using System.Collections.Generic;
namespace DataPro.Core.Settings
{
    /// <summary>
    /// Implements a dictionary with events when an item is changed
    /// </summary>
    /// <typeparam name="TKey">key type</typeparam>
    /// <typeparam name="TItem">value type</typeparam>
    /// <history>
    /// <list type="number">
    /// <item>{01/22/2014}. {RCD}.  {Initial Version}</item>
    /// </list>
    /// </history>
    public class SettingsCollection<TKey, TItem> : IDictionary<TKey, TItem>
    {
        /// <summary>
        /// Event fired when an item changes in dictionary
        /// </summary>
        public event EventHandler<SettingsChangedEventArgs<TKey, TItem>> CollectionItemPropertyChanged;

        /// <summary>
        /// List of stored items
        /// </summary>
        private readonly Dictionary<TKey, TItem> _items = new Dictionary<TKey, TItem>();


        #region IDictionary

        /// <summary>
        /// Add item
        /// </summary>
        /// <param name="key">key</param>
        /// <param name="value">value</param>
        public void Add(TKey key, TItem value)
        {
            _items.Add(key, value);
            FireItemChangedEvent(ChangeSettingType.Add, key, value);
        }

        /// <summary>
        /// Returns true if item contains key
        /// </summary>
        /// <param name="key">key</param>
        /// <returns>true if key exists</returns>
        public bool ContainsKey(TKey key)
        {
            return _items.ContainsKey(key);
        }

        /// <summary>
        /// Returns all keys in collection
        /// </summary>
        public ICollection<TKey> Keys
        {
            get { return _items.Keys; }
        }

        /// <summary>
        /// Removes key
        /// </summary>
        /// <param name="key">key</param>
        /// <returns>true if key removed</returns>
        public bool Remove(TKey key)
        {
            var res = _items.Remove(key);
            if (res) FireItemChangedEvent(ChangeSettingType.Remove, key);

            return res;
        }

        /// <summary>
        /// Trys to get specified value
        /// </summary>
        /// <param name="key">key</param>
        /// <param name="value">value if key exists</param>
        /// <returns>true if key exists; false if it doesn't exist</returns>
        public bool TryGetValue(TKey key, out TItem value)
        {
            return _items.TryGetValue(key, out value);
        }

        /// <summary>
        /// List of values in collection
        /// </summary>
        public ICollection<TItem> Values
        {
            get { return _items.Values; }
        }

        /// <summary>
        /// Gets/sets item in collection (overloads [] operator)
        /// </summary>
        /// <param name="key">key</param>
        /// <returns>item in collection</returns>
        public TItem this[TKey key]
        {
            get
            {
                return _items[key];
            }
            set
            {
                _items[key] = value;
                FireItemChangedEvent(ChangeSettingType.Add, key, value);
            }
        }

        /// <summary>
        /// Adds new item
        /// </summary>
        /// <param name="item">new item to add</param>
        public void Add(KeyValuePair<TKey, TItem> item)
        {
            _items.Add(item.Key, item.Value);
            FireItemChangedEvent(ChangeSettingType.Add, item.Key, item.Value);
        }

        /// <summary>
        /// Clears entire collection
        /// </summary>
        public void Clear()
        {
            _items.Clear();
            FireItemChangedEvent(ChangeSettingType.ClearAll);
        }

        /// <summary>
        /// Returns true if item is in collection
        /// </summary>
        /// <param name="item">item to check</param>
        /// <returns>true if item exists</returns>
        public bool Contains(KeyValuePair<TKey, TItem> item)
        {
            return _items.ContainsKey(item.Key) && _items.ContainsValue(item.Value);
        }

        /// <summary>
        /// Copys items to array
        /// </summary>
        /// <param name="array"></param>
        /// <param name="arrayIndex"></param>
        public void CopyTo(KeyValuePair<TKey, TItem>[] array, int arrayIndex)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Returns count of items
        /// </summary>
        public int Count
        {
            get { return _items.Count; }
        }

        /// <summary>
        /// Returns true if readonly collection
        /// </summary>
        public bool IsReadOnly
        {
            get { return false; }
        }

        /// <summary>
        /// Removes specified item
        /// </summary>
        /// <param name="item">item to remove</param>
        /// <returns>true if item removed</returns>
        public bool Remove(KeyValuePair<TKey, TItem> item)
        {
            var res = _items.Remove(item.Key);
            if (res) FireItemChangedEvent(ChangeSettingType.Remove, item.Key);

            return res;
        }

        /// <summary>
        /// Return enumerator for collection
        /// </summary>
        /// <returns>enumerator</returns>
        public IEnumerator<KeyValuePair<TKey, TItem>> GetEnumerator()
        {
            return _items.GetEnumerator();
        }

        /// <summary>
        /// Return enumerator for collection
        /// </summary>
        /// <returns>enumerator</returns>
        IEnumerator IEnumerable.GetEnumerator()
        {
            return _items.GetEnumerator();
        }

        #endregion

        #region Private methods

        /// <summary>
        /// Fires collection change event
        /// </summary>
        /// <param name="changeType">type of change</param>
        private void FireItemChangedEvent(ChangeSettingType changeType)
        {
            if (CollectionItemPropertyChanged != null)
            {
                CollectionItemPropertyChanged(this, new SettingsChangedEventArgs<TKey, TItem>(changeType));
            }
        }

        /// <summary>
        /// Fires collection change event
        /// </summary>
        /// <param name="changeType">type of change</param>
        /// <param name="key">key</param>
        private void FireItemChangedEvent(ChangeSettingType changeType, TKey key)
        {
            if (CollectionItemPropertyChanged != null)
            {
                CollectionItemPropertyChanged(this, new SettingsChangedEventArgs<TKey, TItem>(changeType, key));
            }
        }

        /// <summary>
        /// Fires collection change event
        /// </summary>
        /// <param name="changeType">type of change</param>
        /// <param name="key">key</param>
        /// <param name="item">item</param>
        private void FireItemChangedEvent(ChangeSettingType changeType, TKey key, TItem item)
        {
            if (CollectionItemPropertyChanged != null)
            {
                CollectionItemPropertyChanged(this, new SettingsChangedEventArgs<TKey, TItem>(changeType, key, item));
            }
        }

        #endregion
    }
}