using FluentAssertions;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Moq;
using NUnit.Framework;
using Strata.ContinuousImprovement.Api.Controllers;
using Strata.ContinuousImprovement.Biz.Dtos;
using Strata.ContinuousImprovement.Biz.Exploration;
using Strata.ContinuousImprovement.Biz.Population;
using Strata.ContinuousImprovement.Biz.UserSetting;
using Strata.DecisionSupport.Models.Encounters;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace Strata.ContinuousImprovement.Api.Test.Unit.Controllers
{
    [TestFixture, Category("Unit"), Category("Controller")]
    public class ExplorationPopulationsControllerTests
    {
        public ExplorationPopulationsController Controller { get; set; }
        public IUserSettingService UserSettingService { get; set; }
        public IExplorationPopulationService PopulationService { get; set; }
        public IExplorationService ExplorationService { get; set; }

        [OneTimeSetUp]
        public async Task ExplorationPopulationsControllerTests_OneTimeSetUp()
        {
            UserSettingService = Mock.Of<IUserSettingService>();
            PopulationService = Mock.Of<IExplorationPopulationService>();
            ExplorationService = Mock.Of<IExplorationService>();
        }

        [SetUp]
        public void ExplorationPopulationsControllerTests_Setup()
        {
            Controller = new ExplorationPopulationsController(UserSettingService, PopulationService, ExplorationService, Mock.Of<ILogger<ExplorationPopulationsController>>());
        }

        [TestCaseSource(nameof(GetEncountersTestCases))]
        public async Task GetEncountersTest(ExplorationPopulationDto population, IEnumerable<EncounterPhysicianInfo> encounterPhysicians)
        {
            // Arrange
            long populationId = 0;
            Guid configurationGuid = new Guid();

            Mock.Get(PopulationService)
                    .Setup(s => s.GetPopulationDataAsync(It.IsAny<long>(), It.IsAny<CancellationToken>()))
                    .Returns<long, CancellationToken>((populationId, token) => Task.FromResult(population));
            Mock.Get(ExplorationService)
                    .Setup(s => s.GetEncountersAsync(It.IsAny<ExplorationDetailInfo>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
                    .Returns<ExplorationDetailInfo, Guid, CancellationToken>((exploration, configurationGuid, token) => Task.FromResult(encounterPhysicians));

            // Act
            var response = await Controller.GetEncounters(populationId, configurationGuid, CancellationToken.None);

            // Assert
            response.Should().NotBeNull();
            if (population == null || encounterPhysicians == null)
            {
                response.Result.Should().BeOfType<BadRequestResult>();
            }
            else
            {
                response.Result.Should().BeOfType<OkObjectResult>();
                var okResult = (OkObjectResult)response.Result;
                okResult.Value.Should().BeAssignableTo<IEnumerable<IJazzExplorationEncounterInfo>>();
                okResult.Value.Should().NotBeNull();
            }
        }

        public static IEnumerable<TestCaseData> GetEncountersTestCases()
        {
            var population = new ExplorationPopulationDto()
            {
                FiltersJSON = string.Empty
            };
            var encounterPhysicians = Enumerable.Empty<EncounterPhysicianInfo>();

            yield return new TestCaseData(population, encounterPhysicians)
                .SetName("Population and Encounters are not null");
            yield return new TestCaseData(population, null)
                .SetName("Encounters is null");
            yield return new TestCaseData(null, encounterPhysicians)
                .SetName("Population is null");
            yield return new TestCaseData(null, null)
                .SetName("Population and Encounters are null");
        }
    }
}