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

namespace Chernobyl.Collections.Generic.Event
{
    /// <summary>
    /// Converts the events raised by <see cref="IEventEnumerable"/> to the 
    /// event raised by <see cref="INotifyCollectionChanged"/>
    /// </summary>
    public class NotifyCollectionChanged : INotifyCollectionChanged, IEnumerable
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="NotifyCollectionChanged"/> 
        /// class.
        /// </summary>
        /// <param name="enumerable">The instance whose raised events are being 
        /// converted to the raised 
        /// <see cref="INotifyCollectionChanged.CollectionChanged"/> event.
        /// Null is a permitted value for this parameter if <see cref="Enumerable"/>
        /// will be set later.</param>
        public NotifyCollectionChanged(IEventEnumerable enumerable)
        {
            // Null check not performed because null values are permitted.
            Enumerable = enumerable;
        }

        /// <summary>
        /// An event that is raised when <see cref="Enumerable"/> changes.
        /// </summary>
        public event NotifyCollectionChangedEventHandler CollectionChanged;

        /// <summary>
        /// The instance whose raised events are being converted to the raised
        /// <see cref="INotifyCollectionChanged.CollectionChanged"/> event. If
        /// null is set on this instance than this will stop listening to the 
        /// previously observed <see cref="IEventEnumerable"/>.
        /// </summary>
        public IEventEnumerable Enumerable
        {
            get { return _enumerable; }
            set
            {
                if (_enumerable != value)
                {
                    _enumerableCopy = null;

                    // Stop listening to the old enumerable.
                    if (_enumerable != null)
                    {
                        _enumerable.ItemsAdded -= OnItemsAdded;
                        _enumerable.ItemsRemoved -= OnItemsRemoved;
                    }

                    // Start listening to the new enumerable
                    _enumerable = value;
                    if (_enumerable != null)
                    {
                        UpdateCopy();
                        _enumerable.ItemsAdded += OnItemsAdded;
                        _enumerable.ItemsRemoved += OnItemsRemoved;
                    }
                }
            }
        }

        /// <summary>
        /// Returns an enumerator that iterates through a collection.
        /// </summary>
        /// <returns>
        /// An <see cref="IEnumerator" /> object that can be used to iterate 
        /// through the collection.
        /// </returns>
        public IEnumerator GetEnumerator()
        {
            if (Enumerable == null)
                throw new NullReferenceException("Failed to get the IEnumerator. " +
                                                 "NotifyCollectionChanged.Enumerable " +
                                                 "must be set to get the IEnumerator. " +
                                                 "It is currently null.");

            return Enumerable.GetEnumerator();
        }

        /// <summary>
        /// Raises the <see cref="INotifyCollectionChanged.CollectionChanged"/>
        /// if applicable.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The <see cref="ItemsEventArgs"/> instance containing 
        /// the event data.</param>
        void OnItemsAdded(object sender, ItemsEventArgs e)
        {
            if (CollectionChanged != null)
            {
                int index = Enumerable.Cast<object>()
                    .TakeWhile(item => item != e.Items.First()).Count();
                UpdateCopy();

                CollectionChanged(this,
                    new NotifyCollectionChangedEventArgs(
                        NotifyCollectionChangedAction.Add,
                        new ArrayList(e.Items), index));
            }
        }

        /// <summary>
        /// Raises the <see cref="INotifyCollectionChanged.CollectionChanged"/>
        /// if applicable.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The <see cref="ItemsEventArgs"/> instance containing 
        /// the event data.</param>
        void OnItemsRemoved(object sender, ItemsEventArgs e)
        {
            if (CollectionChanged != null)
            {
                // Grab the index where the item is removed.
                int index = _enumerableCopy.TakeWhile(item => item != e.Items.First()).Count();
                UpdateCopy();

                CollectionChanged(this,
                    new NotifyCollectionChangedEventArgs(
                        NotifyCollectionChangedAction.Remove,
                        new ArrayList(e.Items), index));
            }
        }

        /// <summary>
        /// Updates <see cref="_enumerableCopy"/>.
        /// </summary>
        void UpdateCopy()
        {
            _enumerableCopy = _enumerable.Cast<object>().ToArray();
        }

        /// <summary>
        /// The copy of <see cref="Enumerable"/>. This instance is used to
        /// determine the index of any items removed from <see cref="Enumerable"/>.
        /// </summary>
        Object[] _enumerableCopy;

        /// <summary>
        /// The backing field to <see cref="Enumerable"/>.
        /// </summary>
        IEventEnumerable _enumerable;
    }
}