using ClosedXML.Excel;
using DocumentFormat.OpenXml.Drawing.Diagrams;
using FluentAssertions;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Moq;
using NUnit.Framework;
using Strata.ContinuousImprovement.Api.Controllers;
using Strata.ContinuousImprovement.Biz.All.Opportunities;
using Strata.ContinuousImprovement.Biz.ChargeCode.Initiatives;
using Strata.ContinuousImprovement.Biz.ChargeCode.Opportunities;
using Strata.ContinuousImprovement.Biz.Configuration;
using Strata.ContinuousImprovement.Biz.DbContexts;
using Strata.ContinuousImprovement.Biz.Dtos;
using Strata.ContinuousImprovement.Biz.Initiatives;
using Strata.ContinuousImprovement.Biz.OrgDefined;
using Strata.ContinuousImprovement.Biz.Shared;
using Strata.ContinuousImprovement.Biz.Test.Unit.Utilities;
using Strata.ContinuousImprovement.JazzEntityFrameworkStub;
using Strata.ContinuousImprovement.JazzEntityFrameworkStub.Generics;
using Strata.CoreLib.Claims;
using Strata.FeatureFlags.Client;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using NUnitSetup = NUnit.Framework.SetUpAttribute;

namespace Strata.ContinuousImprovement.Api.Test.Unit.Controllers
{
    [TestFixture, Category("Unit"), Category("Controller")]
    public class ChargeCodeOpportunitiesControllerTests
    {
        public JazzDbContext DbContext { get; set; }
        public ChargeCodeOpportunitiesController Controller { get; set; }
        public IEnumerable<Biz.Configuration.Configuration> Configurations { get; set; }
        public IClaimsPrincipalAccessor ClaimsPrincipalAccessor { get; set; }
        public IConfigurationService ConfigurationService { get; set; }
        public ICCOpportunityService OpportunityService;
        public ICCInitiativeService InitiativeService;
        public IOpportunityMetricCohortService OpportunityMetricCohortService;
        public IFeatureFlagServiceClient FeatureFlagServiceClient;
        public IAllOpportunityService AllOpportunityService;

        [OneTimeSetUp]
        public async Task ConfigurationsControllerTestSetup()
        {
            // Arrange
            var jeff = new JazzEntityFrameworkFactory();
            DbContext = await jeff.CreateDbContextAsync(nameof(ConfigurationsControllerTests), CancellationToken.None);
            Configurations = jeff.Configurations.ToList();
            var configuration = jeff.Configurations.First(c => c.ConfigurationGuid == JazzEntityFrameworkFactory.CurrentConfigurationGuid);
            var ccOpportunityDataModel = jeff.CCOpportunities[0].MapToDataModel(configuration);
            var workbook = new XLWorkbook();

            // Act
            ClaimsPrincipalAccessor = TestUtilities.GetClaimsPrincipalAccessor();
            FeatureFlagServiceClient = TestUtilities.GetFeatureFlagServiceClient("chargecodebeta", true);
            ConfigurationService = Mock.Of<IConfigurationService>();
            Mock.Get(ConfigurationService)
                .Setup(s => s.GetConfigurationsAsync(It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(Configurations.AsEnumerable()));
            Mock.Get(ConfigurationService)
                .Setup(s => s.GetConfigurationAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(configuration));
            AllOpportunityService = Mock.Of<IAllOpportunityService>();
            Mock.Get(AllOpportunityService)
                .Setup(s => s.NameIsValid(It.IsAny<Guid>(), It.IsAny<int>(), It.IsAny<string>(), It.IsAny<Guid?>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(true));
            OpportunityService = Mock.Of<ICCOpportunityService>();
            Mock.Get(OpportunityService)
                .Setup(s => s.UpdateAsync(It.IsAny<Guid>(), It.IsAny<CCOpportunityDataModel>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(Guid.NewGuid().ToString()));
            Mock.Get(OpportunityService)
                .Setup(s => s.ValidateChargeCodesAsync(It.IsAny<List<string>>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(true));
            Mock.Get(OpportunityService)
                .Setup(s => s.ValidateOpportunityLevelsAsync(It.IsAny<OpportunityLevel>(), It.IsAny<List<string>>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(true));
            Mock.Get(OpportunityService)
                .Setup(s => s.DeleteAsync<CCOpportunityDataModel>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(true));
            Mock.Get(OpportunityService)
                .Setup(s => s.GetById(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
                .Returns<Guid, CancellationToken>((oppGuid, token)
                    => oppGuid == ccOpportunityDataModel.OpportunityGuid
                        ? Task.FromResult(ccOpportunityDataModel)
                        : Task.FromResult((CCOpportunityDataModel)null));
            Mock.Get(OpportunityService)
                .Setup(s => s.ExportAsync(It.IsAny<Guid>(), It.IsAny<IEnumerable<string>>(), It.IsAny<string>(), It.IsAny<CancellationToken>()))
                .Returns<Guid, IEnumerable<string>, string, CancellationToken>((oppGuid, chargeCodes, userName, token)
                    => oppGuid == ccOpportunityDataModel.OpportunityGuid
                        ? Task.FromResult(((IXLWorkbook)workbook))
                        : Task.FromResult(((IXLWorkbook)null)));
            Mock.Get(OpportunityService)
                .Setup(s => s.UpdateGoalTotalUnitsOfServiceAsync(It.IsAny<Guid>(), It.IsAny<string>(), It.IsAny<double>(), It.IsAny<CancellationToken>()))
                .Returns<Guid, string, double, CancellationToken>((oppGuid, key, value, token)
                    => oppGuid == ccOpportunityDataModel.OpportunityGuid
                        ? Task.FromResult(true)
                        : Task.FromResult(false));
            Mock.Get(OpportunityService)
                .Setup(s => s.UpdateGoalCostPerUnitAsync(It.IsAny<Guid>(), It.IsAny<string>(), It.IsAny<double>(), It.IsAny<CancellationToken>()))
                .Returns<Guid, string, double, CancellationToken>((oppGuid, key, goalValue, token)
                    => oppGuid == ccOpportunityDataModel.OpportunityGuid
                        ? Task.FromResult(true)
                        : Task.FromResult(false));
            Mock.Get(OpportunityService)
                .Setup(s => s.GetInitiativeInfoAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(new InitiativeInfo()));
            Mock.Get(OpportunityService)
                .Setup(s => s.RefreshOpportunityTrackingData(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
                .Returns<Guid, Guid, CancellationToken>((dbGuid, oppGuid, token)
                    => dbGuid.ToString() == TestUtilities.DbGuid && oppGuid == ccOpportunityDataModel.OpportunityGuid
                        ? Task.FromResult("Good")
                        : Task.FromResult(""));
            InitiativeService = Mock.Of<ICCInitiativeService>();
            Mock.Get(InitiativeService)
                .Setup(s => s.UpdateSavings(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(true));
            OpportunityMetricCohortService = Mock.Of<IOpportunityMetricCohortService>();
        }

        [NUnitSetup]
        public void TestSetup()
        {
            // Arrange
            Controller = new ChargeCodeOpportunitiesController(ClaimsPrincipalAccessor, ConfigurationService, OpportunityService, InitiativeService, OpportunityMetricCohortService, FeatureFlagServiceClient, AllOpportunityService);
        }

        [Test()]
        public void ChargeCodeOpportunitiesControllerTest()
        {
            // Act
            var controller = new ChargeCodeOpportunitiesController(ClaimsPrincipalAccessor, ConfigurationService, OpportunityService, InitiativeService, OpportunityMetricCohortService, FeatureFlagServiceClient, AllOpportunityService);

            // Assert
            controller.Should().NotBeNull();
        }

        [Test()]
        public async Task UpdateOpportunityTest()
        {
            // Arrange
            var opp = await DbContext.ChargeCodeOpportunities.FirstOrDefaultAsync(CancellationToken.None);
            var opportunity = opp.MapToSaveModel();

            // Act
            var result = await Controller.UpdateOpportunity(opportunity.OpportunityGuid, opportunity, CancellationToken.None);

            // Assert
            var actual = result.Result;
            result.Result.Should().BeOfType<OkObjectResult>();
            var okResult = (OkObjectResult)result.Result;
            okResult.Value.Should().BeOfType<string>();
            var value = new Guid(okResult.Value as string);
            value.Should().NotBeEmpty();
        }

        [Test()]
        public async Task ValidateChargeCodesAsyncTest()
        {
            // Arrange
            var chargeCodes = new List<string>();

            // Act
            var result = await Controller.ValidateChargeCodesAsync(new ChargeCodeOpportunitiesController.ValidateChargeCodeDto() { ChargeCodes = chargeCodes }, CancellationToken.None);

            // Assert
            result.Result.Should().BeOfType<OkObjectResult>();
            var okResult = (OkObjectResult)result.Result;
            okResult.Value.Should().BeOfType<bool>();
            var value = (bool)okResult.Value;
            value.Should().BeTrue();
        }

        [Test()]
        public async Task GetCustomPickerChargeCodesAsyncTest()
        {
            // Arrange
            var chargeCodes = new List<string>();

            // Act
            var result = await Controller.GetChargeCodeMembers(chargeCodes, CancellationToken.None);

            // Assert
            result.Result.Should().BeOfType<OkObjectResult>();
            var okResult = (OkObjectResult)result.Result;
            okResult.Value.Should().BeOfType<ChargeCodePickerModel[]>();
            var value = (ChargeCodePickerModel[])okResult.Value;
            value.Should().NotBeNull();
        }

        [Test()]
        public async Task ValidateOpportunityLevelsAsyncTest()
        {
            // Arrange
            var info = new ChargeCodeOpportunitiesController.OpportunityLevelSelectionInfo
            {
                Configuration = Configurations.First().ConfigurationGuid,
                OpportunityLevel = OpportunityLevel.Entity,
                OpportunityLevels = new List<string>()
            };

            // Act
            var result = await Controller.ValidateOpportunityLevelsAsync(info, CancellationToken.None);

            // Assert
            result.Result.Should().BeOfType<OkObjectResult>();
            var okResult = (OkObjectResult)result.Result;
            okResult.Value.Should().BeOfType<bool>();
            var value = (bool)okResult.Value;
            value.Should().BeTrue();
        }

        [Test()]
        public async Task DeleteTest()
        {
            // Act
            var result = await Controller.Delete(Guid.NewGuid(), CancellationToken.None);

            // Assert
            result.Should().BeTrue();
        }

        [TestCase(true, TestName = "GetByIdTest - true")]
        [TestCase(false, TestName = "GetByIdTest - false")]
        public async Task GetByIdTest(bool withOpp)
        {
            // Arrange
            var opp = await DbContext.ChargeCodeOpportunities.FirstAsync(CancellationToken.None);

            // Act
            var result = await Controller.GetById(withOpp ? opp.OpportunityGuid : Guid.NewGuid(), CancellationToken.None);

            // Assert
            if (withOpp)
            {
                result.Result.Should().BeOfType<OkObjectResult>();
                var okResult = (OkObjectResult)result.Result;
                okResult.Value.Should().BeOfType<CCOpportunityDto>()
                    .And.NotBeOfType<CCOpportunityDataModel>();
            }
            else
            {
                result.Result.Should().BeOfType<NotFoundResult>();
            }
        }

        [TestCase(true, TestName = "GetEditModelTest - true")]
        [TestCase(false, TestName = "GetEditModelTest - false")]
        public async Task GetEditModelTest(bool withOpp)
        {
            // Arrange
            var opp = await DbContext.ChargeCodeOpportunities.FirstAsync(CancellationToken.None);

            // Act
            var result = await Controller.GetEditModel(withOpp ? opp.OpportunityGuid : Guid.NewGuid(), CancellationToken.None);

            // Assert
            if (withOpp)
            {
                result.Should().BeOfType<CCOpportunitySaveModel>();
            }
            else
            {
                result.Should().BeNull();
            }
        }

        [TestCase(true, TestName = "UpdateGoalTotalUnitsOfServiceTest - true")]
        [TestCase(false, TestName = "UpdateGoalTotalUnitsOfServiceTest - false")]
        public async Task UpdateGoalTotalUnitsOfServiceTest(bool withOpp)
        {
            // Arrange
            var opp = await DbContext.ChargeCodeOpportunities.FirstAsync(CancellationToken.None);

            // Act
            var result = await Controller.UpdateGoalTotalUnitsOfService(withOpp ? opp.OpportunityGuid : Guid.NewGuid(), new ChargeCodeOpportunitiesController.GoalSetDto(), CancellationToken.None);

            // Assert
            result.Should().Be(withOpp);
        }

        [TestCase(true, TestName = "UpdateGoalCostPerUnitTest - true")]
        [TestCase(false, TestName = "UpdateGoalCostPerUnitTest - false")]
        public async Task UpdateGoalCostPerUnitTest(bool withOpp)
        {
            // Arrange
            var opp = await DbContext.ChargeCodeOpportunities.FirstAsync(CancellationToken.None);

            // Act
            var result = await Controller.UpdateGoalCostPerUnit(withOpp ? opp.OpportunityGuid : Guid.NewGuid(), new ChargeCodeOpportunitiesController.GoalSetDto(), CancellationToken.None);

            // Assert
            result.Should().Be(withOpp);
        }

        [TestCase(true, TestName = "ExportTest - true")]
        [TestCase(false, TestName = "ExportTest - false")]
        public async Task ExportTest(bool withOpp)
        {
            // Arrange
            var opp = await DbContext.ChargeCodeOpportunities.FirstAsync(CancellationToken.None);
            var chargeCodeItems = new ChargeCodeOpportunitiesController.ChargeCodeItems
            {
                ChargeCodes = new List<string>()
            };

            // Act
            var result = await Controller.Export(withOpp ? opp.OpportunityGuid : Guid.NewGuid(), chargeCodeItems, CancellationToken.None);

            // Assert
            result.Should().BeOfType<ExcelContentResult>();
            var excelContentResult = (ExcelContentResult)result;
            if (withOpp)
            {
                excelContentResult.Workbook.Should().NotBeNull();
            }
            else
            {
                excelContentResult.Workbook.Should().BeNull();
            }
        }

        [Test()]
        public async Task OpportunityCreateEnabledTest()
        {
            // Act
            var result = await Controller.OpportunityCreateEnabled(CancellationToken.None);

            // Assert
            result.Should().BeTrue();
        }

        [Test()]
        public async Task GetInitiativeInfoTest()
        {
            // Act
            var result = await Controller.GetInitiativeInfo(Guid.NewGuid(), CancellationToken.None);

            // Assert
            result.Should().BeOfType<InitiativeInfo>()
                .And.NotBeNull();
        }

        [TestCase(true, TestName = "RefreshTest - true")]
        [TestCase(false, TestName = "RefreshTest - false")]
        public async Task RefreshTest(bool withOpp)
        {
            // Arrange
            var opp = await DbContext.ChargeCodeOpportunities.FirstAsync(CancellationToken.None);

            // Act
            var result = await Controller.Refresh(new ChargeCodeOpportunitiesController.RefreshData
            {
                DatabaseGuid = new Guid(TestUtilities.DbGuid),
                Guid = withOpp ? opp.OpportunityGuid : Guid.NewGuid()
            }, CancellationToken.None);

            // Assert
            result.Should().BeOfType<string>();
            if (withOpp)
            {
                result.Should().NotBeNullOrEmpty();
            }
            else
            {
                result.Should().BeNullOrEmpty();
            }
        }

    }
}