using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;

namespace Chernobyl.ComponentModel
{
    /// <summary>
    /// An <see cref="ITask"/> that can cancel multiple <see cref="ITask"/>
    /// instances and report the progress of those <see cref="ITask"/> instances
    /// as a whole. Each <see cref="ITask"/> contained by this 
    /// <see cref="IEnumerable{T}"/> maintains an equal portion of the progress
    /// reported by this <see cref="ITask"/>. For example, if there are four 
    /// <see cref="ITask"/> instances contained within this 
    /// <see cref="IEnumerable{T}"/> this <see cref="ITask"/> would report a
    /// progress of 25% when one <see cref="ITask"/> fully completes, 50% when
    /// two fully complete, and so on. Invoking <see cref="ITask.Cancel()"/> on
    /// this <see cref="ITask"/> would cancel all of the <see cref="ITask"/> 
    /// instances contained in this <see cref="IEnumerable{T}"/>. This type is 
    /// an implementation of the composite pattern
    /// (http://en.wikipedia.org/wiki/Composite_pattern). Note that
    /// you can convert an <see cref="IEnumerable{T}"/> of <see cref="ITask"/>
    /// instances using the extension method 
    /// <see cref="TaskEnumerableExtensions.AsComposite(IEnumerable{ITask})"/>.
    /// </summary>
    public class TaskEnumerable : ITask, IEnumerable<ITask>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="TaskEnumerable"/> class.
        /// </summary>
        /// <param name="tasks">The <see cref="ITask"/> instances that will be
        /// represented as a whole by this <see cref="ITask"/>.</param>
        public TaskEnumerable(IEnumerable<ITask> tasks)
        {
            _tasks = tasks;

            foreach (ITask task in _tasks)
            {
                task.ProgressChanged += TaskProgressChanged;
                task.Canceled += TaskCanceled;
                ++_countCache;
            }
        }

        /// <summary>
        /// Invokes <see cref="ITask.Cancel()"/> on all of the <see cref="ITask"/> 
        /// instances contained within this <see cref="IEnumerable{T}"/> but only 
        /// if this <see cref="ITask"/> has not been canceled already and the 
        /// <see cref="ITask.ProgressPercentage"/> has not reached 100%. If 
        /// cancellation is successful, the <see cref="Canceled"/> event will be 
        /// raised. Note that, when the work being done is on another thread, it 
        /// is possible that the work will finish just as this method is invoked.
        /// </summary>
        public void Cancel()
        {
            if (IsCanceled == false && ProgressPercentage != 100)
            {
                IsCanceled = true;

                foreach (ITask task in _tasks)
                    task.Cancel();

                // Note: we do not need to raise the Canceled event here
                // because this class is already listening for all contained
                // ITasks to cancel. If they do, the this class will see it and
                // raise the Canceled event automatically. See the 
                // TaskCanceled(object, EventArgs) method for more information.
            }
        }

        /// <summary>
        /// True if the task has been canceled, false if otherwise.
        /// </summary>
        public bool IsCanceled
        {
            get { return _isCanceled; }
            private set
            {
                bool previousValue = _isCanceled;
                _isCanceled = value;

                if (previousValue == false && _isCanceled == true && Canceled != null)
                    Canceled(this, EventArgs.Empty);
            }
        }

        /// <summary>
        /// The percentage of work, from 0% to 100%, that has been completed on
        /// this task.
        /// </summary>
        public int ProgressPercentage
        {
            get
            {
                if (_progressPercentageCache.HasValue == false)
                    _progressPercentageCache = (int)_tasks.Average(task => task.ProgressPercentage);

                return _progressPercentageCache.Value;
            }
        }

        /// <summary>
        /// An event that is raised when the <see cref="Cancel()"/> is invoked
        /// on this instance. Note that this event is only raised once, 
        /// regardless of how many times <see cref="Cancel()"/> is invoked. This 
        /// event will also be raised if all of the <see cref="ITask"/> 
        /// instances contained in this <see cref="IEnumerable{T}"/> are canceled.
        /// This event will not be invoked if the <see cref="ITask.ProgressPercentage"/> 
        /// is at 100%.
        /// </summary>
        public event EventHandler Canceled;

        /// <summary>
        /// An event that is raised whenever the progress of any <see cref="ITask"/>
        /// instance contained in this <see cref="IEnumerable{T}"/> has
        /// changed. Note that the <see cref="ProgressChangedEventArgs.UserState"/>
        /// in the <see cref="ProgressChangedEventArgs"/> instance included with
        /// the event is the <see cref="ProgressChangedEventArgs.UserState"/> of
        /// the <see cref="ITask"/> contained in this <see cref="IEnumerable{T}"/>
        /// that reported its progress and caused this event to be raised.
        /// </summary>
        public event ProgressChangedEventHandler ProgressChanged;

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

        /// <summary>
        /// An event handler that is assigned to the 
        /// <see cref="ITask.ProgressChanged"/> event of the <see cref="_tasks"/>
        /// contained in this <see cref="IEnumerable{T}"/>. This method is
        /// responsible calculating the overall <see cref="ProgressPercentage"/>
        /// and raising of the <see cref="ProgressChanged"/> event.
        /// </summary>
        /// <param name="sender">The instance that generated the event.</param>
        /// <param name="e">The <see cref="ProgressChangedEventArgs"/> instance 
        /// containing the event data.</param>
        void TaskProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            // Force the ProgressPercentage to recalculate itself.
            _progressPercentageCache = null;

            if(ProgressChanged != null)
                ProgressChanged(this, new ProgressChangedEventArgs(ProgressPercentage, e.UserState));
        }

        /// <summary>
        /// An event handler that is assigned to the 
        /// <see cref="ITask.Canceled"/> event of the <see cref="_tasks"/>
        /// contained in this <see cref="IEnumerable{T}"/>. This method is
        /// responsible for checking if all the <see cref="ITask"/> instances
        /// contained within this <see cref="IEnumerable{T}"/> have been 
        /// canceled and raising the <see cref="Canceled"/> event if so.
        /// </summary>
        /// <param name="sender">The instance that generated the event.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing the 
        /// event data.</param>
        void TaskCanceled(object sender, EventArgs e)
        {
            ++_canceledTasksCount;

            if (_canceledTasksCount == _countCache)
                IsCanceled = true;
        }

        /// <summary>
        /// The <see cref="ITask"/> instances that will be represented as a 
        /// whole by this <see cref="ITask"/>.
        /// </summary>
        IEnumerable<ITask> _tasks;

        /// <summary>
        /// The number of <see cref="ITask"/> instances in this 
        /// <see cref="IEnumerable{T}"/>. This value is cached so that we don't
        /// have to iterate over the <see cref="_tasks"/> 
        /// <see cref="IEnumerable{T}"/> to view the value.
        /// </summary>
        int _countCache;

        /// <summary>
        /// The number of <see cref="ITask"/> instances contained within this
        /// <see cref="IEnumerable{T}"/> that have been canceled. This variable
        /// is used to determine if the <see cref="ITask.Canceled"/> event 
        /// should raised.
        /// </summary>
        int _canceledTasksCount;

        /// <summary>
        /// The backing field to <see cref="IsCanceled"/>.
        /// </summary>
        bool _isCanceled;

        /// <summary>
        /// The backing field and cache to <see cref="ProgressPercentage"/>. In
        /// order to calculate the <see cref="ProgressPercentage"/> we have to
        /// iterate over the <see cref="_tasks"/> to get the average. We cache
        /// the value to prevent us from having to do it more than we have to.
        /// </summary>
        int? _progressPercentageCache;
    }

    /// <summary>
    /// Extensions methods used with <see cref="TaskEnumerable"/>.
    /// </summary>
    public static class TaskEnumerableExtensions
    {
        /// <summary>
        /// Takes a group of <see cref="IEnumerable{ITask}"/> instances 
        /// and converts them to a single <see cref="ITask"/> that represents
        /// the entire collection of <see cref="ITask"/> instances. This method
        /// uses <see cref="TaskEnumerable"/> to accomplish this.
        /// </summary>
        /// <param name="tasks">The <see cref="ITask"/> instances that are to be
        /// represented as one <see cref="ITask"/>.</param>
        /// <returns>That <see cref="ITask"/> that represents the whole group of
        /// <see cref="ITask"/> instances.</returns>
        public static ITask AsComposite(this IEnumerable<ITask> tasks)
        {
            return new TaskEnumerable(tasks);
        }
    }
}