using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Moq;
using Strata.Analytics.Client;
using Strata.Analytics.Models.Workbooks;
using Strata.ContinuousImprovement.Biz.DbContexts;
using Strata.ContinuousImprovement.Biz.DbContexts.Snowflake;
using Strata.ContinuousImprovement.Biz.Generics;
using Strata.ContinuousImprovement.Biz.OpportunityTypeWorkbooks;
using Strata.ContinuousImprovement.Biz.OpportunityWorkbooks;
using Strata.ContinuousImprovement.JazzEntityFrameworkStub;
using Strata.SqlTools.Configuration.Common.AsyncFactory;

namespace Strata.ContinuousImprovement.Client.Test.Integration.Setup
{
    public static class ServiceProperties
    {
        // dev master
        internal static readonly Guid DatabaseGuid = new("54409f55-5ddf-4748-8222-9ccfb04fb4f5");

#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
        public static IContinuousImprovementService ContinuousImprovementService { get; set; }
        public static ICentralDbContext CentralDbContext { get; set; }
        public static JazzEntityFrameworkFactory JazzConnBuilderFactory { get; set; }
        public static IJazzDbContext JazzDbContext { get; set; }
        public static ISnowflakeDatabaseContext SnowflakeDatabaseContext { get; set; }
        public static IServiceCollection Services { get; set; }
        public static IServiceProvider ServiceProvider { get; set; }
        public static IAnalyticsService AnalyticsService { get; set; }
#pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.

        private static int WorkbookId = 9;

        public static async Task SetupServiceProperties(this IServiceCollection services, int strataId = 0)
        {
            Services = services;
            var serviceProvider = services.BuildServiceProvider();
            ServiceProvider = serviceProvider;

            try
            {
                var sfConnBuilderFactory = serviceProvider.GetRequiredService<ISnowflakeDatabaseContextFactory>();
                SnowflakeDatabaseContext = sfConnBuilderFactory.Create($"{DatabaseGuid:N}");
            }
            catch (Exception)
            {
                // ILB
            }

            try
            {
                var jazzConnBuilderFactory = serviceProvider.GetRequiredService<IAsyncDbContextFactory<JazzDbContext>>();
                JazzDbContext = await jazzConnBuilderFactory.CreateDbContextAsync(CancellationToken.None);
            }
            catch (Exception)
            {
                // ILB
            }

            await BuildPostgresDb(strataId);

            BuildAnalyticsService(strataId);
        }

        private static async Task BuildPostgresDb(int strataId)
        {
            try
            {
                CentralDbContext = ServiceProvider.GetService<CentralDbContext>() as CentralDbContext
                    ?? throw new NullReferenceException(nameof(CentralDbContext));
                var centralDbContext = CentralDbContext as CentralDbContext;
                if (centralDbContext == null) { throw new NullReferenceException(nameof(centralDbContext)); }

                await centralDbContext.Database.MigrateAsync(CancellationToken.None);
                JazzConnBuilderFactory = new JazzEntityFrameworkFactory();
                await JazzConnBuilderFactory.EnsureCreatedAsync(centralDbContext, JazzDbContext, CancellationToken.None);
                var workbook = new OpportunityWorkbook
                {
                    StrataId = strataId,
                    WorkbookId = WorkbookId,
                    OpportunityGuid = Guid.NewGuid(),
                    Name = "Test",
                };
                Assert.That(centralDbContext, Is.Not.Null);
                await centralDbContext.OpportunityWorkbooks.AddAsync(workbook, CancellationToken.None);

                var oppTypeWorkbook = new OpportunityTypeWorkbook
                {
                    StrataId = strataId,
                    WorkbookId = WorkbookId,
                    OpportunityType = (int)OpportunityTypes.ChargeCode,
                    Name = "Test",
                };
                Assert.That(centralDbContext, Is.Not.Null);
                await centralDbContext.OpportunityTypeWorkbooks.AddAsync(oppTypeWorkbook, CancellationToken.None);

                await centralDbContext.SaveChangesAsync(CancellationToken.None);
            }
            catch (Exception)
            {
                throw;
            }

        }

        private static void BuildAnalyticsService(int strataId)
        {
            var analyticsService = Mock.Of<IAnalyticsService>();
            var workbook = new Workbook
            {
                Name = "Test",
                WorkbookId = WorkbookId,
                IsHidden = false,
                StrataId = strataId,
            };
            var workbooks = new List<Workbook> { workbook };
            workbooks.AddRange(Enumerable.Range(1, 1000).Where(i => i != WorkbookId).Select(i => new Workbook
            {
                Name = $"Test {i}",
                WorkbookId = i,
                IsHidden = (i % 2 == 0),
                StrataId = (i % 3 == 0) ? 9 : strataId,
            }));
            //GetWorkbooksAsync
            Mock.Get(analyticsService)
                .Setup(s => s.GetWorkbookAsync(It.IsAny<int>(), It.IsAny<CancellationToken>()))
                .Returns<int, CancellationToken>((id, token)
                    => Task.FromResult(id == WorkbookId ? workbook : null));
            Mock.Get(analyticsService)
                .Setup(s => s.GetWorkbooksAsync(It.IsAny<bool>(), It.IsAny<CancellationToken>()))
                .Returns<bool, CancellationToken>((isHidden, token)
                    => Task.FromResult(workbooks.Where(w => w.IsHidden == isHidden)));
            AnalyticsService = analyticsService;
        }

    }

}