using Chernobyl.Event;
using Chernobyl.Readiness;
using Chernobyl.Values;

namespace Chernobyl.Creation
{
    /// <summary>
    /// Represents a value that is produced by an <see cref="IFactory{T}"/>. This
    /// type can be implicitly converted to a <see cref="CreationCompletedEventHandler{T}"/>
    /// and so can be consumed by factory create methods.
    /// </summary>
    /// <typeparam name="T">The type created by the <see cref="IFactory{T}"/></typeparam>
    public class Product<T> : HeldValue<T>
    {
        /// <summary>
        /// Converts a <see cref="Product{T}"/> to an
        /// <see cref="CreationCompletedEventHandler{T}"/> for consumption by a
        /// factory create method.
        /// </summary>
        /// <param name="product">The product to be converted.</param>
        /// <returns>The converted value.</returns>
        public static implicit operator CreationCompletedEventHandler<T>(Product<T> product)
        {
            return product.OnCreation;
        }

        /// <summary>
        /// Invoked when an item is created. This method keeps this instance up
        /// to date.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The argument containing the created instance or
        /// details on the creation.</param>
        void OnCreation(object sender, CreationEventArgs<T> e)
        {
            if (e.Cancelled == false && e.Error == null)
                Value = e.CreatedInstance;
        }
    }

    /// <summary>
    /// Utility and extension code for use with <see cref="Product{T}"/>.
    /// </summary>
    public static class ProductExtensions
    {
        /// <summary>
        /// Creates an item from an <see cref="IFactory{T}"/> and returns it as
        /// an <see cref="IValue{T}"/>.
        /// </summary>
        /// <typeparam name="T">The type created by the <see cref="IFactory{T}"/>.</typeparam>
        /// <param name="factory">The instance to create the item from.</param>
        /// <returns>The item created represented as an <see cref="IValue{T}"/>.</returns>
        public static IValue<T> Create<T>(this IFactory<T> factory)
        {
            IValue<IFactory<T>> value = new BasicContainer<IFactory<T>>(factory);
            return value.Create();
        }

        /// <summary>
        /// Creates an item from an <see cref="IFactory{T}"/> and returns it as
        /// an <see cref="IValue{T}"/>.
        /// </summary>
        /// <typeparam name="T">The type created by the <see cref="IFactory{T}"/>.</typeparam>
        /// <param name="factory">The instance to create the item from.</param>
        /// <returns>The item created represented as an <see cref="IValue{T}"/>.</returns>
        public static IValue<T> Create<T>(this IValue<IFactory<T>> factory)
        {
            Product<T> product = new Product<T>();
            factory.NotNull().Provide +=
                (sender, e) => ((CreationCompletedEventHandler<T>)product)(sender, new CreationEventArgs<T>(e.NewValue.Create()));
            return product;
        }
    }
}