using Moq;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using LCU.API.Internal.MemberPreferencesApi.Services;
using LCU.Library.Internal.MemberPreferencesApiModels.Entities;
using LCU.Library.Internal.MemberPreferencesApiModels.Enums;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Agreements;
using LCU.API.Internal.MemberPreferencesApiLib.Repositories;
using LCU.API.Internal.MemberPreferencesApi.Services.XdiServices;
using LCU.API.Internal.MemberPreferencesApi.MicroApiServices;

namespace LCU.API.Internal.MemberPreferencesApi.UnitTests.Services
{
    public class UnifiedOptInServiceTest
    {
        private OptinService _service;
        private Mock<IUnifiedOptInRepository> _mockRepository;
        private Mock<IXdiBatchService> _mockXdiBatchItemService;
        private Mock<ICoreApiWrapperService> _mockCoreApiWrapperService;
        private Mock<IMemberPreferenceService> _mockMemberPreferenceService;

        [SetUp]
        public void Setup()
        {
            _mockRepository = new Mock<IUnifiedOptInRepository>();
            _mockXdiBatchItemService = new Mock<IXdiBatchService>();
            _mockCoreApiWrapperService = new Mock<ICoreApiWrapperService>();
            _mockMemberPreferenceService = new Mock<IMemberPreferenceService>();
            _service = new OptinService(_mockRepository.Object, _mockXdiBatchItemService.Object, _mockMemberPreferenceService.Object, _mockCoreApiWrapperService.Object);
        }

        [Test]
        public async Task Get_OptIn_OK()
        {
            var testSettings1 = new MemberOptInSettings
            {
                UserId = "1",
                UniversalOptIn = "Email"
            };

            _mockRepository.Setup(x => x.GetMemberOptInSettings("1")).ReturnsAsync(testSettings1).Verifiable();
            // act
            var result = await _service.GetMemberOptInSettings("1");
            Assert.NotNull(result);
            Assert.AreEqual("1", result.UserId);
            Assert.AreEqual("Email", result.UniversalOptIn);
            _mockRepository.Verify();
        }

        [Test]
        public async Task GetMemberOptInAgreementInformation_OptIn_OK()
        {

            var agreements = new List<Agreement>
            {
                new Agreement
                {
                    UserId = "1"
                },
                new Agreement
                {
                    UserId = "2"
                }
            };

            var testSetting = new MemberOptInSettings
            {
                UserId = "1",
                UniversalOptIn = "Email"
            };

            _mockCoreApiWrapperService.Setup(x => x.GetAgreementsByAccountId(123)).ReturnsAsync(agreements).Verifiable();
            _mockRepository.Setup(x => x.GetMemberOptInSettings("1")).ReturnsAsync(testSetting).Verifiable();
            _mockRepository.Setup(x => x.GetMemberOptInSettings("2")).ReturnsAsync(testSetting).Verifiable();

            // act
            var result = await _service.GetMemberOptInAgreementInformationByAccountId(123);
            Assert.NotNull(result);
            Assert.IsNotEmpty(result);
            _mockCoreApiWrapperService.Verify();
            _mockRepository.Verify();
        }

        [TestCase(true)]
        [TestCase(false)]
        public async Task TransformMemberOptInSettingsForClient_OK(bool hasPending)
        {
            var testSettings1 = new MemberOptInSettings
            {
                Id = 10,
                UserId = "100",
                EStatements = DeliveryPreference.Microfiche,
                ENotifications = DeliveryPreference.Paper,
                UniversalOptIn = DeliveryPreference.Electronic,
                LegalVersion = "2021/01/01",
                LegalDate = DateTime.Parse("2021/01/01"),
                UnifiedOptInEmail = "unified@test.com",
                EStatementsEmail = "estatements@test.com",
                ENotificationsEmail = "enotifications@test.com",
                Created = DateTime.Parse("2021/01/01"),
                CreatedBy = "TestUser",
                CreatedByType = UserType.Associate,
                LastUpdated = DateTime.Parse("2021/02/01"),
                LastUpdatedBy = "TestMember",
                LastUpdatedByType = UserType.Member,
            };

            _mockXdiBatchItemService.Setup(x => x.DoesMemberHavePendingXdiChange(It.IsAny<string>()))
                .ReturnsAsync(hasPending);
            // act
            var transformation = await _service.TransformMemberOptInSettingsForClient(testSettings1);
            Assert.NotNull(transformation);
            var result = transformation.MemberOptinSettings;
            Assert.AreEqual(10, result.Id);
            Assert.AreEqual("100", result.UserId);
            Assert.AreEqual(DeliveryPreference.Microfiche, result.EStatements);
            Assert.AreEqual(DeliveryPreference.Paper, result.ENotifications);
            Assert.AreEqual(DeliveryPreference.Electronic, result.UniversalOptIn);
            Assert.AreEqual("2021/01/01", result.LegalVersion);
            Assert.AreEqual(DateTime.Parse("2021/01/01"), result.LegalDate);
            Assert.AreEqual("unified@test.com", result.UnifiedOptInEmail);
            Assert.AreEqual("estatements@test.com", result.EStatementsEmail);
            Assert.AreEqual("enotifications@test.com", result.ENotificationsEmail);
            Assert.AreEqual(DateTime.Parse("2021/01/01"), result.Created);
            Assert.AreEqual("TestUser", result.CreatedBy);
            Assert.AreEqual(UserType.Associate, result.CreatedByType);
            Assert.AreEqual(DateTime.Parse("2021/02/01"), result.LastUpdated);
            Assert.AreEqual("TestMember", result.LastUpdatedBy);
            Assert.AreEqual(UserType.Member, result.LastUpdatedByType);
            Assert.AreEqual(hasPending, transformation.HasPendingUpdates);
        }

        [Test]
        public async Task TransformMemberOptInSettingsForClient_List_OK()
        {
            var testSettings1 = new List<MemberOptInSettings>
            {
                new MemberOptInSettings
                {
                    UserId = "9",
                    UniversalOptIn = "Email"
                },
                new MemberOptInSettings
                {
                    UserId = "10",
                    UniversalOptIn = "Paper"
                },
            };
            _mockXdiBatchItemService.Setup(x => x.DoesMemberHavePendingXdiChange("9"))
                .ReturnsAsync(true).Verifiable();
            _mockXdiBatchItemService.Setup(x => x.DoesMemberHavePendingXdiChange("10"))
                .ReturnsAsync(false).Verifiable();
            // act
            var result = await _service.TransformMemberOptInSettingsForClient(testSettings1);
            _mockXdiBatchItemService.Verify();
            Assert.NotNull(result);
            Assert.IsNotEmpty(result);
            Assert.AreEqual(result.Count, 2);
            Assert.True(result.ToList().Exists(x => x.HasPendingUpdates));
            Assert.True(result.ToList().Exists(x => !x.HasPendingUpdates));
        }
    }
}