using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Reflection;
using Chernobyl.ComponentModel;

namespace Chernobyl.Creation
{
    /// <summary>
    /// An <see cref="AsyncCompletedEventArgs"/> used when an instance of some 
    /// type has been created by the invoker of the event.
    /// </summary>
    public class CreationEventArgs : AsyncCompletedEventArgs
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="CreationEventArgs"/> 
        /// class.
        /// </summary>
        /// <param name="instance">The instance that was created by the invoker
        /// of the event.</param>
        public CreationEventArgs(object instance)
            : this(instance, null)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="CreationEventArgs"/> 
        /// class.
        /// </summary>
        /// <param name="instance">The instance that was created by the invoker
        /// of the event.</param>
        /// <param name="userState">The optional user-supplied object used for
        /// whatever purpose the user deems necessary or null if the user deems
        /// this parameter as unnecessary.</param>
        public CreationEventArgs(object instance, object userState)
            : this(instance, null, false, userState)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="CreationEventArgs"/> 
        /// class.
        /// </summary>
        /// <param name="cancelled">A value indicating whether the operation was 
        /// canceled.</param>
        public CreationEventArgs(bool cancelled)
            : this(cancelled, null)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="CreationEventArgs"/> 
        /// class.
        /// </summary>
        /// <param name="cancelled">A value indicating whether the operation was 
        /// canceled.</param>
        /// <param name="userState">The optional user-supplied object used for
        /// whatever purpose the user deems necessary or null if the user deems
        /// this parameter as unnecessary.</param>
        public CreationEventArgs(bool cancelled, object userState)
            : this(null, null, cancelled, userState)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="CreationEventArgs"/> 
        /// class.
        /// </summary>
        /// <param name="error">Any error that occurred during the operation.</param>
        public CreationEventArgs(Exception error)
            : this(error, null)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="CreationEventArgs"/> 
        /// class.
        /// </summary>
        /// <param name="error">Any error that occurred during the operation.</param>
        /// <param name="userState">The optional user-supplied object used for
        /// whatever purpose the user deems necessary or null if the user deems
        /// this parameter as unnecessary.</param>
        public CreationEventArgs(Exception error, object userState)
            : this(null, error, false, userState)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="CreationEventArgs"/> 
        /// class.
        /// </summary>
        /// <param name="instance">The instance that was created by the invoker
        /// of the event.</param>
        /// <param name="error">Any <see cref="Exception"/> that occurred during 
        /// the operation.</param>
        /// <param name="cancelled">True if the operation was canceled, false
        /// if otherwise.</param>
        /// <param name="userState">The optional user-supplied object used for
        /// whatever purpose the user deems necessary or null if the user deems
        /// this parameter as unnecessary.</param>
        protected CreationEventArgs(object instance, Exception error, bool cancelled, object userState)
            : base(error, cancelled, userState)
        {
            CreatedInstance = instance;
        }

        /// <summary>
        /// The instance that was created by the invoker of the event. Note that
        /// this property will throw an <see cref="Exception"/> if the
        /// <see cref="AsyncCompletedEventArgs.Error"/> is set to anything but 
        /// null or the <see cref="AsyncCompletedEventArgs.Cancelled"/>
        /// property is set to true.
        /// </summary>
        /// <exception cref="TargetInvocationException">Thrown if 
        /// <see cref="AsyncCompletedEventArgs.Error"/> was set to anything but
        /// null. The <see cref="Exception.InnerException"/> property holds a 
        /// reference to <see cref="AsyncCompletedEventArgs.Error"/>.</exception>
        /// <exception cref="InvalidOperationException">Thrown if 
        /// <see cref="AsyncCompletedEventArgs.Cancelled"/> is set to true
        /// which indicates that the operation that attempted to create the
        /// instance was cancelled.</exception>
        public object CreatedInstance
        {
            get
            {
                RaiseExceptionIfNecessary();

                return _createdInstance;
            }
            protected set { _createdInstance = value; }
        }

        /// <summary>
        /// The backing field to <see cref="CreatedInstance"/>.
        /// </summary>
        object _createdInstance;
    }

    /// <summary>
    /// An <see cref="AsyncCompletedEventArgs"/> used when an instance of some 
    /// type has been created by the invoker of the event.
    /// </summary>
    /// <typeparam name="TCreated">The type of the instance that was created.</typeparam>
    public class CreationEventArgs<TCreated> : CreationEventArgs
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="CreationEventArgs{TCreated}"/> 
        /// class.
        /// </summary>
        /// <param name="instance">The instance that was created by the invoker
        /// of the event.</param>
        public CreationEventArgs(TCreated instance)
            : this(instance, null)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="CreationEventArgs{TCreated}"/> 
        /// class.
        /// </summary>
        /// <param name="instance">The instance that was created by the invoker
        /// of the event.</param>
        /// <param name="userState">The optional user-supplied object used for
        /// whatever purpose the user deems necessary or null if the user deems
        /// this parameter as unnecessary.</param>
        public CreationEventArgs(TCreated instance, object userState)
            : this(instance, null, false, userState)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="CreationEventArgs{TCreated}"/> 
        /// class.
        /// </summary>
        /// <param name="cancelled">A value indicating whether the operation was 
        /// canceled.</param>
        public CreationEventArgs(bool cancelled)
            : this(cancelled, null)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="CreationEventArgs{TCreated}"/> 
        /// class.
        /// </summary>
        /// <param name="cancelled">A value indicating whether the operation was 
        /// canceled.</param>
        /// <param name="userState">The optional user-supplied object used for
        /// whatever purpose the user deems necessary or null if the user deems
        /// this parameter as unnecessary.</param>
        public CreationEventArgs(bool cancelled, object userState)
            : this(default(TCreated), null, cancelled, userState)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="CreationEventArgs{TCreated}"/> 
        /// class.
        /// </summary>
        /// <param name="error">Any error that occurred during the operation.</param>
        public CreationEventArgs(Exception error)
            : this(error, null)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="CreationEventArgs{TCreated}"/> 
        /// class.
        /// </summary>
        /// <param name="error">Any error that occurred during the operation.</param>
        /// <param name="userState">The optional user-supplied object used for
        /// whatever purpose the user deems necessary or null if the user deems
        /// this parameter as unnecessary.</param>
        public CreationEventArgs(Exception error, object userState)
            : this(default(TCreated), error, false, userState)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="CreationEventArgs{TCreated}"/> 
        /// class.
        /// </summary>
        /// <param name="instance">The instance that was created by the invoker
        /// of the event.</param>
        /// <param name="error">Any <see cref="Exception"/> that occurred during 
        /// the operation.</param>
        /// <param name="cancelled">True if the operation was canceled, false
        /// if otherwise.</param>
        /// <param name="userState">The optional user-supplied object used for
        /// whatever purpose the user deems necessary or null if the user deems
        /// this parameter as unnecessary.</param>
        protected CreationEventArgs(TCreated instance, Exception error, bool cancelled, object userState)
            : base(instance, error, cancelled, userState)
        {
            CreatedInstance = instance;
        }

        /// <summary>
        /// The instance that was created by the invoker of the event. Note that
        /// this property will throw an <see cref="Exception"/> if the
        /// <see cref="AsyncCompletedEventArgs.Error"/> is set to anything but 
        /// null or the <see cref="AsyncCompletedEventArgs.Cancelled"/>
        /// property is set to true.
        /// </summary>
        /// <exception cref="TargetInvocationException">Thrown if 
        /// <see cref="AsyncCompletedEventArgs.Error"/> was set to anything but
        /// null. The <see cref="Exception.InnerException"/> property holds a 
        /// reference to <see cref="AsyncCompletedEventArgs.Error"/>.</exception>
        /// <exception cref="InvalidOperationException">Thrown if 
        /// <see cref="AsyncCompletedEventArgs.Cancelled"/> is set to true
        /// which indicates that the operation that attempted to create the
        /// instance was cancelled.</exception>
        public new TCreated CreatedInstance
        {
            get { return (TCreated)base.CreatedInstance; }
            protected set { base.CreatedInstance = value; }
        }
    }

    /// <summary>
    /// A delegate used for indicating when a particular instance has been 
    /// created, when its creation was canceled, or when an error occurred 
    /// during its creation.
    /// </summary>
    /// <param name="sender">The instance that generated the event.</param>
    /// <param name="e">The <see cref="CreationEventArgs{T}"/> instance 
    /// containing the event data.</param>
    public delegate void CreationCompletedEventHandler(Object sender, CreationEventArgs e);

    /// <summary>
    /// A delegate used for indicating when a particular instance has been 
    /// created, when its creation was canceled, or when an error occurred 
    /// during its creation.
    /// </summary>
    /// <param name="sender">The instance that generated the event.</param>
    /// <param name="e">The <see cref="CreationEventArgs{T}"/> instance 
    /// containing the event data.</param>
    public delegate void CreationCompletedEventHandler<T>(Object sender, CreationEventArgs<T> e);

    /// <summary>
    /// Extension and utility methods for <see cref="CreationEventArgs{T}"/>
    /// and its dependencies.
    /// </summary>
    public static class CreationEventArgExtensions
    {
        /// <summary>
        /// Converts the specified <see cref="CreationEventArgs{TCreated}"/>
        /// that contains an instance of type <typeparamref name="TFromCreated"/>
        /// to an <see cref="CreationEventArgs{TCreated}"/> that contains an 
        /// instance of type <typeparamref name="TToCreated"/>
        /// </summary>
        /// <typeparam name="TFromCreated">The type of the created instance to 
        /// convert from.</typeparam>
        /// <typeparam name="TToCreated">The type of the created instance to 
        /// convert to.</typeparam>
        /// <param name="eventArgs">The instance that is to be converted.</param>
        /// <param name="convertCreation">The method that will convert the
        /// <see cref="CreationEventArgs{TCreated}.CreatedInstance"/> to an
        /// <typeparamref name="TToCreated"/>.</param>
        /// <returns>The converted to instance.</returns>
        public static CreationEventArgs<TToCreated> Convert<TFromCreated, TToCreated>(
            this CreationEventArgs<TFromCreated> eventArgs,
            Func<TFromCreated, TToCreated> convertCreation)
        {
            CreationEventArgs<TToCreated> result;

            if (eventArgs.Error != null)
                result = new CreationEventArgs<TToCreated>(eventArgs.Error,
                                                           eventArgs.UserState);
            else if (eventArgs.Cancelled)
                result = new CreationEventArgs<TToCreated>(true,
                                                           eventArgs.UserState);
            else
                result = new CreationEventArgs<TToCreated>(
                    convertCreation(eventArgs.CreatedInstance),
                    eventArgs.UserState);

            return result;
        }

        /// <summary>
        /// An event handler that adds a created item to an
        /// <see cref="ICollection{T}" /> but only if the creation did not
        /// get cancelled or result in an error.
        /// </summary>
        /// <typeparam name="TItems">The type of the item held in the 
        /// <paramref name="collection"/>.</typeparam>
        /// <typeparam name="TCreated">The type of the created item reported
        /// by the <see cref="CreationEventArgs{TCreated}"/>. This type must be
        /// of type <typeparamref name="TCreated"/>.</typeparam>
        /// <param name="collection">The instance to add the created item to.</param>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The <see cref="CreationEventArgs{TCreated}" /> instance
        /// containing the created item.</param>
        public static void Add<TItems, TCreated>(this ICollection<TItems> collection, object sender, CreationEventArgs<TCreated> e)
            where TCreated : TItems
        {
            if (e.IsGood())
                collection.Add(e.CreatedInstance);
        }
    }
}