using DocumentFormat.OpenXml.Drawing.Diagrams;
using FluentAssertions;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Moq;
using NUnit.Framework;
using Strata.ApiLib.Standard.Models;
using Strata.ContinuousImprovement.Api.Controllers;
using Strata.ContinuousImprovement.Api.Test.Unit.Generics;
using Strata.ContinuousImprovement.Biz.DbContexts;
using Strata.ContinuousImprovement.Biz.Dtos;
using Strata.ContinuousImprovement.Biz.Encounter.Opportunities.Filters;
using Strata.ContinuousImprovement.Biz.Network;
using Strata.ContinuousImprovement.Biz.Pagination;
using Strata.ContinuousImprovement.Biz.Test.Unit.Utilities;
using Strata.ContinuousImprovement.JazzEntityFrameworkStub;
using Strata.CoreLib.Claims;
using System;
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 ClientNetworkOpportunitiesControllerTests
    {
        public CentralDbContext DbContext { get; set; }
        public ClientNetworkOpportunitiesController Controller { get; set; }
        public ClientNetworkOpportunitiesController EmptyDbController { get; set; }
        public ClientNetworkOpportunitiesController ControllerExceptions { get; set; }
        public IClaimsPrincipalAccessor ClaimsPrincipalAccessor { get; set; }
        public IClaimsPrincipalAccessor EnptyDbClaimsPrincipalAccessor { get; set; }
        public IClientNetworkOpportunityService ClientNetworkOpportunityService { get; set; }
        public IClientNetworkOpportunityService ClientNetworkOpportunityServiceException { get; set; }
        public ILogger<ClientNetworkOpportunitiesController> Logger { get; set; }

        [OneTimeSetUp]
        public async Task ClientNetworkOpportunitiesControllerTestsSetup()
        {
            // Arrange
            var jeff = new JazzEntityFrameworkFactory();
            DbContext = await jeff.CreateCentralDbContextAsync(nameof(ClientNetworkOpportunitiesControllerTests), CancellationToken.None);
            var expectedData = jeff.ClientNetworkOpportunities;
            var opportunity = expectedData[0];
            var expected = new PagedApiResponse<NetworkOpportunitySummary>
            {
                Data = expectedData.Select(d => new NetworkOpportunitySummary
                {
                    NetworkOpportunityId = d.NetworkOpportunityId,
                    Name = d.NetworkOpportunity.Name,
                    AnalyticsWorkbookId = d.AnalyticsWorkbookId,
                    CostDriver = d.NetworkOpportunity.CostDriver,
                    Description = d.NetworkOpportunity.Description,
                    IsPublished = d.IsPublished
                }),
                PagingInfo = new PagingInfo
                {
                    PageNumber = 1,
                    TotalNumberOfResults = expectedData.Count,
                    TotalPages = 1,
                    ResultsPerPage = expectedData.Count
                }
            };

            // Act
            ClaimsPrincipalAccessor = TestUtilities.GetClaimsPrincipalAccessor();
            EnptyDbClaimsPrincipalAccessor = TestUtilities.GetClaimsPrincipalAccessor(isEmptyDatabase: true);
            ClientNetworkOpportunityService = Mock.Of<IClientNetworkOpportunityService>();
            Mock.Get(ClientNetworkOpportunityService)
                .Setup(s => s.GetOpportunitiesAsync(It.IsAny<Guid>(), It.IsAny<PagingOptions>(), It.IsAny<NetworkOpportunityFilters>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(expected));
            Mock.Get(ClientNetworkOpportunityService)
                .Setup(s => s.GetByIdAsync(It.IsAny<Guid>(), It.IsAny<int>(), It.IsAny<CancellationToken>()))
                .Returns<Guid, int, CancellationToken>((dbGuid, networkOpportunityId, token) =>
                    networkOpportunityId == opportunity.NetworkOpportunityId
                        ? Task.FromResult(opportunity)
                        : Task.FromResult((ClientNetworkOpportunity)null));
            Mock.Get(ClientNetworkOpportunityService)
                .Setup(s => s.ConfigureAsync(It.IsAny<Guid>(), It.IsAny<int>(), It.IsAny<ClientNetworkOpportunity>(), It.IsAny<NetworkOpportunitySaveModel>(), It.IsAny<CancellationToken>()));
            ClientNetworkOpportunityServiceException = Mock.Of<IClientNetworkOpportunityService>();
            Mock.Get(ClientNetworkOpportunityServiceException)
                .Setup(s => s.GetByIdAsync(It.IsAny<Guid>(), It.IsAny<int>(), It.IsAny<CancellationToken>()))
                .Throws(new CreateWorkbookFromTemplateException());
            Logger = Mock.Of<ILogger<ClientNetworkOpportunitiesController>>();
        }

        [NUnitSetup]
        public void TestSetup()
        {
            Controller = new ClientNetworkOpportunitiesController(ClaimsPrincipalAccessor, ClientNetworkOpportunityService, Logger);
            EmptyDbController = new ClientNetworkOpportunitiesController(EnptyDbClaimsPrincipalAccessor, ClientNetworkOpportunityService, Logger);
            ControllerExceptions = new ClientNetworkOpportunitiesController(ClaimsPrincipalAccessor, ClientNetworkOpportunityServiceException, Logger);
        }

        [Test()]
        public async Task ClientNetworkOpportunitiesControllerTest()
        {
            // Assert
            Controller.Should().NotBeNull();
        }

        [Test()]
        public async Task GetOpportunitiesTest()
        {
            // Arrange
            var loadOptions = new NetworkOpportunityLoadOptions
            {
                Filters = new NetworkOpportunityFilters
                {

                },
                PagingOptions = new Biz.Pagination.PagingOptions
                {
                    First = 0,
                    Rows = 24
                }
            };

            // Act
            var result = await Controller.GetOpportunities(loadOptions, CancellationToken.None);

            result.Should().NotBeNull();
            result.Value.Should().NotBeNull()
                .And.BeOfType<PagedApiResponse<NetworkOpportunitySummary>>();
        }

        [TestCase(true, TestName = "GetByIdTest w/ Exception")]
        [TestCase(false, TestName = "GetByIdTest w/o Exception")]
        public async Task GetByIdTest(bool withException)
        {
            // Arrange
            var opportunity = DbContext.NetworkOpportunities.FirstOrDefault();
            var clientNetworkOpportunity = DbContext.ClientNetworkOpportunities.FirstOrDefault(cno => cno.NetworkOpportunityId == opportunity.NetworkOpportunityId);
            var dto = clientNetworkOpportunity.MapToDto();
            ActionResult<ClientNetworkOpportunityDto> result;

            // Act
            if (withException)
            {
                result = await ControllerExceptions.GetById(opportunity.NetworkOpportunityId, CancellationToken.None);

            }
            else
            {
                result = await Controller.GetById(opportunity.NetworkOpportunityId, CancellationToken.None);
            }

            // Assert
            if (withException)
            {
                result.Value.Should().BeNull();
                result.Result.Should().BeOfType<ObjectResult>();
                var objectResult = (ObjectResult)result.Result;
                objectResult.StatusCode.Should().Be(500);
            }
            else
            {
                result.Value.Should().NotBeNull()
                    .And.BeOfType<ClientNetworkOpportunityDto>()
                    .And.BeEquivalentTo(dto);
            }
        }

        [TestCase(true, TestName = "SaveTest w/ Exception")]
        [TestCase(false, TestName = "SaveTest w/o Exception")]
        public async Task SaveTest(bool withException)
        {
            // Arrange
            var opportunity = DbContext.NetworkOpportunities.FirstOrDefault();
            var clientNetworkOpportunity = DbContext.ClientNetworkOpportunities.FirstOrDefault(cno => cno.NetworkOpportunityId == opportunity.NetworkOpportunityId);
            var dto = clientNetworkOpportunity.MapToDto();

            // Act
            IActionResult result;
            if (withException)
            {
                result = await ControllerExceptions.Save(-1, dto, CancellationToken.None);
            }
            else
            {
                result = await Controller.Save(opportunity.NetworkOpportunityId, dto, CancellationToken.None);
            }

            // Assert
            if (withException)
            {
                result.Should().NotBeNull()
                    .And.BeOfType<BadRequestResult>();
            }
            else
            {
                result.Should().NotBeNull()
                    .And.BeOfType<NoContentResult>();
            }
        }

        [Test()]
        public async Task DeleteTest()
        {
            // Arrange
            var opportunity = DbContext.NetworkOpportunities.FirstOrDefault();

            // Act
            IActionResult result;
            result = await Controller.Delete(opportunity.NetworkOpportunityId, CancellationToken.None);

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

        [TestCase(true, true, TestName = "PublishTest w/ Exception on EmptyDb")]
        [TestCase(false, true, TestName = "PublishTest w/o Exception on EmptyDb")]
        [TestCase(true, false, TestName = "PublishTest w/ Exception")]
        [TestCase(false, false, TestName = "PublishTest w/o Exception")]
        public async Task PublishTest(bool withException, bool withEmptyDb)
        {
            // Arrange
            var opportunity = DbContext.NetworkOpportunities.FirstOrDefault();
            var clientNetworkOpportunity = DbContext.ClientNetworkOpportunities.FirstOrDefault(cno => cno.NetworkOpportunityId == opportunity.NetworkOpportunityId);
            var dto = clientNetworkOpportunity.MapToDto();
            ActionResult<bool> result;

            // Act
            if (withEmptyDb)
            {
                if (withException)
                {
                    result = await EmptyDbController.Publish(-1, true, CancellationToken.None);

                }
                else
                {
                    result = await EmptyDbController.Publish(opportunity.NetworkOpportunityId, true, CancellationToken.None);
                }
            }
            else
            {
                if (withException)
                {
                    result = await Controller.Publish(-1, true, CancellationToken.None);

                }
                else
                {
                    result = await Controller.Publish(opportunity.NetworkOpportunityId, true, CancellationToken.None);
                }
            }

            // Assert
            if (withEmptyDb)
            {
                if (withException)
                {
                    result.Should().NotBeNull();
                    result.Should().BeOfType<ActionResult<bool>>();
                    result.Result.Should().BeOfType<BadRequestResult>();
                    result.Value.Should().BeFalse();
                }
                else
                {
                    result.Should().NotBeNull();
                    result.Should().BeOfType<ActionResult<bool>>();
                    result.Result.Should().BeOfType<BadRequestResult>();
                }
            }
            else
            {
                if (withException)
                {
                    result.Should().NotBeNull();
                    result.Should().BeOfType<ActionResult<bool>>();
                    result.Result.Should().BeOfType<BadRequestResult>();
                    result.Value.Should().BeFalse();
                }
                else
                {
                    result.Should().NotBeNull();
                    result.Should().BeOfType<ActionResult<bool>>();
                    result.Result.Should().BeOfType<OkObjectResult>();
                }
            }

        }

        [Test()]
        public async Task UpdateInitiativeStatusTest()
        {
            // Arrange
            var opportunity = DbContext.NetworkOpportunities.FirstOrDefault();
            var clientNetworkOpportunity = DbContext.ClientNetworkOpportunities.FirstOrDefault(cno => cno.NetworkOpportunityId == opportunity.NetworkOpportunityId);
            var dto = clientNetworkOpportunity.MapToDto();

            // Act
            var result = await Controller.UpdateInitiativeStatus(opportunity.NetworkOpportunityId, Biz.Shared.InitiativeStatuses.Completed, CancellationToken.None);

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

        [TestCase(true, true, TestName = "RevertWorkbookToTemplateTest w/ Exception on EmptyDb")]
        [TestCase(false, true, TestName = "RevertWorkbookToTemplateTest w/o Exception on EmptyDb")]
        [TestCase(true, false, TestName = "RevertWorkbookToTemplateTest w/ Exception")]
        [TestCase(false, false, TestName = "RevertWorkbookToTemplateTest w/o Exception")]
        public async Task RevertWorkbookToTemplateTest(bool withException, bool withEmptyDb)
        {
            // Arrange
            var opportunity = DbContext.NetworkOpportunities.FirstOrDefault();
            var clientNetworkOpportunity = DbContext.ClientNetworkOpportunities.FirstOrDefault(cno => cno.NetworkOpportunityId == opportunity.NetworkOpportunityId);
            var dto = clientNetworkOpportunity.MapToDto();
            ActionResult<bool> result;

            // Act
            if (withEmptyDb)
            {
                if (withException)
                {
                    result = await EmptyDbController.RevertWorkbookToTemplate(-1, CancellationToken.None);

                }
                else
                {
                    result = await EmptyDbController.RevertWorkbookToTemplate(opportunity.NetworkOpportunityId, CancellationToken.None);
                }
            }
            else
            {
                if (withException)
                {
                    result = await Controller.RevertWorkbookToTemplate(-1, CancellationToken.None);

                }
                else
                {
                    result = await Controller.RevertWorkbookToTemplate(opportunity.NetworkOpportunityId, CancellationToken.None);
                }
            }

            // Assert
            if (withEmptyDb)
            {
                if (withException)
                {
                    result.Should().NotBeNull();
                    result.Should().BeOfType<ActionResult<bool>>();
                    result.Result.Should().BeOfType<BadRequestResult>();
                    result.Value.Should().BeFalse();
                }
                else
                {
                    result.Should().NotBeNull();
                    result.Should().BeOfType<ActionResult<bool>>();
                    result.Result.Should().BeOfType<BadRequestResult>();
                }
            }
            else
            {
                if (withException)
                {
                    result.Should().NotBeNull();
                    result.Should().BeOfType<ActionResult<bool>>();
                    result.Result.Should().BeOfType<BadRequestResult>();
                    result.Value.Should().BeFalse();
                }
                else
                {
                    result.Should().NotBeNull();
                    result.Should().BeOfType<ActionResult<bool>>();
                    result.Result.Should().BeOfType<OkObjectResult>();
                }
            }
        }
    }
}