using System;
using System.Collections;
using System.Collections.Generic;
namespace DTS.Common.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>
    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);
        }

        /// <inheritdoc />
        /// <summary>
        /// Returns all keys in collection
        /// </summary>
        public ICollection<TKey> Keys => _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 => _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 => _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 => _items.Count;

        /// <summary>
        /// Returns true if readonly collection
        /// </summary>
        public bool IsReadOnly => 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)
        {
            CollectionItemPropertyChanged?.Invoke(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)
        {
            CollectionItemPropertyChanged?.Invoke(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)
        {
            CollectionItemPropertyChanged?.Invoke(this, new SettingsChangedEventArgs<TKey, TItem>(changeType, key, item));
        }

        #endregion
    }
}