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

namespace Chernobyl.Collections.Generic.Event
{
    /// <summary>
    /// An <see cref="IEventEnumerable{T}"/> that can represent another
    /// <see cref="IEventEnumerable{T}"/> (the "source") while still allowing the
    /// source to be swapped out with another <see cref="IEventEnumerable{T}"/> 
    /// at any time.
    /// </summary>
    /// <typeparam name="T">The type that is to be held in this instance.</typeparam>
    public class SourceEventEnumerable<T> : IEventEnumerable<T>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="SourceEventEnumerable{T}"/> class.
        /// </summary>
        public SourceEventEnumerable()
            : this(null)
        {}

        /// <summary>
        /// Initializes a new instance of the <see cref="SourceEventEnumerable{T}"/> class.
        /// </summary>
        /// <param name="source">The source of the items that are being enumerated 
        /// and the events that are raised. If null is specified then <c>this</c> 
        /// instance will be empty.</param>
        public SourceEventEnumerable(IEventEnumerable<T> source)
        {
            Source = source;

            // When ItemsAdded/ItemsRemoved is invoked we'll want to also invoke
            // IEventEnumerable.ItemsAdded/IEventEnumerable.ItemsRemoved.

            ItemsAdded += (sender, e) =>
                {
                    if (_itemsAdded != null)
                        _itemsAdded(this, e);
                };

            ItemsRemoved += (sender, e) =>
                {
                    if (_itemsRemoved != null)
                        _itemsRemoved(this, e);
                };
        }

        /// <summary>
        /// The source of the items that are being enumerated and the events that
        /// are raised. If null is specified then <c>this</c> instance will be
        /// empty.
        /// </summary>
        public IEventEnumerable<T> Source
        {
            get { return _source; }
            set
            {
                IEventEnumerable<T> previousValue = _source;
                _source = value;

                if (previousValue != null)
                {
                    previousValue.ItemsAdded -= OnSourceItemsAdded;
                    previousValue.ItemsRemoved -= OnSourceItemsRemoved;
                }

                if (_source != null)
                {
                    _source.ItemsAdded += OnSourceItemsAdded;
                    _source.ItemsRemoved += OnSourceItemsRemoved;
                }
            }
        }

        /// <summary>
        /// An event that is raised right after items are added to this list.
        /// </summary>
        public event EventHandler<ItemsEventArgs<T>> ItemsAdded;

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

        /// <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()
        {
            return _source != null ? _source.GetEnumerator() : System.Linq.Enumerable.Empty<T>().GetEnumerator();
        }

        /// <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()
        {
            return GetEnumerator();
        }

        /// <summary>
        /// An event that is raised right after items are added to this list.
        /// </summary>
        event EventHandler<ItemsEventArgs> IEventEnumerable.ItemsAdded
        {
            add { _itemsAdded += value; }
            remove { _itemsAdded -= value; }
        }

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

        /// <summary>
        /// An event handler that is invoked when the <see cref="Source"/>
        /// instance's <see cref="IEventEnumerable{T}.ItemsAdded"/> event is
        /// raised.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The arguments containing the removed items.</param>
        void OnSourceItemsAdded(object sender, ItemsEventArgs<T> e)
        {
            if (ItemsAdded != null)
                ItemsAdded(this, e);
        }

        /// <summary>
        /// An event handler that is invoked when the <see cref="Source"/>
        /// instance's <see cref="IEventEnumerable{T}.ItemsRemoved"/> event is
        /// raised.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The arguments containing the removed items.</param>
        void OnSourceItemsRemoved(object sender, ItemsEventArgs<T> e)
        {
            if (ItemsRemoved != null)
                ItemsRemoved(this, e);
        }

        /// <summary>
        /// The backing field to <see cref="Source"/>.
        /// </summary>
        IEventEnumerable<T> _source;

        /// <summary>
        /// The backing field to <see cref="IEventEnumerable.ItemsAdded"/>.
        /// </summary>
        EventHandler<ItemsEventArgs> _itemsAdded;

        /// <summary>
        /// The backing field to <see cref="IEventEnumerable.ItemsRemoved"/>.
        /// </summary>
        EventHandler<ItemsEventArgs> _itemsRemoved;
    }

    /// <summary>
    /// Utility methods that make use of <see cref="SourceEventEnumerable{T}"/>.
    /// </summary>
    public static class SourceEventEnumerable
    {
        /// <summary>
        /// Returns an <see cref="IEventEnumerable{T}"/> that represents the 
        /// <see cref="IEventEnumerable{T}"/> contained in <paramref name="value"/>
        /// regardless of whether it actually exists (i.e. is null) or whether 
        /// the instance is swapped for another <see cref="IEventEnumerable{T}"/>
        /// at any point.
        /// </summary>
        /// <typeparam name="T">The type that is to be held in the 
        /// <see cref="IEventEnumerable{T}"/>.</typeparam>
        /// <typeparam name="TEventEnumerable">The type of 
        /// <see cref="IEventEnumerable{T}"/> contained within
        /// <paramref name="value"/>.</typeparam>
        /// <param name="value">The instance whose value is to be represented
        /// regardless of what value it is at any given point.</param>
        /// <returns>The <see cref="IEventEnumerable{T}"/> that represents the
        /// value contained within <paramref name="value"/>.</returns>
        public static IEventEnumerable<T> AsEventEnumerable<T, TEventEnumerable>(this IValue<TEventEnumerable> value)
            where TEventEnumerable : IEventEnumerable<T>
        {
            SourceEventEnumerable<T> sourceEventEnumerable = new SourceEventEnumerable<T>();
            value.Provide += (sender, e) => sourceEventEnumerable.Source = e.NewValue;
            return sourceEventEnumerable;
        }

        /// <summary>
        /// Performs the same task as 
        /// <see cref="SourceEventEnumerable.AsEventEnumerable{T, TEventEnumerable}(IValue{TEventEnumerable})"/>
        /// except this method is for instances deriving from <see cref="IEventEnumerable{T}"/>
        /// which are often used for collections of services in Chernobyl.
        /// </summary>
        /// <typeparam name="TEventEnumerable">The type of 
        /// <see cref="IEventEnumerable{T}"/> contained within
        /// <paramref name="value"/>. This type must inherit from 
        /// <see cref="IEventEnumerable{T}"/> with <see cref="object"/> as its type.</typeparam>
        /// <param name="value">The instance whose value is to be represented
        /// regardless of what value it is at any given point.</param>
        /// <returns>The <see cref="IEventEnumerable{T}"/> that represents the
        /// value contained within <paramref name="value"/>.</returns>
        public static IEventEnumerable<object> AsServices<TEventEnumerable>(this IValue<TEventEnumerable> value)
            where TEventEnumerable : IEventEnumerable<object>
        {
            return value.AsEventEnumerable<object, TEventEnumerable>();
        }
    }
}