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

namespace Chernobyl.Collections.Generic.Event
{
    /// <summary>
    /// Combines two sequences into a single sequence.
    /// </summary>
    /// <typeparam name="T">The type of the elements of the input sequences.</typeparam>
    public class Concatenation<T> : IEventEnumerable<T>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Concatenation{T}"/> 
        /// class.
        /// </summary>
        /// <param name="first">The first sequence to add to the second.</param>
        /// <param name="second">The second sequence to add to the first.</param>
        /// <exception cref="ArgumentNullException">Thrown if <paramref name="first"/>
        /// or <paramref name="second"/> is null.</exception>
        public Concatenation(IEventEnumerable<T> first,
                             IEventEnumerable<T> second)
        {
            first.ThrowIfNull("first");
            second.ThrowIfNull("second");

            // IEventEnumerable<T>.ItemsAdded should also raise the 
            // IEventEnumerable.ItemsAdded event.
            ItemsAdded += (sender, args) =>
            {
                if (_itemsAdded != null)
                    _itemsAdded(sender, args);
            };

            // IEventEnumerable<T>.ItemsRemoved should also raise the 
            // IEventEnumerable.ItemsRemoved event.
            ItemsRemoved += (sender, args) =>
            {
                if (_itemsRemoved != null)
                    _itemsRemoved(sender, args);
            };

            _first = first;
            _first.ItemsAdded += RaiseItemsAdded;
            _first.ItemsRemoved += RaiseItemsRemoved;
            
            _second = second;
            _second.ItemsAdded += RaiseItemsAdded;
            _second.ItemsRemoved += RaiseItemsRemoved;
        }

        /// <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 ((IEnumerable<T>)_first).Concat(_second).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>
        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>
        /// 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>
        /// Raises the <see cref="ItemsAdded"/> event if it has event handlers.
        /// </summary>
        /// <param name="sender">The sender of the event. This parameter will 
        /// be replaced by <c>this</c> in the raised event.</param>
        /// <param name="e">The <see cref="ItemsEventArgs{T}"/> instance 
        /// containing the event data.</param>
        void RaiseItemsAdded(object sender, ItemsEventArgs<T> e)
        {
            if (ItemsAdded != null)
                ItemsAdded(this, e);
        }

        /// <summary>
        /// Raises the <see cref="ItemsRemoved"/> event if it has event handlers.
        /// </summary>
        /// <param name="sender">The sender of the event. This parameter will 
        /// be replaced by <c>this</c> in the raised event.</param>
        /// <param name="e">The <see cref="ItemsEventArgs{T}"/> instance 
        /// containing the event data.</param>
        void RaiseItemsRemoved(object sender, ItemsEventArgs<T> e)
        {
            if (ItemsRemoved != null)
                ItemsRemoved(this, e);
        }

        /// <summary>
        /// The first sequence to add to the second.
        /// </summary>
        readonly IEventEnumerable<T> _first;

        /// <summary>
        /// The second sequence to add to the first.
        /// </summary>
        readonly IEventEnumerable<T> _second;

        /// <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>
    /// Extension and utility methods for <see cref="Concatenation{T}"/>.
    /// </summary>
    public static class ConcatenationExtensions
    {
        /// <summary>
        /// Combines two sequences into a single sequence.
        /// </summary>
        /// <typeparam name="T">The type of the elements of the input sequences.</typeparam>
        /// <param name="first">The first sequence to add to the second.</param>
        /// <param name="second">The second sequence to add to the first.</param>
        /// <returns>An instance that contains the combined elements of the two 
        /// input sequences.</returns>
        /// <exception cref="ArgumentNullException">Thrown if <paramref name="first"/>
        /// or <paramref name="second"/> is null.</exception>
        public static IEventEnumerable<T> Concat<T>(this IEventEnumerable<T> first, 
                                                    IEventEnumerable<T> second)
        {
            return new Concatenation<T>(first, second);
        }

        /// <summary>
        /// Combines multiple sequences into a single sequence.
        /// </summary>
        /// <typeparam name="T">The type of the elements of the input sequences.</typeparam>
        /// <param name="sequences">The sequences that are to be combined.</param>
        /// <returns>An instance that contains the combined elements of the 
        /// input sequences.</returns>
        /// <exception cref="ArgumentNullException">Thrown if 
        /// <paramref name="sequences"/> is null.</exception>
        public static IEventEnumerable<T> Concat<T>(IEnumerable<IEventEnumerable<T>> sequences)
        {
            sequences.ThrowIfNull("sequences");

            IEventEnumerable<T> sequence;
            using (IEnumerator<IEventEnumerable<T>> iter = sequences.GetEnumerator())
            {
                // If sequences contains no elements then we return an empty
                // IEventEnumerable{T}.
                sequence = iter.MoveNext() ? 
                    iter.Current : DecoratingEventEnumerable<T>.Empty;

                while (iter.MoveNext())
                {
                    IEventEnumerable<T> previousSequence = sequence;
                    sequence = previousSequence.Concat(iter.Current);
                }
            }

            return sequence;
        }
    }
}