using Microsoft.EntityFrameworkCore;
using Strata.ContinuousImprovement.Biz.ClientWarehouses;
using Strata.ContinuousImprovement.Biz.Dtos;
using Strata.ContinuousImprovement.Biz.GMDN;
using Strata.ContinuousImprovement.Biz.Network;
using Strata.ContinuousImprovement.Biz.OpportunityComments;
using Strata.ContinuousImprovement.Biz.OpportunityTypeWorkbooks;
using Strata.ContinuousImprovement.Biz.OpportunityWorkbooks;
using Strata.ContinuousImprovement.Biz.Population;
using Strata.ContinuousImprovement.Biz.StrategicOpportunities;
using Strata.ContinuousImprovement.Biz.Test.Unit.Utilities;
using System.Diagnostics.CodeAnalysis;

namespace Strata.ContinuousImprovement.Biz.Test.Integration.CentralDbIntegrationTests
{
    [ExcludeFromCodeCoverage]
    [TestFixture, Category("Integration"), Category("CCI")]
    public class TestCentralDbOrm : IntegrationTestBase
    {
        public async Task TestGeneric<T>(TestContext testContext) where T : class
        {
            try
            {
                var testName = testContext.TestName(typeof(T).Name);
                var dbSet = ((DbContext)CentralDbContext).Set<T>();
                var count = await dbSet.CountAsync(CancellationToken.None);
                Assert.That(count, Is.GreaterThanOrEqualTo(0));
                if (count == 0)
                {
                    if (Activator.CreateInstance(typeof(T)) is T obj)
                    {
                        await dbSet.AddAsync(obj, CancellationToken.None);
                        await ((DbContext)CentralDbContext).SaveChangesAsync(CancellationToken.None);
                    }
                }
                var result = await dbSet.FirstOrDefaultAsync(CancellationToken.None);
                Assert.That(result, Is.Not.Null.And.InstanceOf<T>());
            }
            catch
            {
                // ILB
            }
        }

        public async Task TestFirst<T>(TestContext testContext) where T : class
        {
            try
            {
                var testName = testContext.TestName(typeof(T).Name) + " First";
                var dbSet = ((DbContext)CentralDbContext).Set<T>();
                var any = await dbSet.AnyAsync(CancellationToken.None);
                if (!any)
                {
                    if (Activator.CreateInstance(typeof(T)) is T obj)
                    {
                        await dbSet.AddAsync(obj, CancellationToken.None);
                        await ((DbContext)CentralDbContext).SaveChangesAsync(CancellationToken.None);
                    }
                }
                var result = await dbSet.FirstOrDefaultAsync(CancellationToken.None);
                Assert.That(result, Is.Not.Null.And.InstanceOf<T>());
            }
            catch
            {
                // ILB
            }
        }

        public async Task TestCount<T>(TestContext testContext) where T : class
        {
            try
            {
                var testName = testContext.TestName(typeof(T).Name) + " Count";
                var dbSet = ((DbContext)CentralDbContext).Set<T>();
                var count = await dbSet.CountAsync(CancellationToken.None);
                Assert.That(count, Is.GreaterThanOrEqualTo(0));
            }
            catch
            {
                // ILB
            }
        }

        [TestCaseSource(nameof(TestCaseSources))]
        public async Task TestOrmCases(string typeName, bool first)
        {
            var entityType = ((DbContext)CentralDbContext).Model.GetEntityTypes()
                .SingleOrDefault(et => et.ClrType.Name == typeName);
            if (entityType == null) { return; }
            if (first) { FirstCaseTests(typeName); }
            CountCaseTests(typeName);
        }

        public async Task FirstCaseTests(string typeName)
        {
            switch (typeName)
            {
                case nameof(ClientNetworkOpportunity):
                    await TestFirst<ClientNetworkOpportunity>(TestContext.CurrentContext);
                    break;
                case nameof(ClientNetworkOpportunityLink):
                    await TestFirst<ClientNetworkOpportunityLink>(TestContext.CurrentContext);
                    break;
                case nameof(ClientWarehouse):
                    await TestFirst<ClientWarehouse>(TestContext.CurrentContext);
                    break;
                case nameof(Comment):
                    await TestFirst<Comment>(TestContext.CurrentContext);
                    break;
                case nameof(DeviceIdentifierDimension):
                    await TestFirst<DeviceIdentifierDimension>(TestContext.CurrentContext);
                    break;
                case nameof(DeviceIdentifierTerm):
                    await TestFirst<DeviceIdentifierTerm>(TestContext.CurrentContext);
                    break;
                case nameof(GMDNCategory):
                    await TestFirst<GMDNCategory>(TestContext.CurrentContext);
                    break;
                case nameof(GMDNTerm):
                    await TestFirst<GMDNTerm>(TestContext.CurrentContext);
                    break;
                case nameof(GMDNTermCategory):
                    await TestFirst<GMDNTermCategory>(TestContext.CurrentContext);
                    break;
                case nameof(GUDIDDevice):
                    await TestFirst<GUDIDDevice>(TestContext.CurrentContext);
                    break;
                case nameof(GUDIDIdentifier):
                    await TestFirst<GUDIDIdentifier>(TestContext.CurrentContext);
                    break;
                case nameof(GUDIDTerm):
                    await TestFirst<GUDIDTerm>(TestContext.CurrentContext);
                    break;
                case nameof(NetworkOpportunity):
                    await TestFirst<NetworkOpportunity>(TestContext.CurrentContext);
                    break;
                case nameof(OpportunityTypeWorkbook):
                    await TestFirst<OpportunityTypeWorkbook>(TestContext.CurrentContext);
                    break;
                case nameof(OpportunityWorkbook):
                    await TestFirst<OpportunityWorkbook>(TestContext.CurrentContext);
                    break;
                case nameof(TmpGUDIDIdentifier):
                    await TestFirst<TmpGUDIDIdentifier>(TestContext.CurrentContext);
                    break;
                default:
                    throw new NotImplementedException(typeName);
            }
        }

        public async Task CountCaseTests(string typeName)
        {
            switch (typeName)
            {
                case nameof(ClientNetworkOpportunity):
                    await TestCount<ClientNetworkOpportunity>(TestContext.CurrentContext);
                    break;
                case nameof(ClientNetworkOpportunityLink):
                    await TestCount<ClientNetworkOpportunityLink>(TestContext.CurrentContext);
                    break;
                case nameof(ClientWarehouse):
                    await TestCount<ClientWarehouse>(TestContext.CurrentContext);
                    break;
                case nameof(Comment):
                    await TestCount<Comment>(TestContext.CurrentContext);
                    break;
                case nameof(DeviceIdentifierDimension):
                    await TestCount<DeviceIdentifierDimension>(TestContext.CurrentContext);
                    break;
                case nameof(DeviceIdentifierTerm):
                    await TestCount<DeviceIdentifierTerm>(TestContext.CurrentContext);
                    break;
                case nameof(GMDNCategory):
                    await TestCount<GMDNCategory>(TestContext.CurrentContext);
                    break;
                case nameof(GMDNTerm):
                    await TestCount<GMDNTerm>(TestContext.CurrentContext);
                    break;
                case nameof(GMDNTermCategory):
                    await TestCount<GMDNTermCategory>(TestContext.CurrentContext);
                    break;
                case nameof(GUDIDDevice):
                    await TestCount<GUDIDDevice>(TestContext.CurrentContext);
                    break;
                case nameof(GUDIDIdentifier):
                    await TestCount<GUDIDIdentifier>(TestContext.CurrentContext);
                    break;
                case nameof(GUDIDTerm):
                    await TestCount<GUDIDTerm>(TestContext.CurrentContext);
                    break;
                case nameof(NetworkOpportunity):
                    await TestCount<NetworkOpportunity>(TestContext.CurrentContext);
                    break;
                case nameof(OpportunityTypeWorkbook):
                    await TestCount<OpportunityTypeWorkbook>(TestContext.CurrentContext);
                    break;
                case nameof(OpportunityWorkbook):
                    await TestCount<OpportunityWorkbook>(TestContext.CurrentContext);
                    break;
                case nameof(TmpGUDIDIdentifier):
                    await TestCount<TmpGUDIDIdentifier>(TestContext.CurrentContext);
                    break;
                default:
                    throw new NotImplementedException(typeName);
            }
        }

        [Test]
        public async Task MissingCentralDbContextTestCases()
        {
            var types = ((DbContext)CentralDbContext).Model.GetEntityTypes()
                .Select(e => e.ClrType).OrderBy(c => c.Name).ToList();
            var missingTests = TestCaseSources()
                .Select(tc => tc.Arguments.First().ToString())
                .Where(tc => !types.Select(t => t.Name).Contains(tc));
            foreach (var test in missingTests)
            {
                try
                {
                    throw new NotImplementedException(test);
                }
                catch (Exception)
                {
                    // ILB
                    throw;
                }
            }
        }

        [Test]
        public async Task CentralDbContextTestCases()
        {
            var types = ((DbContext)CentralDbContext).Model.GetEntityTypes()
                .Select(e => e.ClrType).OrderBy(c => c.Name).ToList();

            foreach (var type in types)
            {
                switch (type.Name)
                {
                    case nameof(ClientNetworkOpportunity):
                        await TestGeneric<ClientNetworkOpportunity>(TestContext.CurrentContext);
                        break;
                    case nameof(ClientNetworkOpportunityLink):
                        await TestGeneric<ClientNetworkOpportunityLink>(TestContext.CurrentContext);
                        break;
                    case nameof(ClientWarehouse):
                        await TestGeneric<ClientWarehouse>(TestContext.CurrentContext);
                        break;
                    case nameof(Comment):
                        await TestGeneric<Comment>(TestContext.CurrentContext);
                        break;
                    case nameof(DeviceIdentifierDimension):
                        await TestGeneric<DeviceIdentifierDimension>(TestContext.CurrentContext);
                        break;
                    case nameof(DeviceIdentifierTerm):
                        await TestGeneric<DeviceIdentifierTerm>(TestContext.CurrentContext);
                        break;
                    case nameof(GMDNCategory):
                        await TestGeneric<GMDNCategory>(TestContext.CurrentContext);
                        break;
                    case nameof(GMDNTerm):
                        await TestGeneric<GMDNTerm>(TestContext.CurrentContext);
                        break;
                    case nameof(GMDNTermCategory):
                        await TestGeneric<GMDNTermCategory>(TestContext.CurrentContext);
                        break;
                    case nameof(GUDIDDevice):
                        await TestGeneric<GUDIDDevice>(TestContext.CurrentContext);
                        break;
                    case nameof(GUDIDIdentifier):
                        await TestGeneric<GUDIDIdentifier>(TestContext.CurrentContext);
                        break;
                    case nameof(GUDIDTerm):
                        await TestGeneric<GUDIDTerm>(TestContext.CurrentContext);
                        break;
                    case nameof(NetworkOpportunity):
                        await TestGeneric<NetworkOpportunity>(TestContext.CurrentContext);
                        break;
                    case nameof(OpportunityTypeWorkbook):
                        await TestGeneric<OpportunityTypeWorkbook>(TestContext.CurrentContext);
                        break;
                    case nameof(OpportunityWorkbook):
                        await TestGeneric<OpportunityWorkbook>(TestContext.CurrentContext);
                        break;
                    case nameof(TmpGUDIDIdentifier):
                        await TestGeneric<TmpGUDIDIdentifier>(TestContext.CurrentContext);
                        break;
                    case nameof(ExplorationInclusionExclusion):
                        await TestGeneric<ExplorationInclusionExclusion>(TestContext.CurrentContext);
                        break;
                    case nameof(ExplorationPopulation):
                        await TestGeneric<ExplorationPopulation>(TestContext.CurrentContext);
                        break;
                    case nameof(ExplorationPopulationEncounter):
                        await TestGeneric<ExplorationPopulationEncounter>(TestContext.CurrentContext);
                        break;
                    case nameof(StrategicOpportunity):
                        await TestGeneric<StrategicOpportunity>(TestContext.CurrentContext);
                        break;
                    case nameof(StrategicOpportunityChargeCode):
                        await TestGeneric<StrategicOpportunityChargeCode>(TestContext.CurrentContext);
                        break;
                    case nameof(StrategicOpportunityGL):
                        await TestGeneric<StrategicOpportunityGL>(TestContext.CurrentContext);
                        break;
                    case nameof(StrategicStakeholdersLink):
                        await TestGeneric<StrategicStakeholdersLink>(TestContext.CurrentContext);
                        break;
                    case nameof(StrategicOpportunityMeasure):
                        await TestGeneric<StrategicOpportunityMeasure>(TestContext.CurrentContext);
                        break;
                    case nameof(StrategicOpportunityWorkbook):
                        await TestGeneric<StrategicOpportunityWorkbook>(TestContext.CurrentContext);
                        break;
                    case nameof(StrategicOpportunityRampUp):
                        await TestGeneric<StrategicOpportunityRampUp>(TestContext.CurrentContext);
                        break;
                    case nameof(OpportunityRoleAssignment.OpportunityRoleAssignment):
                        await TestGeneric<OpportunityRoleAssignment.OpportunityRoleAssignment>(TestContext.CurrentContext);
                        break;
                    default:
                        var pathArr = TestContext.CurrentContext.TestDirectory.Split(Path.DirectorySeparatorChar);
                        var path = string.Join(Path.DirectorySeparatorChar, pathArr[..(pathArr.Length - 3)].Append("CentralDbIntegrationTests"));
                        var fileName = Path.Combine(path, $"{nameof(TestCentralDbOrm)}_{type.Name}.cs");
                        if (File.Exists(fileName)) break;
                        var testFile = @"
namespace Strata.ContinuousImprovement.Biz.Test.Integration.CentralDbIntegrationTests
{
    [TestFixture, Category(""Integration""), Category(""CCI"")]
    public partial class TestCentralDbContext : IntegrationTestBase
    {
        [Test]
        public async Task TestCentralDb" + type.Name + @"()
        {
            await TestGeneric<" + type.Name + @">(TestContext.CurrentContext);
        }
    }
}
";
                        File.WriteAllText(fileName, testFile);
                        break;
                }
            }
        }

        [Test]
        public async Task ClientNetworkOpportunityTest()
        {
            var opp = await CentralDbContext.ClientNetworkOpportunities.FirstOrDefaultAsync(CancellationToken.None);
            opp ??= new ClientNetworkOpportunity();
            opp.NetworkOpportunity ??= new NetworkOpportunity
            {
                Name = nameof(ClientNetworkOpportunityTest),
                Description = nameof(ClientNetworkOpportunityTest),
                WorkbookTemplateId = 0
            };
            var result = new ClientNetworkOpportunityDto(opp);
            Assert.That(result, Is.Not.Null.And.InstanceOf<ClientNetworkOpportunityDto>()
                .And.Property(nameof(ClientNetworkOpportunityDto.Name)).Not.Null
                .And.Property(nameof(ClientNetworkOpportunityDto.Description)).Not.Null
                .And.Property(nameof(ClientNetworkOpportunityDto.WorkbookTemplateId)).Not.Null);
        }
    }

}