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

namespace Chernobyl.Collections.Generic.Event
{
    /// <summary>
    /// Behaves like the method
    /// <see cref="System.Linq.Enumerable.Select{TSource, TResult}(IEnumerable{TSource}, Func{TSource, int, TResult})" />
    /// in that it projects each element of a sequence into a new form by
    /// incorporating the element's index and maintains that form even if the
    /// source <see cref="IEventEnumerable{T}" /> changes.
    /// </summary>
    /// <typeparam name="TSource">The type of the elements of source.</typeparam>
    /// <typeparam name="TResult">The type of the value returned by selector.</typeparam>
    public class SelectEventEnumerable<TSource, TResult> : DecoratingEventEnumerable<TResult>
    {
        /// <summary>
        /// Initializes a new instance of the 
        /// <see cref="SelectEventEnumerable{TSource,TResult}"/> class.
        /// </summary>
        /// <param name="source">A sequence of values to invoke a transform 
        /// function on.</param>
        /// <param name="selector">A transform function to apply to each source 
        /// element. The second parameter represents the index of the source 
        /// element. The third parameter is the callback to invoke to keep the 
        /// transformed value up to date.</param>
        /// <param name="unselector">The method that is invoked when updates to 
        /// the transformed value are no longer needed. The second parameter 
        /// represents the index of the source element. The third parameter is 
        /// the callback to invoke to keep the transformed value up to date.</param>
        public SelectEventEnumerable(IEventEnumerable<TSource> source,
                                     Action<TSource, int, EventHandler<ValueChangedEventArgs<TResult>>> selector,
                                     Action<TSource, int, EventHandler<ValueChangedEventArgs<TResult>>> unselector)
            : this(source, selector, unselector, new Dictionary<int, TResult>())
        {}

        /// <summary>
        /// Initializes a new instance of the
        /// <see cref="SelectEventEnumerable{TSource,TResult}" /> class.
        /// </summary>
        /// <param name="source">A sequence of values to invoke a transform
        /// function on.</param>
        /// <param name="selector">A transform function to apply to each source 
        /// element. The second parameter represents the index of the source 
        /// element. The third parameter is the callback to invoke to keep the 
        /// transformed value up to date.</param>
        /// <param name="unselector">The method that is invoked when updates to 
        /// the transformed value are no longer needed. The second parameter 
        /// represents the index of the source element. The third parameter is 
        /// the callback to invoke to keep the transformed value up to date.</param>
        /// <param name="items">The <see cref="IEventEnumerable" /> being
        /// decorated or extended with event capabilities.</param>
        protected SelectEventEnumerable(IEventEnumerable<TSource> source,
                                        Action<TSource, int, EventHandler<ValueChangedEventArgs<TResult>>> selector,
                                        Action<TSource, int, EventHandler<ValueChangedEventArgs<TResult>>> unselector,
                                        IDictionary<int, TResult> items)
            : base(items.Values)
        {
            selector.ThrowIfNull("selector");
            _selector = selector;

            unselector.ThrowIfNull("unselector");
            _unselector = unselector;

            source.ThrowIfNull("source");
            Source = source;

            items.ThrowIfNull("implementation");
            _items = items;
        }

        /// <summary>
        /// A sequence of values to invoke a transform function on.
        /// </summary>
        public IEventEnumerable<TSource> Source
        {
            get { return _source; }
            private set
            {
                // Unconfigure the old instance. If the ItemsNeeded is false then
                // the unconfiguration has already occured.
                if (_source != null && ItemsNeeded)
                    UnreadyItems();

                _source = value;

                // Configure the new instance but only if the the items from this
                // instance are needed.
                if (_source != null && ItemsNeeded)
                    ReadyItems();
            }
        }

        /// <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 override void ReadyItems()
        {
            int index = 0;
            foreach (TSource source in _source)
            {
                var eventHandler = CreateOnValueChanged(index);
                _selector(source, index, eventHandler);
                ++index;
            }

            _source.ItemsAdded += OnSourceItemsAdded;
            _source.ItemsRemoved += OnSourceItemsRemoved;

            base.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 override void UnreadyItems()
        {
            // No longer need to know when new items are added.
            _source.ItemsAdded -= OnSourceItemsAdded;
            _source.ItemsRemoved -= OnSourceItemsRemoved;

            // No longer need to know when transformations change.
            int index = 0;
            foreach (TSource source in _source)
            {
                var eventHandler = _eventHandlers[index];
                _unselector(source, index, eventHandler);
                ++index;
            }

            _items.Clear();
            _eventHandlers.Clear();

            base.UnreadyItems();
        }

        /// <summary>
        /// An event handler that is invoked when items are added to
        /// <see cref="_source"/>. This method ensures that transformations are
        /// performed on the new items.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The <see cref="ItemsEventArgs{TSource}"/> instance 
        /// containing the event data.</param>
        void OnSourceItemsAdded(object sender, ItemsEventArgs<TSource> e)
        {
            foreach (var item in e.Items)
            {
                int index = _source.IndexOf(item);
                var eventHandler = CreateOnValueChanged(index);

                _selector(item, index, eventHandler);
            }
        }

        /// <summary>
        /// An event handler that is invoked when items are removed from
        /// <see cref="_source"/>. This method ensures that transformations do
        /// not continue on the removed items.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The <see cref="ItemsEventArgs{TSource}"/> instance 
        /// containing the event data.</param>
        void OnSourceItemsRemoved(object sender, ItemsEventArgs<TSource> e)
        {
            foreach (var item in e.Items)
            {
                int index = _source.IndexOf(item);
                var eventHandler = _eventHandlers[index];

                _unselector(item, index, eventHandler);
                _eventHandlers.Remove(index);
            }
        }

        /// <summary>
        /// An event handler that is invoked when the transformation of an item
        /// in <see cref="_source" /> is changed.
        /// </summary>
        /// <param name="e">The <see cref="ValueChangedEventArgs{TResult}" />
        /// instance containing the event data.</param>
        /// <param name="index">The zero based location of the item that was
        /// changed.</param>
        void OnValueChanged(ValueChangedEventArgs<TResult> e, int index)
        {
            // Remove the old value of the item.
            _items.Remove(index);
            if (ItemsRemovedHandler != null)
                ItemsRemovedHandler(this, new ItemsEventArgs<TResult>(e.OldValue));

            // Add the new value of the item into the location in the list that
            // corresponds with the location in the Source. Both the source and
            // this list must correlate with regard to order since Enumerable.Select
            // correlates in this manner and differing would be confusing to those
            // using this code.
            _items.Add(index, e.NewValue);
            if(ItemsAddedHandler != null)
                ItemsAddedHandler(this, new ItemsEventArgs<TResult>(e.NewValue));
        }

        /// <summary>
        /// Creates and stores an event handler that invokes 
        /// <see cref="OnValueChanged(ValueChangedEventArgs{TResult}, int)"/>
        /// with the provided index.
        /// </summary>
        /// <param name="index">The index that is to be passed to 
        /// <see cref="OnValueChanged(ValueChangedEventArgs{TResult}, int)"/>.</param>
        /// <returns>The event handler requested.</returns>
        EventHandler<ValueChangedEventArgs<TResult>> CreateOnValueChanged(int index)
        {
            EventHandler<ValueChangedEventArgs<TResult>> eventHandler =
                (valueChangeSender, valueChangeEventArgs) =>
                    OnValueChanged(valueChangeEventArgs, index);

            _eventHandlers.Add(index, eventHandler);

            return eventHandler;
        }

        /// <summary>
        /// A sequence of values to invoke a transform function on.
        /// </summary>
        IEventEnumerable<TSource> _source;

        /// <summary>
        /// A transform function to apply to each source element. The second 
        /// parameter represents the index of the source element. The third 
        /// parameter is the callback to invoke to keep the transformed value up 
        /// to date.
        /// </summary>
        readonly Action<TSource, int, EventHandler<ValueChangedEventArgs<TResult>>> _selector;

        /// <summary>
        /// The method that is invoked when updates to the transformed value are 
        /// no longer needed. The second parameter represents the index of the 
        /// source element. The third parameter is the callback to invoke to 
        /// keep the transformed value up to date.
        /// </summary>
        readonly Action<TSource, int, EventHandler<ValueChangedEventArgs<TResult>>> _unselector;

        /// <summary>
        /// The instance that contains items selected from <see cref="Source"/>
        /// mapped to their index in <see cref="Source"/>. The items are mapped
        /// to this index because each item may be provided at a different time.
        /// </summary>
        readonly IDictionary<int, TResult> _items;

        /// <summary>
        /// The instance that contains the event handlers that react to the
        /// providing of values by the instance contained in <see cref="Source"/>.
        /// Each method is mapped to an index within <see cref="Source"/> where 
        /// the item the method reports on is located.
        /// </summary>
        readonly IDictionary<int, EventHandler<ValueChangedEventArgs<TResult>>> _eventHandlers =
            new Dictionary<int, EventHandler<ValueChangedEventArgs<TResult>>>();
    }

    /// <summary>
    /// Extension and utility methods for the 
    /// <see cref="SelectEventEnumerable{TSource,TResult}"/> and its dependencies.
    /// </summary>
    public static class SelectEventEnumerable
    {
        /// <summary>
        /// Behaves like the method
        /// <see cref="System.Linq.Enumerable.Select{TSource, TResult}(IEnumerable{TSource}, Func{TSource, TResult})" />
        /// in that it projects each element of a sequence into a new form by
        /// incorporating the element's index and maintains that form even if the
        /// source <see cref="IEventEnumerable{T}" /> changes.
        /// </summary>
        /// <typeparam name="TSource">The type of the elements of source.</typeparam>
        /// <typeparam name="TResult">The type of the value returned by selector.</typeparam>
        /// <param name="source">A sequence of values to invoke a transform function on.</param>
        /// <param name="selector">A transform function to apply to each source 
        /// element; the second parameter of the function represents the index 
        /// of the source element.</param>
        /// <returns>An <see cref="IEventEnumerable{T}"/> whose elements are the 
        /// result of invoking the transform function on each element of source.</returns>
        public static IEventEnumerable<TResult> Select<TSource, TResult>(
            this IEventEnumerable<TSource> source, Func<TSource, TResult> selector)
        {
            return source.Select((value, i) => selector(value));
        }

        /// <summary>
        /// Behaves like the method
        /// <see cref="System.Linq.Enumerable.Select{TSource, TResult}(IEnumerable{TSource}, Func{TSource, int, TResult})" />
        /// in that it projects each element of a sequence into a new form by
        /// incorporating the element's index and maintains that form even if the
        /// source <see cref="IEventEnumerable{T}" /> changes.
        /// </summary>
        /// <typeparam name="TSource">The type of the elements of source.</typeparam>
        /// <typeparam name="TResult">The type of the value returned by selector.</typeparam>
        /// <param name="source">A sequence of values to invoke a transform function on.</param>
        /// <param name="selector">A transform function to apply to each source 
        /// element; the second parameter of the function represents the index 
        /// of the source element.</param>
        /// <returns>An <see cref="IEventEnumerable{T}"/> whose elements are the 
        /// result of invoking the transform function on each element of source.</returns>
        public static IEventEnumerable<TResult> Select<TSource, TResult>(
            this IEventEnumerable<TSource> source, Func<TSource, int, TResult> selector)
        {
            return new SelectEventEnumerable<TSource, TResult>(source,
                (value, index, handler) => handler(null, new ValueChangedEventArgs<TResult>(default(TResult), selector(value, index))),
                (value, index, handler) => { /* no-op */ });
        }

        /// <summary>
        /// Takes the internal values from a collection of <see cref="IValue{T}"/>
        /// and stores them in an <see cref="IEventEnumerable{T}" /> and maintains
        /// that list so that added or removed <see cref="IValue{T}"/> are reflected.
        /// </summary>
        /// <typeparam name="T">The type of items stored in the 
        /// <see cref="IValue{T}"/> and in the returned 
        /// <see cref="IEventEnumerable{T}" />.</typeparam>
        /// <param name="source">The instance that contains the 
        /// <see cref="IValue{T}"/> instances whose internals are to be reflected
        /// in the return <see cref="IEventEnumerable{T}"/>.</param>
        /// <returns>The <see cref="IEventEnumerable{T}"/> that reflects the
        /// internal values of the <paramref name="source"/>.</returns>
        public static IEventEnumerable<T> AsValues<T>(this IEventEnumerable<IValue<T>> source)
        {
            return new SelectEventEnumerable<IValue<T>, T>(source,
                (value, index, handler) => value.Provide += handler,
                (value, index, handler) => value.Provide -= handler);
        }
    }
}