using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using System;
using System.Threading;
using System.Threading.Tasks;
using Autofac;
using InvestmentsServicesGateway.ServiceLibrary.Net5.Factories.ModelFactory.Implementations;
using InvestmentsServicesGateway.ServiceLibrary.Net5.Factories.ModelFactory.Interfaces;
using InvestmentsServicesGateway.ServiceLibrary.Net5.FileProcessors.Implementations.Bancs;
using InvestmentsServicesGateway.ServiceLibrary.Net5.FileProcessors.Interfaces;
using InvestmentsServicesGateway.ServiceLibrary.Net5.Global;
using InvestmentsServicesGateway.ServiceLibrary.Net5.Helpers.Implementations;
using InvestmentsServicesGateway.ServiceLibrary.Net5.Helpers.Interfaces;
using InvestmentsServicesGateway.ServiceLibrary.Net5.MessagingService.Receive.Implementations;
using InvestmentsServicesGateway.ServiceLibrary.Net5.MessagingService.Receive.Interfaces;
using InvestmentsServicesGateway.ServiceLibrary.Net5.MessagingService.Send.Implementations;
using InvestmentsServicesGateway.ServiceLibrary.Net5.MessagingService.Send.Interfaces;
using InvestmentsServicesGateway.ServiceLibrary.Net5.TradeStateProcessors.Implementations;
using InvestmentsServicesGateway.ServiceLibrary.Net5.TradeStateProcessors.Interfaces;
using InvestmentsServicesGateway.ServiceLibrary.Net5.ViaNova.Convertors.Implementations;
using InvestmentsServicesGateway.ServiceLibrary.Net5.ViaNova.Convertors.Interfaces;
using InvestmentsServicesGateway.ServiceLibrary.Net5.ViaNova.DocumentBuilder.Implementations;
using InvestmentsServicesGateway.ServiceLibrary.Net5.ViaNova.DocumentBuilder.Interfaces;
using InvestmentsServicesGateway.ServiceLibrary.Net5.XmlProcessors.Implementations;
using InvestmentsServicesGateway.ServiceLibrary.Net5.XmlProcessors.Interfaces;
using ISG.DAL;
using ISG.DAL.Factories.Implementations;
using ISG.DAL.Factories.Interfaces;
using ISG.DAL.Implementations;
using ISG.DAL.Interfaces;
using ISG.Models.Enums;
using ISG.Models.Internal;
using log4net.Config;
using Nimbus.InfrastructureContracts;
using System.Collections.Generic;
using System.Configuration;
using System.Reflection;
using Nimbus;
using Microsoft.Extensions.Configuration;
using log4net;
using System.IO;
using ISG.ServiceBus.Handlers.Net5;
using Investments.ServiceBus.Messages.Net5.Messages;
using Rpmi.Messaging.Azure.Core.Messages;
using Investments.Models.Bancs;

namespace ISG.ServiceBus.ReceiverNet5.WorkerService
{
    public class Worker : BackgroundService
    {
        private readonly ILogger<Worker> _logger;
        private static IContainer _container;
        private static string _endPointConnection = ConfigurationManager.AppSettings["ConnectionString"];
        private static string _storageConnection = ConfigurationManager.AppSettings["AzureBlobStoreConnectionString"];
        private static string _storageContainer = ConfigurationManager.AppSettings["AzureBlobStoreContainerName"];
		private readonly Bus _bus;
		private readonly IConfiguration _configuration;
		private static readonly ILog _log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
		private bool _busStarted;

		public Worker(ILogger<Worker> logger, IConfiguration configuration)
        {
            _logger = logger;
			_configuration = configuration;

			// Load log4net configuration
			var logRepository = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			XmlConfigurator.Configure(new FileInfo(Path.Combine(logRepository, "app.config")));

			//get the connections from the config 
			GetConnections();

			//configure the container
			StartContainer();


			if (_container.Resolve<IBus>() == null) throw new ArgumentNullException("bus");
			var instance = _container.Resolve<IBus>() as Bus;

			if (instance == null) throw new InvalidCastException("bus is not an instance of the Nimbus bus");
			this._bus = instance;

		}

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
			try
			{
				while (!stoppingToken.IsCancellationRequested)
				{
					if (!_busStarted)
					{
						await StartBus();

						_log.Info($"ISG.ServiceBus.ReceiverNet5.WorkerService running at: {DateTimeOffset.Now}");
						await Task.Delay(1000, stoppingToken);
						_busStarted = true;
					}
				}
			}
			catch(Exception e)
            {
				//await StopBus();
				var exceptionType = e.GetType().FullName;
				var method = e.GetType().DeclaringMethod;
				var caller = e.GetType().AssemblyQualifiedName;
				_log.Error(e.Message, e);
			}
        }

		private void GetConnections()
        {
			_endPointConnection = _configuration.GetValue<string>("Connections:AzureServiceBus:EndpointConnection");
			_storageConnection = _configuration.GetValue<string>("Connections:AzureStorage:StorageConnection");
			_storageContainer = _configuration.GetValue<string>("Connections:AzureStorage:StorageContainer"); 
		}

		private void StartContainer()
        {
			//Log4net
			XmlConfigurator.Configure();

			//Autofac
			_container = BuildContainer();
		}

		private async Task StartBus()
        {
			try
			{
				await _bus.Start(Nimbus.Configuration.MessagePumpTypes.All);
			}
			catch (Exception e)
            {
                throw;
            }
		}

		private async Task StopBus()
        {
			//we have an error stop the bus instance
			await _bus.Stop();
        }


		static IContainer BuildContainer()
		{
			var builder = new ContainerBuilder();

			//The GlobalData object can be shared
			builder.RegisterType<MessageIDCreator>().As<IMessageIDCreator>().InstancePerLifetimeScope();

			builder.RegisterType<GlobalData>().As<IGlobalData>();

			builder.RegisterType<ViaNovaModelFactory>().As<IViaNovaModelFactory>();

			builder.RegisterType<TradeRepositoryFactory>().As<ITradeRepositoryFactory>();
			builder.RegisterType<InvestmentFileProcessor>().As<IInvestmentFileProcessor>();
			builder.RegisterType<SchemeCodeConvertor>().As<ISchemeCodeConvertor>();
			builder.RegisterType<InvestmentViaNovaProcessor>().As<IInvestmentViaNovaProcessor>();
			builder.RegisterType<TradeResponseProcessor>().As<ITradeResponseProcessor>();
			builder.RegisterType<EmailNotifier>().As<IEmailNotifier>();
			builder.RegisterType<ModelFactory>().As<IModelFactory>();
			builder.RegisterType<TradeStateReverser>().As<ITradeStateReverser>();
			builder.RegisterType<TradeStateProcessor>().As<ITradeStateProcessor>();
			builder.RegisterType<Audit>().As<IAudit>();
			builder.RegisterType<ViaNovaDocumentMerger>().As<IViaNovaDocumentMerger>();
			builder.RegisterType<InvestmentViaNovaProcessor>().As<IInvestmentViaNovaProcessor>();
			builder.RegisterType<TradeStateSenderSelector>().As<ITradeStateSenderSelector>();

			builder.Register<IInvestmentsServicesGatewayRepository>(c => new InvestmentsServicesGatewayRepository(new InvestmentsServicesGatewayEntities()));


			//builder.RegisterType<GenericRepository<ITrade>>().As<IGenericRepository<ITrade>>().InstancePerRequest();
			//builder.RegisterType<InvestmentViaNovaProcessor>().As<IInvestmentViaNovaProcessor>();

			builder.RegisterGeneric(typeof(GenericRepository<>))
				.As(typeof(IGenericRepository<>));

			builder.RegisterGeneric(typeof(InvestmentXMLProcessor<>))
				.As(typeof(IInvestmentXMLProcessor<>));



			builder.RegisterType<BancsUnitHoldingProcessor>()
				.As<IFileProcessor>()
				.Keyed<IFileProcessor>(typeof(Investments.Models.Bancs.UnitHolding));


			builder.Register<Func<Type, Lazy<IFileProcessor>>>(c =>
			{
				var ctx = c.Resolve<IComponentContext>();
				return type => !ctx.IsRegisteredWithKey<IFileProcessor>(type) ? null : ctx.ResolveKeyed<Lazy<IFileProcessor>>(type);
			});





			builder.RegisterType<RedemptionConvertor>()
				.As<IViaNovaConvertor>()
				.Keyed<IViaNovaConvertor>(ViaNovaFileType.Redemption);

			builder.RegisterType<SubscriptionConvertor>()
				.As<IViaNovaConvertor>()
				.Keyed<IViaNovaConvertor>(ViaNovaFileType.Subscription);

			builder.RegisterType<SwitchConvertor>()
				.As<IViaNovaConvertor>()
				.Keyed<IViaNovaConvertor>(ViaNovaFileType.Switch);

			builder.Register<Func<ViaNovaFileType, Lazy<IViaNovaConvertor>>>(c =>
			{
				var ctx = c.Resolve<IComponentContext>();
				return type => !ctx.IsRegisteredWithKey<IViaNovaConvertor>(type) ? null : ctx.ResolveKeyed<Lazy<IViaNovaConvertor>>(type);
			});



			//***************************
			// Trade Generic Repository
			//***************************
			builder.RegisterType<RedemptionTradeGenericRepository>()
				.As<ITradeGenericRepository>()
				.Keyed<ITradeGenericRepository>(Investments.Models.TradeType.Redemption);

			builder.RegisterType<SubscriptionTradeGenericRepository>()
				.As<ITradeGenericRepository>()
				.Keyed<ITradeGenericRepository>(Investments.Models.TradeType.Subscription);

			builder.RegisterType<SwitchTradeGenericRepository>()
				.As<ITradeGenericRepository>()
				.Keyed<ITradeGenericRepository>(Investments.Models.TradeType.Switch);

			builder.RegisterType<TupeTradeGenericRepository>()
				.As<ITradeGenericRepository>()
				.Keyed<ITradeGenericRepository>(Investments.Models.TradeType.Tupe);

			builder.RegisterType<AvivaBrass1TradeGenericRepository>()
				.As<ITradeGenericRepository>()
				.Keyed<ITradeGenericRepository>(Investments.Models.TradeType.AvivaBrass1);

			builder.RegisterType<AvivaBrass2TradeGenericRepository>()
				.As<ITradeGenericRepository>()
				.Keyed<ITradeGenericRepository>(Investments.Models.TradeType.AvivaBrass2);

			builder.Register<Func<Investments.Models.TradeType, Lazy<ITradeGenericRepository>>>(c =>
			{
				var ctx = c.Resolve<IComponentContext>();
				return type => !ctx.IsRegisteredWithKey<ITradeGenericRepository>(type) ? null : ctx.ResolveKeyed<Lazy<ITradeGenericRepository>>(type);
			});



			//****************
			// Xml processors
			//****************
			builder.RegisterType<UnitTransferXmlProcessor>()
				.As<IXMLProcessor>()
				.Keyed<IXMLProcessor>(typeof(UnitTransferMessage));

			builder.RegisterType<AvivaTradeInstructionXMLProcessor>()
				.As<IXMLProcessor>()
				.Keyed<IXMLProcessor>(typeof(AvivaTradeInstructionMessage));

			builder.Register<Func<Type, Lazy<IXMLProcessor>>>(c =>
			{
				var ctx = c.Resolve<IComponentContext>();
				return type => !ctx.IsRegisteredWithKey<IXMLProcessor>(type) ? null : ctx.ResolveKeyed<Lazy<IXMLProcessor>>(type);
			});


			//*****************
			//  Model Factory
			//*****************
			builder.RegisterType<AuditTradeStateConvertor>()
				.As<IModelConvertor>()
				.Keyed<IModelConvertor>(typeof(AuditTradeState));

			builder.RegisterType<AvivaTradeInstructionConvertor>()
				.As<IModelConvertor>()
				.Keyed<IModelConvertor>(typeof(AvivaTrade));

			builder.RegisterType<UnitTransferConvertor>()
				.As<IModelConvertor>()
				.Keyed<IModelConvertor>(typeof(ISG.DAL.UnitTransfer));

			builder.RegisterType<TradeResponseConvertor>()
				.As<IModelConvertor>()
				.Keyed<IModelConvertor>(typeof(List<ISG.DAL.TradeResponse>));

			builder.RegisterType<AuditTradeStateConvertor>()
				.As<IModelConvertor>()
				.Keyed<IModelConvertor>(typeof(TradeStatusModel));


			builder.Register<Func<Type, Lazy<IModelConvertor>>>(c =>
			{
				var ctx = c.Resolve<IComponentContext>();
				return type => !ctx.IsRegisteredWithKey<IModelConvertor>(type) ? null : ctx.ResolveKeyed<Lazy<IModelConvertor>>(type);
			});

			//**************************************
			//  Service Bus Via Nova Message Sender
			//**************************************
			builder.RegisterType<ContractNoteRedMessageSender>()
				.As<IViaNovaMessageSender>()
				.Keyed<IViaNovaMessageSender>(ViaNovaFileType.ContractNote_Redemption);

			builder.RegisterType<ContractNoteSubMessageSender>()
				.As<IViaNovaMessageSender>()
				.Keyed<IViaNovaMessageSender>(ViaNovaFileType.ContractNote_Subscription);

			builder.RegisterType<ContractNoteSwtMessageSender>()
				.As<IViaNovaMessageSender>()
				.Keyed<IViaNovaMessageSender>(ViaNovaFileType.ContractNote_Switch);

			builder.RegisterType<PriceReportMessageSender>()
				.As<IViaNovaMessageSender>()
				.Keyed<IViaNovaMessageSender>(ViaNovaFileType.PriceReport);

			builder.RegisterType<UnitHoldingMessageSender>()
				.As<IViaNovaMessageSender>()
				.Keyed<IViaNovaMessageSender>(ViaNovaFileType.UnitHoldings);

			builder.Register<Func<ViaNovaFileType, Lazy<IViaNovaMessageSender>>>(c =>
			{
				var ctx = c.Resolve<IComponentContext>();
				return type => !ctx.IsRegisteredWithKey<IViaNovaMessageSender>(type) ? null : ctx.ResolveKeyed<Lazy<IViaNovaMessageSender>>(type);
			});

			//****************************
			//  Via Nova Document Merger
			//****************************

			builder.RegisterType<RedemptionConfDocMerger>()
				.As<IDocumentMerger>()
				.Keyed<IDocumentMerger>(ViaNovaFileType.ContractNote_Redemption);

			builder.Register<Func<ViaNovaFileType, IDocumentMerger>>(c =>
			{
				var ctx = c.Resolve<IComponentContext>();
				return type => !ctx.IsRegisteredWithKey<IDocumentMerger>(type) ? null : ctx.ResolveKeyed<IDocumentMerger>(type);
			});

			//******************************
			//  Trade State Sender Selector
			//******************************
			builder.RegisterType<ViaNovaTradeStateSender>()
				.As<ITradeStateSender>()
				.Keyed<ITradeStateSender>(OrderStateUpdateType.ViaNova);

			builder.RegisterType<AvivaTradeStateSender>()
				.As<ITradeStateSender>()
				.Keyed<ITradeStateSender>(OrderStateUpdateType.Aviva);

			builder.Register<Func<OrderStateUpdateType, Lazy<ITradeStateSender>>>(c =>
			{
				var ctx = c.Resolve<IComponentContext>();
				return type => !ctx.IsRegisteredWithKey<ITradeStateSender>(type) ? null : ctx.ResolveKeyed<Lazy<ITradeStateSender>>(type);
			});


******************************************************************************************
This calls the xstn method in the second namespace in the MainConfig 
******************************************************************************************

			builder.RegisterBusComponents(new[] { Assembly.GetAssembly(typeof(UnitHoldingMessage)), Assembly.GetAssembly(typeof(UnitHoldingMessageHandler)) }
					, "InvestmentsTradingGateway"
					, _endPointConnection
					, _storageConnection
					, _storageContainer
					, ""
					, 99
					, null

					);

			return builder.Build();
		}
	}
}