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

namespace Chernobyl.Collections.Generic
{
    /// <summary>
    /// An <see cref="IEnumerator{T}"/> that can iterate over a collection that 
    /// changes, without throwing an exception. When the collection changes, this 
    /// class is notified of it and grabs a new enumerator using 
    /// <see cref="IEnumerable{T}.GetEnumerator()"/>. Note that, derived classes 
    /// can override this behavior.
    /// </summary>
    /// <typeparam name="T">The type being iterated over.</typeparam>
    public class DynamicEnumerator<T> : IEnumerator<T>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="DynamicEnumerator{T}"/> 
        /// class.
        /// </summary>
        /// <param name="decoratingEventCollection">The event collection to iterate over.</param>
        public DynamicEnumerator(DecoratingEventCollection<T> decoratingEventCollection)
        {
            DecoratingEventCollection = decoratingEventCollection;
            DecoratingEventCollection.ItemsAdded += OnItemsAdded;
            DecoratingEventCollection.ItemsRemoved += OnItemsRemoved;
        }

        /// <summary>
        /// Called by this enumerator when the collection being iterated over 
        /// has been changed. You can also call this method if you want to 
        /// force this class to re-obtain the <see cref="IEnumerator{T}"/> from 
        /// the collection being iterated over.
        /// </summary>
        public virtual void CollectionChanged()
        {
            Enumerator = DecoratingEventCollection.GetEnumerator();
        }

        /// <summary>
        /// Gets the element in the collection at the current position of the 
        /// enumerator.
        /// </summary>
        /// <value></value>
        /// <returns>The element in the collection at the current position of 
        /// the enumerator.</returns>
        public T Current { get { return Enumerator.Current; } }

        /// <summary>
        /// Performs application-defined tasks associated with freeing, releasing, 
        /// or resetting unmanaged resources.
        /// </summary>
        public void Dispose()
        {
            DecoratingEventCollection.ItemsAdded -= OnItemsAdded;
            DecoratingEventCollection.ItemsRemoved -= OnItemsRemoved;
            DecoratingEventCollection = null;
            Enumerator.Dispose();
        }

        /// <summary>
        /// Advances the enumerator to the next element of the collection.
        /// </summary>
        /// <returns>
        /// true if the enumerator was successfully advanced to the next element; 
        /// false if the enumerator has passed the end of the collection.
        /// </returns>
        /// <exception cref="T:System.InvalidOperationException">The collection 
        /// was modified after the enumerator was created. </exception>
        public bool MoveNext()
        {
            return Enumerator.MoveNext();
        }

        /// <summary>
        /// Sets the enumerator to its initial position, which is before the 
        /// first element in the collection.
        /// </summary>
        /// <exception cref="T:System.InvalidOperationException">The collection 
        /// was modified after the enumerator was created. </exception>
        public void Reset()
        {
            Enumerator.Reset();
        }

        /// <summary>
        /// An event handler that is invoked when the collection being iterated 
        /// over has items removed from it. This method, just calls 
        /// <see cref="CollectionChanged()"/>.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="Chernobyl.Event.ItemsEventArgs{T}"/> 
        /// instance containing the event data.</param>
        protected virtual void OnItemsRemoved(object sender, ItemsEventArgs<T> e)
        {
            CollectionChanged();
        }

        /// <summary>
        /// An event handler that is invoked when the collection being iterated 
        /// over has items added to it. This method, just calls 
        /// <see cref="CollectionChanged()"/>.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="Chernobyl.Event.ItemsEventArgs{T}"/> 
        /// instance containing the event data.</param>
        protected virtual void OnItemsAdded(object sender, ItemsEventArgs<T> e)
        {
            CollectionChanged();
        }

        /// <summary>
        /// Gets the element in the collection at the current position of the 
        /// enumerator.
        /// </summary>
        /// <value></value>
        /// <returns>The element in the collection at the current position of 
        /// the enumerator.</returns>
        object System.Collections.IEnumerator.Current { get { return Enumerator.Current; } }

        /// <summary>
        /// The <see cref="IEnumerator{T}"/> being used to iterate over the 
        /// collection.
        /// </summary>
        IEnumerator<T> Enumerator { get; set; }

        /// <summary>
        /// The collection being iterated over.
        /// </summary>
        DecoratingEventCollection<T> DecoratingEventCollection { get; set; }
    }
}