using Microsoft.Extensions.Logging;
using Moq;
using NUnit.Framework;
using Strata.ContinuousImprovement.Biz.PeerGroups;
using Strata.ContinuousImprovement.Biz.PeerGroups.Enums;
using Strata.ContinuousImprovement.Biz.Test.Unit.Utilities;
using Strata.ContinuousImprovement.JazzEntityFrameworkStub;
using Strata.StrataSphereCompare.Client.Models.Enums;
using Superpower.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using VerifyNUnit;
using VerifyTests;

namespace Strata.ContinuousImprovement.Biz.Test.Unit.PeerGroup
{
    public class PeerGroupServiceTest
    {
        private readonly string _duplicateName = "Test Name";
        private readonly int _existingGroupId = 1;
        private ILogger<PeerGroupService> _logger { get; set; }
        private VerifySettings _verifySettings { get; set; }

        [SetUp]
        public void TestSetUp()
        {
            _verifySettings = TestExtensions.TestSettings();
            _logger = Mock.Of<ILogger<PeerGroupService>>();
        }

        [Test]
        public async Task TestValidDropdownItems()
        {
            // arrange
            var framework = new JazzEntityFrameworkFactory();
            await framework.CreateDbContextAsync(CancellationToken.None);
            var peerGroupService = new PeerGroupService(framework, _logger);

            // act
            var dropdownItems = peerGroupService.GetDropdownItems();

            // assert
            await Verifier.Verify(dropdownItems, _verifySettings)
                .UseFileName(TestContext.CurrentContext.TestName());
        }

        [Test]
        public async Task TestTooLongNameThrowsAnError()
        {
            // arrange
            var framework = new JazzEntityFrameworkFactory();
            await framework.CreateDbContextAsync(CancellationToken.None);
            var peerGroupService = new PeerGroupService(framework, _logger);

            // act
            var exception = Assert.ThrowsAsync<Exception>(() => peerGroupService.CreateAsync(new PeerGroupDto() { Name = new string('a', 101) }, default));

            // assert
            Assert.That(exception, Is.Not.Null);
            Assert.That("Rollup column exceeds maximum number of characters", Is.EqualTo(exception.Message));
        }

        [Test]
        public async Task TestDuplicateNameThrowsAnError()
        {
            // arrange
            var framework = new JazzEntityFrameworkFactory();
            await framework.CreateDbContextAsync(CancellationToken.None);
            var peerGroupService = new PeerGroupService(framework, _logger);

            // act
            var exception = Assert.ThrowsAsync<Exception>(() => peerGroupService.CreateAsync(new PeerGroupDto() { Name = _duplicateName }, default));

            // assert
            Assert.That(exception, Is.Not.Null);
            Assert.That("Rollup column name already exists.", Is.EqualTo(exception.Message));
        }

        [Test]
        public async Task TestGetGroupByIdReturnsCorrectGroup()
        {
            // arrange
            var framework = new JazzEntityFrameworkFactory();
            await framework.CreateDbContextAsync(CancellationToken.None);
            var peerGroupService = new PeerGroupService(framework, _logger);

            // act
            var group = await peerGroupService.GetByIdAsync(_existingGroupId, default);

            // assert
            Assert.That(group, Is.Not.Null);
            Assert.That(_duplicateName, Is.EqualTo(group.Name));
        }

        [Test]
        public async Task TestCreateSavesAnItem()
        {
            // arrange
            var framework = new JazzEntityFrameworkFactory();
            await framework.CreateDbContextAsync(CancellationToken.None);
            var peerGroupService = new PeerGroupService(framework, _logger);
            var dto = new PeerGroupDto()
            {
                Name = "New Item",
                AmcTypes = new List<byte>() { (byte)IsAmc.NonAcademicMedicalCenters, (byte)IsAmc.AcademicMedicalCenters },
                EntityTypes = new List<byte>() { (byte)HospitalType.ShortTermAcuteCareHospital, (byte)HospitalType.CancerCenter },
                CensusRegions = new List<byte>() { (byte)CensusRegion.Midwest, (byte)CensusRegion.Northeast },
                OperatingExpenses = new List<byte>() { (byte)OperatingExpense._250MTo500M, (byte)OperatingExpense._100MTo250M },
                BedSize = new List<byte>() { (byte)BedSize._0_250, (byte)BedSize._251_500 },
                UrbanRural = new List<byte>() { (byte)UrbanRural.Urban, (byte)UrbanRural.Rural }
            };

            // act
            var result = await peerGroupService.CreateAsync(dto, default);

            // assert
            Assert.That(result, Is.EqualTo(true));
            var itemsFromDB = await peerGroupService.GetAllAsync(default);
            var savedItem = itemsFromDB.FirstOrDefault(i => i.Name == dto.Name);
            AssertPeerGroups(dto, savedItem);
        }

        [Test]
        public async Task TestUpdateRewritesMappings()
        {
            // arrange
            var framework = new JazzEntityFrameworkFactory();
            await framework.CreateDbContextAsync(CancellationToken.None);
            var peerGroupService = new PeerGroupService(framework, _logger);
            var dto = new PeerGroupDto()
            {
                PeerGroupId = 1,
                Name = "Changed Item",
                AmcTypes = new List<byte>() { (byte)IsAmc.AcademicMedicalCenters },
                EntityTypes = new List<byte>() { (byte)HospitalType.CancerCenter, (byte)HospitalType.RehabLTACOther },
                CensusRegions = new List<byte>() { (byte)CensusRegion.West, (byte)CensusRegion.Midwest },
                OperatingExpenses = new List<byte>() { (byte)OperatingExpense.GreaterThan1B, (byte)OperatingExpense._100MTo250M },
                BedSize = new List<byte>() { (byte)BedSize._251_500, (byte)BedSize._501_750 },
                UrbanRural = new List<byte>() { (byte)UrbanRural.Rural }
            };

            // act
            var result = await peerGroupService.UpdateAsync(dto.PeerGroupId, dto, default);

            // assert
            Assert.That(result, Is.EqualTo(true));
            var itemsFromDB = await peerGroupService.GetAllAsync(default);
            var savedItem = itemsFromDB.FirstOrDefault(i => i.Name == dto.Name);
            AssertPeerGroups(dto, savedItem);
        }

        [Test]
        public async Task TestDeleteWorksCorrectly()
        {
            // arrange
            var framework = new JazzEntityFrameworkFactory();
            await framework.CreateDbContextAsync(CancellationToken.None);
            var peerGroupService = new PeerGroupService(framework, _logger);
            // act
            await peerGroupService.DeleteAsync(_existingGroupId, default);

            // assert
            var itemsFromDB = await peerGroupService.GetAllAsync(default);
            var savedItem = itemsFromDB.FirstOrDefault(i => i.Name == _duplicateName || i.PeerGroupId == _existingGroupId);
            Assert.That(savedItem, Is.Null);
        }

        private void AssertPeerGroups(PeerGroupDto expected, PeerGroupDto actual)
        {
            Assert.That(actual, Is.Not.Null);
            Assert.That(actual.AmcTypes, Is.EqualTo(expected.AmcTypes));
            Assert.That(actual.EntityTypes, Is.EqualTo(expected.EntityTypes));
            Assert.That(actual.CensusRegions, Is.EqualTo(expected.CensusRegions));
            Assert.That(actual.OperatingExpenses, Is.EqualTo(expected.OperatingExpenses));
            Assert.That(actual.BedSize, Is.EqualTo(expected.BedSize));
            Assert.That(actual.UrbanRural, Is.EqualTo(expected.UrbanRural));
        }
    }
}