using Hangfire;
using Microsoft.AspNetCore.SignalR;
using Microsoft.EntityFrameworkCore;
using Moq;
using NUnit.Framework;
using Strata.Authorization;
using Strata.ContinuousImprovement.Biz.Configuration;
using Strata.ContinuousImprovement.Biz.DbContexts;
using Strata.ContinuousImprovement.Biz.DbContexts.Snowflake;
using Strata.ContinuousImprovement.Biz.FiscalMonths;
using Strata.ContinuousImprovement.Biz.Generics;
using Strata.ContinuousImprovement.Biz.Initiatives;
using Strata.ContinuousImprovement.Biz.Notification;
using Strata.ContinuousImprovement.Biz.Test.Unit.Utilities;
using Strata.ContinuousImprovement.JazzEntityFrameworkStub;
using Strata.CoreLib.Claims;
using Strata.Hangfire.Jazz.Client;
using Strata.Id.Client;
using Strata.Schema.Client;
using Strata.SqlTools.Configuration.Common.AsyncFactory;
using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using VerifyTests;

namespace Strata.ContinuousImprovement.Biz.Test.Unit
{
    [ExcludeFromCodeCoverage]
    [TestFixture]
    public class OpportunityServiceTests
    {
        public VerifySettings VerifySettings { get; set; }
        public CentralDbContext CentralDbContext { get; set; }
        public IClaimsPrincipalAccessor ClaimsPrincipalAccessor { get; set; }
        public IAsyncDbContextFactory<JazzDbContext> DbContextFactory { get; set; }
        public IJazzDbContext JazzDbContext { get; set; }
        public IJazzHangfireServiceClient JazzHangfireServiceClient { get; set; }
        public IAuthorizationServiceClient AuthorizationServiceClient { get; set; }
        public IIdServiceClient IdServiceClient { get; set; }
        public IConfigurationService ConfigurationService { get; set; }

        public IFiscalMonthResolver FiscalMonthResolver { get; set; }
        public ISchemaServiceClient SchemaServiceClient { get; set; }
        public IBackgroundJobClient BackgroundJobClient { get; set; }
        public INotificationHub NotificationHub { get; set; }
        public IHubClients<INotificationHub> HubClients { get; set; }
        public IHubContext<NotificationHub, INotificationHub> NotificationHubContext { get; set; }
        public IInitiativeService InitiativeService { get; set; }
        public ISnowflakeDatabaseContext SnowflakeDatabaseContext { get; set; }
        public IUpdateFactOpportunitySavingsService UpdateFactOpportunitySavingsService { get; set; }

        public JazzEntityFrameworkFactory JAZZ_Framework { get; set; }

        [OneTimeSetUp]
        public async Task TestFixtureSetup()
        {
            VerifySettings = TestExtensions.TestSettings();
            var dbContextOptions = new DbContextOptions<CentralDbContext>();
            CentralDbContext = new CentralDbContext(dbContextOptions);
            ClaimsPrincipalAccessor = Mock.Of<IClaimsPrincipalAccessor>();
            DbContextFactory = Mock.Of<IAsyncDbContextFactory<JazzDbContext>>();
            JazzHangfireServiceClient = Mock.Of<IJazzHangfireServiceClient>();
            AuthorizationServiceClient = Mock.Of<IAuthorizationServiceClient>();
            IdServiceClient = Mock.Of<IIdServiceClient>();
            ConfigurationService = Mock.Of<IConfigurationService>();
            FiscalMonthResolver = Mock.Of<IFiscalMonthResolver>();
            SchemaServiceClient = Mock.Of<ISchemaServiceClient>();
            BackgroundJobClient = Mock.Of<IBackgroundJobClient>();
            NotificationHub = Mock.Of<INotificationHub>();
            HubClients = Mock.Of<IHubClients<INotificationHub>>();
            NotificationHubContext = Mock.Of<IHubContext<NotificationHub, INotificationHub>>();
            InitiativeService = Mock.Of<IInitiativeService>();
            SnowflakeDatabaseContext = Mock.Of<ISnowflakeDatabaseContext>();
            UpdateFactOpportunitySavingsService = Mock.Of<IUpdateFactOpportunitySavingsService>();

            JAZZ_Framework = new JazzEntityFrameworkFactory();
            JazzDbContext = await JAZZ_Framework.CreateDbContextAsync(CancellationToken.None);
            var configurations = JazzDbContext.Configurations;

            Mock.Get(AuthorizationServiceClient)
                .Setup(o => o.AddPermissionsFromDefaultsAsync(It.IsAny<Guid>(), It.IsAny<SecurableEntityType>(), It.IsAny<CancellationToken>()));
            Mock.Get(ConfigurationService)
                .Setup(s => s.GetConfigurationAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
                .Returns<Guid, CancellationToken>((configurationGuid, token) =>
                    Task.FromResult(configurations.SingleOrDefault(c => c.ConfigurationGuid == configurationGuid)));

            Mock.Get(IdServiceClient)
                .Setup(s => s.GetStrataId(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(9));

            Mock.Get(NotificationHub)
                .Setup(s => s.SendOpportunityUpdate(It.IsAny<string>()));
            Mock.Get(NotificationHub)
                .Setup(s => s.SendOpportunityUpdateError(It.IsAny<string>(), It.IsAny<string>()));
            Mock.Get(HubClients)
                .Setup(s => s.Group(It.IsAny<string>()))
                .Returns(NotificationHub);
            Mock.Get(NotificationHubContext)
                .Setup(s => s.Clients)
                .Returns(HubClients);

            Mock.Get(InitiativeService)
                .Setup(s => s.DeleteAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(true));
            Mock.Get(UpdateFactOpportunitySavingsService)
                .Setup(s => s.UpdateFactOpportunitySavings(It.IsAny<CancellationToken>()));

            Mock.Get(DbContextFactory)
                .Setup(s => s.CreateDbContextAsync(It.IsAny<CancellationToken>()))
                .Returns(() => Task.FromResult((JazzDbContext)JazzDbContext));
        }
    }
}