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

namespace Chernobyl.Collections.Generic.Event
{
    /// <summary>
    /// An <see cref="IEnumerable"/> type that makes creating new 
    /// <see cref="IEnumerable"/> types easier.
    /// </summary>
    public abstract class EventEnumerable : IEventEnumerable
    {
        /// <summary>
        /// An event that is raised right after items are added to this list.
        /// </summary>
        public event EventHandler<ItemsEventArgs> ItemsAdded
        {
            add
            {
                ItemsNeeded = true;
                ItemsAddedHandler += value;
            }
            remove
            {
                ItemsAddedHandler -= value;

                if (ItemsAddedHandler == null)
                    ItemsNeeded = false;
            }
        }

        /// <summary>
        /// An event that is raised right after items are removed from this list.
        /// </summary>
        public event EventHandler<ItemsEventArgs> ItemsRemoved
        {
            add
            {
                ItemsNeeded = true;
                ItemsRemovedHandler += value;
            }
            remove
            {
                ItemsRemovedHandler -= value;

                if (ItemsRemovedHandler == null)
                    ItemsNeeded = false;
            }
        }

        /// <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>
        IEnumerator IEnumerable.GetEnumerator()
        {
            ItemsNeeded = true;
            return EnumerableDecorated.GetEnumerator();
        }

        /// <summary>
        /// Invoked when the items in this instance need to be ready for
        /// iteration or events. This method is invoked when 
        /// <see cref="EventEnumerable.ItemsNeeded"/> is changed to true.
        /// </summary>
        protected virtual void ReadyItems() { }

        /// <summary>
        /// Invoked when the items in this instance no longer need to be ready 
        /// for iteration or events. This method is invoked when 
        /// <see cref="EventEnumerable.ItemsNeeded"/> is changed to false.
        /// </summary>
        protected virtual void UnreadyItems() { }

        /// <summary>
        /// Set to true when items in this type are needed, such as when the 
        /// someone signs up to the <see cref="IEventEnumerable.ItemsAdded"/> or 
        /// <see cref="IEventEnumerable.ItemsRemoved"/> events or when someone 
        /// iterates over this instance. Set to false when the items are no 
        /// longer needed. If overriding, make sure to invoke the base class 
        /// method in the override.
        /// </summary>
        protected bool ItemsNeeded
        {
            get { return _itemsNeeded; }
            set
            {
                if (_itemsNeeded != value)
                {
                    _itemsNeeded = value;

                    if (_itemsNeeded)
                        ReadyItems();
                    else
                        UnreadyItems();
                }
            }
        }

        /// <summary>
        /// The backing property to <see cref="ItemsAdded"/>.
        /// </summary>
        protected EventHandler<ItemsEventArgs> ItemsAddedHandler { get; private set; }

        /// <summary>
        /// The backing property to <see cref="ItemsRemoved"/>.
        /// </summary>
        protected EventHandler<ItemsEventArgs> ItemsRemovedHandler { get; private set; }

        /// <summary>
        /// The <see cref="IEventEnumerable"/> being decorated or extended 
        /// with event capabilities.
        /// </summary>
        protected abstract IEnumerable EnumerableDecorated { get; }

        /// <summary>
        /// The backing field to <see cref="ItemsNeeded"/>.
        /// </summary>
        bool _itemsNeeded;
    }

    /// <summary>
    /// An <see cref="IEnumerable{T}"/> type that makes creating new 
    /// <see cref="IEnumerable{T}"/> types easier.
    /// </summary>
    /// <typeparam name="T">The type that is to be held within this 
    /// <see cref="IEnumerable{T}"/>.</typeparam>
    public abstract class EventEnumerable<T> : EventEnumerable, IEventEnumerable<T>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="DecoratingEventCollection{T}"/> 
        /// class.
        /// </summary>
        protected EventEnumerable()
        {
            // We need to make sure the base class' events are raised. Note that
            // we do not go through ItemsAdded/ItemsRemoved for this, since that
            // would cause ItemsNeeded to be set to true prematurely.
            ItemsAddedHandler += InvokeBaseItemsAdded;
            ItemsRemovedHandler += InvokeBaseItemsRemoved;
        }

        /// <summary>
        /// An event that is raised right after items are added to this list.
        /// </summary>
        public new event EventHandler<ItemsEventArgs<T>> ItemsAdded
        {
            add
            {
                ItemsNeeded = true;
                ItemsAddedHandler += value;
            }
            remove
            {
                ItemsAddedHandler -= value;

                // Check if we no longer have outside subscribers 
                // (InvokeBaseItemsAdded will always be subscribed). We no
                // longer need items if subscribers no longer listen.
                if (ItemsAddedHandler.GetInvocationList().Length == 1)
                    ItemsNeeded = false;
            }
        }

        /// <summary>
        /// An event that is raised right after items are removed from this list.
        /// </summary>
        public new event EventHandler<ItemsEventArgs<T>> ItemsRemoved
        {
            add
            {
                ItemsNeeded = true;
                ItemsRemovedHandler += value;
            }
            remove
            {
                ItemsRemovedHandler -= value;

                // Check if we no longer have outside subscribers 
                // (InvokeBaseItemsRemoved will always be subscribed). We no
                // longer need items if subscribers no longer listen.
                if (ItemsRemovedHandler.GetInvocationList().Length == 1)
                    ItemsNeeded = false;
            }
        }

        /// <summary>
        /// An instance that represents an empty <see cref="IEventEnumerable{T}"/>.
        /// </summary>
        public static readonly IEventEnumerable<T> Empty = new StaticEventEnumerable<T>();

        /// <summary>
        /// Returns an enumerator that iterates through the collection.
        /// </summary>
        /// <returns>
        /// A <see cref="IEnumerator{T}"/> that can 
        /// be used to iterate through the collection.
        /// </returns>
        public IEnumerator<T> GetEnumerator()
        {
            ItemsNeeded = true;
            return GenericEnumerableDecorated.GetEnumerator();
        }

        /// <summary>
        /// Raises the <see cref="IEventEnumerable.ItemsAdded"/> of the base
        /// class after checking if it is null.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The event's arguments.</param>
        protected void InvokeBaseItemsAdded(object sender, ItemsEventArgs<T> e)
        {
            if (base.ItemsAddedHandler != null)
                base.ItemsAddedHandler(sender, e);
        }

        /// <summary>
        /// Raises the <see cref="IEventEnumerable.ItemsRemoved"/> of the base
        /// class after checking if it is null.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The event's arguments.</param>
        protected void InvokeBaseItemsRemoved(object sender, ItemsEventArgs<T> e)
        {
            if (base.ItemsRemovedHandler != null)
                base.ItemsRemovedHandler(sender, e);
        }

        /// <summary>
        /// The backing property to <see cref="ItemsAdded"/>.
        /// </summary>
        protected new EventHandler<ItemsEventArgs<T>> ItemsAddedHandler { get; set; }

        /// <summary>
        /// The backing property to <see cref="ItemsRemoved"/>.
        /// </summary>
        protected new EventHandler<ItemsEventArgs<T>> ItemsRemovedHandler { get; set; }

        /// <summary>
        /// The <see cref="IEventEnumerable{T}"/> being decorated or extended 
        /// with event capabilities.
        /// </summary>
        protected abstract IEnumerable<T> GenericEnumerableDecorated { get; }

        /// <summary>
        /// The <see cref="IEventEnumerable" /> being decorated or extended
        /// with event capabilities.
        /// </summary>
        protected override IEnumerable EnumerableDecorated
        {
            get { return GenericEnumerableDecorated; }
        }
    }
}