using System;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Creation;

namespace Chernobyl.Plugin
{
    /// <summary>
    /// The default <see cref="IPluginBuilder"/> implementation. This class 
    /// makes it easier to create new <see cref="IPluginBuilder"/>s.
    /// </summary>
    public abstract class PluginBuilder : Builder<Object[]>, IPluginBuilder
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="PluginBuilder"/> class.
        /// </summary>
        /// <param name="services">The <see cref="IEventCollection{T}"/> instance
        /// that gives and takes services and is given to the created plug-ins 
        /// if they have a constructor that takes an <see cref="IEventCollection{T}"/> 
        /// instance.</param>
        protected PluginBuilder(IEventCollection<object> services)
        {
            Predicate = DefaultPredicate;
            Creator = new DefaultCreator(services);
        }

        /// <summary>
        /// The method used to choose which types to create.
        /// </summary>
        public Predicate<Type> Predicate { get; set; }

        /// <summary>
        /// The method used to create an instance of the Type passed in. The
        /// default value of this property is an instance of 
        /// <see cref="DefaultCreator"/>.
        /// </summary>
        public Func<Type, object> Creator { get; set; }

        /// <summary>
        /// A class that holds the default method for <see cref="Creator"/> property.
        /// </summary>
        public class DefaultCreator
        {
            /// <summary>
            /// Initializes a new instance of the <see cref="DefaultCreator"/> class.
            /// </summary>
            /// <param name="services">The <see cref="IEventCollection{T}"/> instance that 
            /// gives and takes services and is given to the created plug-ins 
            /// if they have a constructor that takes an <see cref="IEventCollection{T}"/> 
            /// instance.</param>
            public DefaultCreator(IEventCollection<object> services) { Services = services; }

            /// <summary>
            /// The default method for the <see cref="PluginBuilder.Creator"/> 
            /// property. This method checks for a constructor on the passed in type 
            /// that takes an <see cref="IEventCollection{T}"/> instance. If one isn't found 
            /// then the instance is created using it's parameterless constructor.
            /// </summary>
            /// <param name="type">The type to create an instance of.</param>
            /// <returns>The created instance.</returns>
            public object Creator(Type type)
            {
                return type.GetConstructor(new[] { typeof(IEventCollection<object>) }) != null ? 
                       Activator.CreateInstance(type, Services) : Activator.CreateInstance(type);
            }

            /// <summary>
            /// Performs an implicit conversion from <see cref="DefaultCreator"/>
            /// to <see cref="Func{Type, Object}"/>.
            /// </summary>
            /// <param name="defaultCreator">The <see cref="DefaultCreator"/> to
            /// convert.</param>
            /// <returns>The result of the conversion.</returns>
            public static implicit operator Func<Type, object>(DefaultCreator defaultCreator)
            {
                return defaultCreator.Creator;
            }

            /// <summary>
            /// The <see cref="IEventCollection{T}"/> instance that 
            /// gives and takes services and is given to the created plug-ins 
            /// if they have a constructor that takes an <see cref="IEventCollection{T}"/> 
            /// instance.
            /// </summary>
            public IEventCollection<object> Services { get; protected set; }
        }

        /// <summary>
        /// The default value of the <see cref="Predicate"/> property. The 
        /// default predicate returns true if the Type passed in implements the
        /// <see cref="IPlugin"/> interface.
        /// </summary>
        public static bool DefaultPredicate(Type type)
        {
            return typeof(IPlugin).IsAssignableFrom(type);
        }
    }
}