using System;
using System.ComponentModel;

namespace Chernobyl.ComponentModel
{
    /// <summary>
    /// A default implementation of the <see cref="ITask"/> interface. This 
    /// class is intended to make the creation of <see cref="ITask"/>s easier.
    /// You should never use this class as part of your interface (like as an 
    /// argument to a method) as not all <see cref="ITask"/> instances will 
    /// derive from this class.
    /// </summary>
    public abstract class Task : ITask
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Task"/> class.
        /// </summary>
        protected Task() : this(0)
        {}

        /// <summary>
        /// Initializes a new instance of the <see cref="Task"/> class.
        /// </summary>
        /// <param name="progressPercentage">The percentage of work, from 0% to 
        /// 100%, that has been completed on this task.</param>
        protected Task(int progressPercentage)
        {
            ProgressPercentage = progressPercentage;
        }

        /// <summary>
        /// Cancels the work being done but only if it 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;
                ProgressPercentage = 0;

                if(Canceled != null)
                    Canceled(this, EventArgs.Empty);
            }
        }

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

        /// <summary>
        /// The percentage of work, from 0% to 100%, that has been completed on 
        /// this task. Note that setting this property will cause the
        /// <see cref="ProgressChanged"/> event to be raised if the amount of 
        /// change between the new value and the old value is not equal to zero.
        /// If the task is Canceled (i.e. <see cref="Cancel()"/> is invoked) the 
        /// value of this property will be set to zero by this <see cref="ITask"/>.
        /// </summary>
        /// <exception cref="ArgumentOutOfRangeException">Thrown if the new 
        /// <paramref name="value"/> is less than 0% or if the 
        /// <paramref name="value"/> is over 100%.</exception>
        public int ProgressPercentage
        {
            get { return _progressPercentage; }
            protected set
            {
                if (value < 0)
                    throw new ArgumentOutOfRangeException("value",
                        "You must provide a positive value for the amount " +
                        "of progress made.");

                if (value > 100)
                    throw new ArgumentOutOfRangeException("value",
                        "The ITask.ProgressPercentage cannot be over 100%.");

                int changeAmount = value - _progressPercentage;
                _progressPercentage = value;
                
                if(changeAmount != 0 && ProgressChanged != null)
                    ProgressChanged(this, new ProgressChangedEventArgs(ProgressPercentage, null));
            }
        }

        /// <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 not be invoked if the <see cref="ITask.ProgressPercentage"/> 
        /// is at 100%.
        /// </summary>
        public event EventHandler Canceled;

        /// <summary>
        /// An event that is raised when the progress of the task has changed.
        /// </summary>
        public event ProgressChangedEventHandler ProgressChanged;

        /// <summary>
        /// An implementation of the <see cref="ITask"/> interface that 
        /// represents a minor task that is completed immediately.
        /// </summary>
        public static readonly ITask Simple = new SimpleTask();

        /// <summary>
        /// Checks if the <see cref="ProgressChanged"/> event has subscribers.
        /// </summary>
        /// <returns>True if the <see cref="ProgressChanged"/> has subscribers, 
        /// false if otherwise.</returns>
        protected bool ProgressChangedHasSubscribers()
        {
            return ProgressChanged != null;
        }

        /// <summary>
        /// Raises the <see cref="ProgressChanged"/> event. Note that this 
        /// method does not check if <see cref="ProgressChanged"/> has subscribers
        /// so you must invoke <see cref="ProgressChangedHasSubscribers"/> to find
        /// out before invoking this method.
        /// </summary>
        /// <param name="e">The <see cref="ProgressChangedEventArgs"/> instance 
        /// containing the event data.</param>
        protected void RaiseProgressChanged(ProgressChangedEventArgs e)
        {
            ProgressChanged(this, e);
        }

        /// <summary>
        /// Checks if the <see cref="Canceled"/> event has subscribers.
        /// </summary>
        /// <returns>True if the <see cref="Canceled"/> has subscribers, false 
        /// if otherwise.</returns>
        protected  bool CanceledHasSubscribers()
        {
            return Canceled != null;
        }

        /// <summary>
        /// Raises the <see cref="Canceled"/> event. Note that this 
        /// method does not check if <see cref="Canceled"/> has subscribers
        /// so you must invoke <see cref="CanceledHasSubscribers"/> to find
        /// out before invoking this method.
        /// </summary>
        /// <param name="e">The <see cref="EventArgs"/> instance containing the 
        /// event data.</param>
        protected void RaiseCanceled(EventArgs e)
        {
            Canceled(this, e);
        }

        /// <summary>
        /// The backing field to <see cref="ProgressPercentage"/>.
        /// </summary>
        int _progressPercentage;
    }

    /// <summary>
    /// A type that is used for the <see cref="Task.Simple"/> field. This type
    /// represents a minor task that is completed immediately.
    /// </summary>
    class SimpleTask : Task
    {
        /// <summary>
        /// Prevents a default instance of the <see cref="SimpleTask"/> class 
        /// from being created.
        /// </summary>
        public SimpleTask() : base(100)
        { }
    }
}