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

namespace Chernobyl.Collections.Generic.Event
{
    /// <summary>
    /// An interface for working with <see cref="IEnumerable"/> types that 
    /// allow client code to know when the <see cref="IEnumerable"/> has been
    /// modified.
    /// </summary>
    public interface IEventEnumerable : IEnumerable
    {
        /// <summary>
        /// An event that is raised right after items are added to this list.
        /// </summary>
        event EventHandler<ItemsEventArgs> ItemsAdded;

        /// <summary>
        /// An event that is raised right after items are removed from this list.
        /// </summary>
        event EventHandler<ItemsEventArgs> ItemsRemoved;
    }

    /// <summary>
    /// An interface for working with <see cref="IEnumerable{T}"/> types that 
    /// allow client code to know when the <see cref="IEnumerable{T}"/> has been
    /// modified.
    /// </summary>
    /// <typeparam name="T">The type that is to be held within the collection.</typeparam>
    public interface IEventEnumerable<T> : IEnumerable<T>, IEventEnumerable
    {
        /// <summary>
        /// An event that is raised right after items are added to this list.
        /// </summary>
        new event EventHandler<ItemsEventArgs<T>> ItemsAdded;

        /// <summary>
        /// An event that is raised right after items are removed from this list.
        /// </summary>
        new event EventHandler<ItemsEventArgs<T>> ItemsRemoved;
    }
	
	/// <summary>
    /// Utility methods for the <see cref="IEventEnumerable{T}"/> type.
    /// </summary>
    public static class EventEnumerableExtensions
    {
        /// <summary>
        /// Invokes the <paramref name="firstAdded"/> when the first item has
        /// been added to <paramref name="enumerable"/>. If an item is already
        /// in the list, then <paramref name="firstAdded"/> is invoked immediately.
        /// The <paramref name="firstAdded"/> method will not be invoked more
        /// than once.
        /// </summary>
        /// <typeparam name="T">The type contained within the 
        /// <see cref="IEventEnumerable{T}"/>.</typeparam>
        /// <param name="enumerable">The <see cref="IEventEnumerable{T}"/> where
        /// the first item is to be found.</param>
        /// <param name="firstAdded">The method that is to be invoked with the
        /// first item added to the <paramref name="enumerable"/> or the first
        /// item found if the <paramref name="enumerable"/> already has an item.</param>
        public static void First<T>(this IEventEnumerable<T> enumerable, Action<T> firstAdded)
        {
            if (enumerable.Any())
                firstAdded(enumerable.First());
            else
            {
                // We create a proxy method that 'wraps' the firstAdded method.
                // The proxy will remove itself from the IEventEnumerable<T>.ItemsAdded
                // event of the enumerable so that firstAdded doesn't get called
                // more than once.

                EventHandler<ItemsEventArgs<T>> proxy = null;
                proxy = (sender, e) =>
                    {
                        firstAdded(e.Items[0]);
                        enumerable.ItemsAdded -= proxy;
                    };
                enumerable.ItemsAdded += proxy;
            }
        }
    }
}