using System;
using System.Linq;
using System.Reflection;
using Autofac;
using Nimbus;
using Nimbus.Configuration;
using Nimbus.Infrastructure;
using Nimbus.Infrastructure.Routing;
using Nimbus.InfrastructureContracts.Routing;
using Nimbus.Transports.AzureServiceBus;
using Rpmi.Messaging.Azure.Core.Messages;
using Rpmi.Messaging.Azure.Core.Sending;
using Serilog;
using Nimbus.InfrastructureContracts;
using Nimbus.Logger.Serilog.Logger.Serilog;
using RRpmi.Messaging.Azure.Core.Routing;
using Nimbus.LargeMessages.Azure.Client;
using Nimbus.Logger.Log4net.Logger.Log4Net;
using Nimbus.Configuration.LargeMessages.Settings;
using Rpmi.Messaging.Azure.Core;
using Nimbus.Configuration.Settings;

namespace Rpmi.Messaging.Azure.Core
{
    public static class AutofacBusBuilder
    {

        private static readonly log4net.ILog log = log4net.LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);

        public static void RegisterBusComponents(ContainerBuilder builder
            , Assembly[] assembliesToScan
            , string applicationName
            , string connectionString
            , string azureBlobStoreConnectionString
            , string azureBlobStoreContainerName
            , string instanceName = ""
            , int maxDeliveryAttempts = 99
            , TimeSpan? lockDuration = null)
        {


            if (string.IsNullOrWhiteSpace(connectionString)) throw new ArgumentNullException("connectionString");
            if (string.IsNullOrWhiteSpace(applicationName)) throw new ArgumentNullException("applicationName");

            if (string.IsNullOrWhiteSpace(instanceName))
                instanceName = Environment.MachineName;


            //Default lock duration to 5 minutes
            if (lockDuration == null)
                lockDuration = new TimeSpan(0, 5, 0);

            var handlerTypesProvider = CreateTypesProvider(assembliesToScan);

            builder.RegisterInstance(handlerTypesProvider);

            builder.Register(ctx => new Router(new DestinationPerMessageTypeRouter()))
                .As<IRouter>()
                .SingleInstance();

            builder.Register(ctx => BuildBus(connectionString, null, applicationName, instanceName, maxDeliveryAttempts, 
                (TimeSpan)lockDuration, ctx, handlerTypesProvider, azureBlobStoreConnectionString, azureBlobStoreContainerName))
                .As<IBus>()
                .AutoActivate()
                .SingleInstance();

            builder.RegisterType<MessageSender>().As<IMessageSender>().SingleInstance();
        }


        private static Bus BuildBus(string connectionString
            , Action<BusBuilderConfiguration> customConfiguration
            , string applicationName
            , string instanceName
            , int maxDeliveryAttempts
            , TimeSpan lockDuration
            , IComponentContext ctx
            , ITypeProvider handlerTypesProvider
            ,string azureBlobStoreConnectionString
            ,string azureBlobStoreContainerName)
        {

            MaxSmallMessageSizeSetting minMessageSize = new MaxSmallMessageSizeSetting();
            minMessageSize.Value = 64 * 1024;

            MaxLargeMessageSizeSetting maxMessageSize = new MaxLargeMessageSizeSetting();
            maxMessageSize.Value = 10 * 1048576;


            var busBuilder = new BusBuilder().Configure()
                .WithNames("Rpmi.Messaging.Azure.Core", Environment.MachineName)
                .WithTransport(new AzureServiceBusTransportConfiguration().WithConnectionString(connectionString)
                               .WithLargeMessageStorage(new AzureBlobStorageLargeMessageStorageConfiguration() { MaxSmallMessageSize= minMessageSize , MaxLargeMessageSize = maxMessageSize }
                               .UsingStorageAccountConnectionString(azureBlobStoreConnectionString)
                               .UsingBlobStorageContainerName(azureBlobStoreContainerName)))
                .WithTypesFrom(handlerTypesProvider)
                .WithMaxDeliveryAttempts(maxDeliveryAttempts)
                .WithDefaultTimeout(TimeSpan.FromSeconds(120))
                .WithRouter(ctx.Resolve<IRouter>())
                .WithLogger(new Log4NetLogger(log));


            return busBuilder.Build();
        }

        private static ITypeProvider CreateTypesProvider(Assembly[] assembliesToScan)
        {
            Assembly coreAssembly = Assembly.GetAssembly(typeof(IMessage));

            return new AssemblyScanningTypeProvider(assembliesToScan.Contains(coreAssembly)
                ? assembliesToScan
                : assembliesToScan.Concat(new[] { coreAssembly }).ToArray());
        }

        private static SerilogLogger BuildLogger()
        {
            var log = new LoggerConfiguration()
                .WriteTo.Log4Net();

            if (ShouldOutputNimbusDebugMessages())
            {
                // for some reason the Debug messages from Nimbus doesn't pick up the logging level set in the log4net config file
                log.MinimumLevel.Debug();
            }

            return new SerilogLogger(log.CreateLogger());
        }

        private static bool ShouldOutputNimbusDebugMessages()
        {
            bool debugLoggingDefaultValue = false;

#if DEBUG
            debugLoggingDefaultValue = true;
#endif

            return AppSettings.Get(AppSettings.EnableDebug, debugLoggingDefaultValue);
        }
    }
}

******************************************************************************************
Below is a separate namespace which call into the main config above from the Worker Service
******************************************************************************************

namespace Autofac
{
    public static class ContainerBuilderExtensions
    {
        public static void RegisterBusComponents(this ContainerBuilder builder
            , Assembly[] assembliesToScan
            , string applicationName
            , string connectionString
            , string azureBlobStoreConnectionString
            , string azureBlobStoreContainerName
            , string instanceName = ""
            , int maxDeliveryAttempts = 99
            , TimeSpan? lockDuration = null)
        {
            AutofacBusBuilder.RegisterBusComponents(builder
                , assembliesToScan
                , applicationName            
                , connectionString
                , azureBlobStoreConnectionString
                , azureBlobStoreContainerName
                , instanceName
                , maxDeliveryAttempts
                , lockDuration);
        }
    }
}