using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Reflection;
using Autofac;
using Autofac.Builder;
using Autofac.Core;
using Chernobyl.Destruction;
using Chernobyl.Extensions.Configuration;
using Chernobyl.Plugin;

namespace Chernobyl.Dependency.Autofac
{
    /// <summary>
    /// Dependency specific extensions using autofac.
    /// </summary>
    public static class AutofacExt
    {
        /// <summary>
        /// Loads the Autofac modules and Chernobyl plugins using the <see cref="ContainerBuilder"/>
        /// provided. Modules and plugins from the calling assembly will also be included.
        /// </summary>
        /// <param name="builder">The instance that loads the plugins.</param>
        /// <returns>The <see cref="IContainer"/> received after calling
        /// <see cref="ContainerBuilder.Build(ContainerBuildOptions)"/> and the Chernobyl plugins
        /// found from the Autofac modules. Make sure to dispose of these instances when shutting
        /// down the application or unloading the plugin.</returns>
        public static (IContainer, IEnumerable<TryDisposable<IPlugin>>) LoadPlugins(this ContainerBuilder builder)
        {
            var config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
            var pluginAssemblies = config.GetPluginAssemblies().Append(Assembly.GetCallingAssembly()).ToArray();
            builder.RegisterAssemblyModules(pluginAssemblies);
            var container = builder.Build();

            return (container, container.Resolve<IEnumerable<IPlugin>>().Select(plugin => new TryDisposable<IPlugin>(plugin)).ToArray());
        }

        /// <summary>
        /// Binds the type <typeparamref name="T"/> as a plugin. Typically plugin are constructed at
        /// application startup and disposed at application shutdown.
        /// </summary>
        public static void BindPlugin<T>(this ContainerBuilder builder)
        {
            builder.RegisterType<T>().AsSelf().SingleInstance();
            builder.RegisterType<Plugin<T>>().As<IPlugin>().SingleInstance();
        }

        /// <summary>
        /// Returns a predicate that returns true when the type is of <typeparamref name="T"/>.
        /// </summary>
        public static Func<ParameterInfo, IComponentContext, bool> TypePredicate<T>() =>
            (param, ctx) => param.ParameterType == typeof(T);

        /// <summary>
        /// Returns a method that uses the context to resolve the service named <paramref name="serviceName"/>.
        /// </summary>
        public static Func<ParameterInfo, IComponentContext, object> NamedAccessor<T>(string serviceName) =>
            (param, ctx) => ctx.ResolveNamed<T>(serviceName);
    }

    /// <summary>
    /// Resolves a service of the specified parameter and of type <typeparamref name="T"/> into a
    /// parameter of the same type.
    /// </summary>
    /// <typeparam name="T">The type of the parameter to inject into and the type of the service to
    /// inject into that parameter.</typeparam>
    public class Param<T> : ResolvedParameter
    {
        /// <inheritdoc />
        public Param(string serviceName)
            : base(AutofacExt.TypePredicate<T>(), AutofacExt.NamedAccessor<T>(serviceName))
        {}
    }
}