using System;
using System.Collections.Generic;
using Chernobyl.Collections.Generic;

namespace Chernobyl.Creation
{
    /// <summary>
    /// An <see cref="IBuilder{T}"/> type that can construct and/or configure instances of type
    /// <typeparamref name="TResult"/>.
    /// </summary>
    /// <typeparam name="TResult">The type that is being constructed and/or configured.</typeparam>
    public interface IFactory<TResult> : IBuilder<TResult>
    {
        /// <summary>
        /// Constructs and/or configures an instance of type <typeparamref name="TResult"/>.
        /// </summary>
        TResult Create();
    }

    /// <summary>
    /// An <see cref="IBuilder{T}"/> type that can construct and/or configure instances of type
    /// <typeparamref name="TResult"/> using a single argument. If you wish to have multiple arguments,
    /// it is recommended you use an argument that can hold multiple instances such as a
    /// <see cref="Pair{TFirst, TSecond}"/> or <see cref="IEnumerable{T}"/>.
    /// </summary>
    public interface IFactory<in T1, TResult> : IBuilder<TResult>
    {
        /// <summary>
        /// Constructs and/or configures an instance of type <typeparamref name="TResult"/>.
        /// </summary>
        TResult Create(T1 arg1);
    }

    /// <summary>
    /// Utility methods for working with the factory types such as
    /// <see cref="IFactory{T}"/>.
    /// </summary>
    public static class FactoryExtensions
    {
        /// <summary>
        /// An event handler style method that can be assigned to an event so that the
        /// <see cref="IFactory{TResult}.Create()"/> method is invoked.
        /// </summary>
        public static void Create<TResult>(this IFactory<TResult> factory, object sender, EventArgs e)
            => factory.Create();

        /// <summary>
        /// Returns a <see cref="Lazy{T}"/> that creates an instance from the specified factory.
        /// </summary>
        public static Lazy<TResult> LazyCreate<TResult>(this IFactory<TResult> factory) =>
            new Lazy<TResult>(factory.Create);

        /// <summary>
        /// Returns a <see cref="Lazy{T}"/> that creates an instance from the specified factory.
        /// </summary>
        public static Lazy<TResult> LazyCreate<T1, TResult>(this IFactory<T1, TResult> factory, Arg<T1> arg1) =>
            new Lazy<TResult>(() => factory.Create(arg1.Func()));

        /// <summary>
        /// Returns a <see cref="Lazy{T}"/> that creates an instance from the specified factory.
        /// </summary>
        public static Lazy<TResult> LazyCreate<T1, TResult>(this IFactory<T1, TResult> factory, T1 arg1) =>
            factory.LazyCreate(arg1.AsArg());

        /// <summary>
        /// Returns a <see cref="Lazy{T}"/> that creates an instance from the specified factory.
        /// </summary>
        public static Lazy<TResult> Create<TResult>(this Lazy<IFactory<TResult>> factory) =>
            factory.Select(f => f.Create());

        /// <summary>
        /// Returns a <see cref="Lazy{T}"/> that creates an instance from the specified factory.
        /// </summary>
        public static Lazy<TResult> Create<T1, TResult>(this Lazy<IFactory<T1, TResult>> factory, T1 arg1) =>
            factory.Select(f => f.Create(arg1));
    }
}