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

namespace Chernobyl.Collections.Generic.Event
{
    /// <summary>
    /// Behaves like the method 
    /// <see cref="System.Linq.Enumerable.SelectMany{TSource, TResult}(IEnumerable{TSource}, Func{TSource, IEnumerable{TResult}})"/>
    /// in that it projects each element of a sequence to an 
    /// <see cref="IEventEnumerable{T}"/> and flattens the resulting sequences 
    /// into one sequence but this type continuously updates itself based on the
    /// changes to the original source sequence and the sequences returned by the
    /// provided selector method.
    /// </summary>
    /// <typeparam name="TSource">The type of the elements of source.</typeparam>
    /// <typeparam name="TResult">The type of the elements of the sequence 
    /// returned by selector.</typeparam>
    public class SelectManyEventEnumerable<TSource, TResult> : DecoratingEventEnumerable<TResult>
    {
        /// <summary>
        /// Initializes a new instance of the 
        /// <see cref="SelectManyEventEnumerable{TSource,TResult}" /> class.
        /// </summary>
        /// <param name="source">A sequence of values to project.</param>
        /// <param name="selector">A transform function to apply to each element.</param>
        public SelectManyEventEnumerable(IEventEnumerable<TSource> source,
                                         Func<TSource, IEventEnumerable<TResult>> selector)
            : this(source, selector, new List<TResult>())
        {}

        /// <summary>
        /// Initializes a new instance of the
        /// <see cref="SelectManyEventEnumerable{TSource,TResult}" /> class.
        /// </summary>
        /// <param name="source">A sequence of values to project.</param>
        /// <param name="selector">A transform function to apply to each element.</param>
        /// <param name="implementation">The instance that will implement the
        /// <see cref="IEnumerable{T}"/> side of this type.</param>
        private SelectManyEventEnumerable(IEventEnumerable<TSource> source,
                                          Func<TSource, IEventEnumerable<TResult>> selector,
                                          ICollection<TResult> implementation)
            : base(implementation)
        {
            selector.ThrowIfNull("selector");
            source.ThrowIfNull("source");

            _implementation = implementation;
            _selector = selector;
            Source = source;
        }

        /// <summary>
        /// A sequence of values to project.
        /// </summary>
        public IEventEnumerable<TSource> Source
        {
            get { return _source; }
            private set
            {
                IEventEnumerable<TSource> previousValue = _source;
                _source = value;

                if (previousValue != null)
                {
                    previousValue.ItemsAdded += OnSourcesAdded;
                    previousValue.ItemsRemoved += OnSourcesRemoved;
                    OnSourcesRemoved(this, new ItemsEventArgs<TSource>(previousValue.ToArray()));
                }

                if (_source != null)
                {
                    OnSourcesAdded(this, new ItemsEventArgs<TSource>(_source.ToArray()));
                    _source.ItemsAdded += OnSourcesAdded;
                    _source.ItemsRemoved += OnSourcesRemoved;
                }
            }
        }

        /// <summary>
        /// An event handler that is invoked when new sources have been added to
        /// <see cref="Source"/>. This method applies the <see cref="_selector"/>
        /// method to gather results and also ensures the addition/removal of
        /// results is reported later on.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The event data containing the items added.</param>
        void OnSourcesAdded(object sender, ItemsEventArgs<TSource> e)
        {
            foreach (TSource source in e.Items)
            {
                IEventEnumerable<TResult> results = _selector(source);

                if(results.Any())
                    OnResultsAdded(this, new ItemsEventArgs<TResult>(results.ToArray()));

                results.ItemsAdded += OnResultsAdded;
                results.ItemsRemoved += OnResultsRemoved;
            }
        }

        /// <summary>
        /// An event handler that is invoked when new sources have been removed from
        /// <see cref="Source"/>. This method applies the <see cref="_selector"/>
        /// method to gather results that are to be removed and ensures results
        /// are no longer be listened to for additions/removals.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The event data containing the items removed.</param>
        void OnSourcesRemoved(object sender, ItemsEventArgs<TSource> e)
        {
            foreach (TSource source in e.Items)
            {
                IEventEnumerable<TResult> results = _selector(source);

                results.ItemsAdded -= OnResultsAdded;
                results.ItemsRemoved -= OnResultsRemoved;

                if(results.Any())
                    OnResultsRemoved(this, new ItemsEventArgs<TResult>(results.ToArray()));
            }
        }

        /// <summary>
        /// An event handler that is invoked when sources have added new 
        /// <typeparamref name="TResult"/> instances. This method collects the
        /// new instances and reports them as having been added.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The event data containing the items added.</param>
        void OnResultsAdded(object sender, ItemsEventArgs<TResult> e)
        {
            _implementation.AddRange(e.Items);

            if (ItemsAddedHandler != null)
                ItemsAddedHandler(this, e);
        }

        /// <summary>
        /// An event handler that is invoked when sources have removed
        /// <typeparamref name="TResult"/> instances. This method removes the
        /// instances and reports them as having been removed.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The event data containing the items added.</param>
        void OnResultsRemoved(object sender, ItemsEventArgs<TResult> e)
        {
            _implementation.RemoveRange(e.Items);

            if (ItemsRemovedHandler != null)
                ItemsRemovedHandler(this, e);
        }

        /// <summary>
        /// The instance that will implement the <see cref="IEnumerable{T}"/> 
        /// side of this type.
        /// </summary>
        readonly ICollection<TResult> _implementation;
        
        /// <summary>
        /// A transform function to apply to each element.
        /// </summary>
        readonly Func<TSource, IEventEnumerable<TResult>> _selector;

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

    /// <summary>
    /// Utility methods that work on or with 
    /// <see cref="SelectManyEventEnumerable{TSource,TResult}"/>.
    /// </summary>
    public static class SelectManyEventEnumerableExtensions
    {
        /// <summary>
        /// Behaves like the method 
        /// <see cref="System.Linq.Enumerable.SelectMany{TSource, TResult}(IEnumerable{TSource}, Func{TSource, IEnumerable{TResult}})"/>
        /// in that it projects each element of a sequence to an 
        /// <see cref="IEventEnumerable{T}"/> and flattens the resulting sequences 
        /// into one sequence but the instance returned by this method continuously 
        /// updates itself based on the changes to the original source sequence 
        /// and the sequences returned by the provided selector method.
        /// </summary>
        /// <typeparam name="TSource">The type of the elements of source.</typeparam>
        /// <typeparam name="TResult">The type of the elements of the sequence 
        /// returned by selector.</typeparam>
        /// <param name="source">A sequence of values to project.</param>
        /// <param name="selector">A transform function to apply to each element.</param>
        /// <returns>An <see cref="IEventEnumerable{T}"/> whose elements are the 
        /// result of invoking the one-to-many transform function on each element 
        /// of the input sequence and will continuously update itself to remain
        /// that way.</returns>
        public static IEventEnumerable<TResult> SelectMany<TSource, TResult>(
            this IEventEnumerable<TSource> source,
            Func<TSource, IEventEnumerable<TResult>> selector)
        {
            return new SelectManyEventEnumerable<TSource, TResult>(source, selector);
        }
    }
}