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

namespace Chernobyl.Plugin
{
    /// <summary>
    /// Creates plug-ins from assembly files.
    /// </summary>
    public class AssemblyFilePluginFactory : PluginBuilder, IFactory<IEnumerable<AssemblyName>, Object[]>
    {
        /// <summary>
        /// Constructor.
        /// </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 AssemblyFilePluginFactory(IEventCollection<object> services)
            : this(services, assembly => { /* By default, do nothing with assemblies. */ })
        { }

        /// <summary>
        /// Constructor.
        /// </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>
        /// <param name="processAssembly">An optional, additional action performed
        /// on loaded assemblies prior to the plug-ins being created.</param>
        public AssemblyFilePluginFactory(IEventCollection<object> services, Action<Assembly> processAssembly)
            : base(services)
        {
            processAssembly.ThrowIfNull("processAssembly");
            _processAssembly = processAssembly;
        }

        /// <inheritdoc />
        public object[] Create(IEnumerable<AssemblyName> assemblyNames)
        {
            try
            {
                List<object> interfaces = new List<object>();
                foreach (AssemblyName name in assemblyNames)
                {
                    Assembly moduleAssembly = Assembly.Load(name);
                    _processAssembly(moduleAssembly);

                    // go through all of the types in the module, find the types
                    // specified by the predicate and create it.
                    Type[] types = moduleAssembly.GetTypes();
                    interfaces.AddRange(from type in types
                                        where Predicate(type)
                                        select Creator(type));
                }

                var result = interfaces.ToArray();
                ReportCreation(result);
                return result;
            }
            catch (Exception e)
            {
                ReportCreation(new CreationEventArgs<object[]>(e));
                throw;
            }

        }

        /// <summary>
        /// An optional, additional action performed on loaded assemblies prior
        /// to the plug-ins being created.
        /// </summary>
        readonly Action<Assembly> _processAssembly;
    }
}