using FluentAssertions;
using NUnit.Framework;
using Strata.ContinuousImprovement.Biz.Dtos;
using Strata.ContinuousImprovement.Biz.Encounter.Opportunities;
using Strata.ContinuousImprovement.Biz.Mappers;
using Strata.ContinuousImprovement.Biz.Shared;
using System;
using System.Collections.Generic;
using System.Linq;

namespace Strata.ContinuousImprovement.Biz.Test.Unit.Encounter
{
    [TestFixture, Category("Unit")]
    public class EncounterOpportunityMetricTest
    {
        private ENOpportunityDto opportunity;
        private ENOpportunityDataModelWithFilters model;

        [SetUp]
        public void TestSetup()
        {
            opportunity = new ENOpportunityDto
            {
                ConfigurationGuid = Guid.NewGuid(),
                Name = "Test Encounter Opportunity",
                EncounterGroup = 0,
                OpportunityLevel = 1,
                EncounterGroups = new List<string>
                {
                    "CaseType|CaseType|1"
                },
                OpportunityLevels = new List<string>()
                {
                    "ENT|ENT|1"
                },
                IsBaseline = true
            };
            model = opportunity.MapToDataModel(null);
            model.OpportunityGuid = Guid.NewGuid();
            model.AuthorGuid = Guid.NewGuid();
            model.AuthorName = "Someones Name";
            model.DateCreated = DateTime.Today;
        }

        [Test]
        public void TestENOpportunityDataModel()
        {
            var data = opportunity.MapToDataModel(null);
            data.ConfigurationGuid.Should().NotBe(Guid.Empty)
                .And.Be(opportunity.ConfigurationGuid);
            data.EncounterGroup.Should().Be(opportunity.EncounterGroup);
            data.OpportunityLevel.Should().Be(Enum.GetName(typeof(OpportunityLevel), opportunity.OpportunityLevel));
            data.EncounterOpportunityLevel.Should().Be((OpportunityLevel)opportunity.OpportunityLevel);
            data.CaseTypes.Should().NotBeEmpty()
                .And.Contain(ct => opportunity.EncounterGroups.Select(x => x).Contains(ct.Id));
            data.IsSeasonal.Should().Be(opportunity.IsSeasonal);
            data.IsBaseline.Should().Be(opportunity.IsBaseline);
        }

        [Test]
        public void TestEncounterOpportunityMetric()
        {
            var metric = model.MapFromDataModel();
            metric.OpportunityGuid.Should().Be(model.OpportunityGuid);
            metric.ConfigurationGuid.Should().Be(model.ConfigurationGuid);
            metric.AuthorName.Should().Be(model.AuthorName);
            metric.AuthorGuid.Should().Be(model.AuthorGuid);
            metric.Name.Should().Be(model.Name);
            metric.EncounterOpportunityLevel.Should().Be(model.EncounterOpportunityLevel);
            metric.EncounterGroup.Should().Be(model.EncounterGroup);
            metric.CaseTypes.Should().NotBeEmpty()
                .And.Contain(ct => opportunity.EncounterGroups.Select(x => x).Contains(ct.Id));
            var filter = opportunity.EncounterGroups.First().MapToFilterHelper();
            metric.CaseTypes.First().GetHashCode().Equals(filter.GetHashCode());
            metric.PatientPopulations.Should().BeEmpty();
            metric.Entities.Should().NotBeEmpty()
                .And.Contain(ct => opportunity.OpportunityLevels.Select(x => x).Contains(ct.Id));
            metric.ServiceLines.Should().BeEmpty();
            metric.Specialties.Should().BeEmpty();
            metric.Providers.Should().BeEmpty();
            metric.IsBaseline.Should().Be(opportunity.IsBaseline);
            metric.ConfigurationGuid.Should().NotBe(Guid.Empty);
            metric.IsSeasonal.Should().Be(opportunity.IsSeasonal);
            metric.IsBaseline.Should().Be(opportunity.IsBaseline);
        }

        [TestCaseSource(nameof(GetEncounterOpportunityMetricTests))]
        public void TestEncounterOpportunityMetric(ENOpportunityDto enOpportunity)
        {
            var dataModel = opportunity.MapToDataModel(null);
            var metric = dataModel.MapFromDataModel();
            metric.OpportunityGuid.Should().Be(dataModel.OpportunityGuid);
            metric.ConfigurationGuid.Should().Be(dataModel.ConfigurationGuid);
            metric.AuthorName.Should().Be(dataModel.AuthorName);
            metric.AuthorGuid.Should().Be(dataModel.AuthorGuid);
            metric.Name.Should().Be(dataModel.Name);
            metric.EncounterOpportunityLevel.Should().Be(dataModel.EncounterOpportunityLevel);
            metric.EncounterGroup.Should().Be(dataModel.EncounterGroup);
            switch ((EncounterGroup)metric.EncounterGroup)
            {
                case EncounterGroup.CaseType:
                    metric.CaseTypes.Should().NotBeEmpty()
                        .And.Contain(ct => opportunity.EncounterGroups.Select(x => x).Contains(ct.Id));
                    var filter = opportunity.EncounterGroups.First().MapToFilterHelper();
                    metric.CaseTypes.First().GetHashCode().Equals(filter.GetHashCode());
                    break;
                case EncounterGroup.PatientPopulation:
                    metric.PatientPopulations.Should().NotBeEmpty()
                        .And.Contain(ct => opportunity.EncounterGroups.Select(x => x).Contains(ct.Id));
                    var filter1 = opportunity.EncounterGroups.First().MapToFilterHelper();
                    metric.PatientPopulations.First().GetHashCode().Equals(filter1.GetHashCode());
                    break;
            }
            metric.PatientPopulations.Should().BeEmpty();
            switch (metric.EncounterOpportunityLevel)
            {
                case OpportunityLevel.Organization:
                    metric.Entities.Should().BeEmpty();
                    metric.ServiceLines.Should().BeEmpty();
                    metric.Specialties.Should().BeEmpty();
                    metric.Providers.Should().BeEmpty();
                    break;
                case OpportunityLevel.Entity:
                    metric.Entities.Should().NotBeEmpty()
                        .And.Contain(ct => opportunity.OpportunityLevels.Select(x => x).Contains(ct.Id));
                    metric.ServiceLines.Should().BeEmpty();
                    metric.Specialties.Should().BeEmpty();
                    metric.Providers.Should().BeEmpty();
                    break;
                case OpportunityLevel.ServiceLine:
                    metric.ServiceLines.Should().NotBeEmpty()
                        .And.Contain(ct => opportunity.OpportunityLevels.Select(x => x).Contains(ct.Id));
                    metric.Entities.Should().BeEmpty();
                    metric.Specialties.Should().BeEmpty();
                    metric.Providers.Should().BeEmpty();
                    break;
                case OpportunityLevel.Specialty:
                    metric.Specialties.Should().NotBeEmpty()
                        .And.Contain(ct => opportunity.OpportunityLevels.Select(x => x).Contains(ct.Id));
                    metric.Entities.Should().BeEmpty();
                    metric.ServiceLines.Should().BeEmpty();
                    metric.Providers.Should().BeEmpty();
                    break;
                case OpportunityLevel.Provider:
                    metric.Providers.Should().NotBeEmpty()
                        .And.Contain(ct => opportunity.OpportunityLevels.Select(x => x).Contains(ct.Id));
                    metric.Entities.Should().BeEmpty();
                    metric.ServiceLines.Should().BeEmpty();
                    metric.Specialties.Should().BeEmpty();
                    break;
            }
            metric.IsBaseline.Should().Be(opportunity.IsBaseline);
            metric.ConfigurationGuid.Should().NotBe(Guid.Empty);
            metric.IsSeasonal.Should().Be(opportunity.IsSeasonal);
            metric.IsBaseline.Should().Be(opportunity.IsBaseline);
        }
        public static IEnumerable<TestCaseData> GetEncounterOpportunityMetricTests()
        {
            foreach (EncounterGroup encounterGroup in Enum.GetValues(typeof(EncounterGroup)))
            {
                if (encounterGroup == EncounterGroup.Both) continue;
                foreach (OpportunityLevel oppLevel in Enum.GetValues(typeof(OpportunityLevel)))
                {
                    yield return new TestCaseData(new ENOpportunityDto
                    {
                        ConfigurationGuid = Guid.NewGuid(),
                        Name = "Test Encounter Opportunity",
                        EncounterGroup = (int)encounterGroup,
                        OpportunityLevel = (int)oppLevel,
                        EncounterGroups = new List<string>
                        {
                            "CaseType|CaseType|1"
                        },
                        OpportunityLevels = new List<string>()
                        {
                            "ENT|ENT|1"
                        },
                        IsBaseline = true
                    }).SetName($"TestEncounterOpportunityMetric {encounterGroup} {oppLevel}");
                }
            }
        }
    }

}