using LCU.API.Internal.MemberPreferencesApi.MicroApiServices;
using LCU.API.Internal.MemberPreferencesApi.Models;
using LCU.API.Internal.MemberPreferencesApi.Models.Requests;
using LCU.API.Internal.MemberPreferencesApi.Services.XdiServices;
using LCU.API.Internal.MemberPreferencesApiLib.Repositories;
using LCU.Library.Internal.ApiResponse.Models;
using LCU.Library.Internal.FileOperationsModels.Models;
using LCU.Library.Internal.MemberPreferencesApiModels.Entities;
using LCU.Library.Internal.MemberPreferencesApiModels.Enums;
using Moq;
using Newtonsoft.Json;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace LCU.API.Internal.MemberPreferencesApi.UnitTests.Services
{
    public class XdiBatchItemServiceTest
    {
        private IXdiBatchService _xdiBatchItemService;
        private Mock<IXdiBatchItemsRepository> _mockBatchItemsRepository;
        private Mock<IUnitOfWork> _mockUnitOfWork;
        private Mock<IUnifiedOptInRepository> _mockUnifiedOptinRepository;
        private Mock<IMemberPreferenceRepository> _mockMemberPreferenceRepository;
        private Mock<IFileOperationsApiService> _mockFileOperationsApiService;

        [SetUp]
        public void Setup()
        {
            _mockBatchItemsRepository = new Mock<IXdiBatchItemsRepository>();
            _mockUnitOfWork = new Mock<IUnitOfWork>();
            _mockUnifiedOptinRepository = new Mock<IUnifiedOptInRepository>();
            _mockMemberPreferenceRepository = new Mock<IMemberPreferenceRepository>();
            _mockFileOperationsApiService = new Mock<IFileOperationsApiService>();

            _xdiBatchItemService = new XdiBatchService(_mockBatchItemsRepository.Object, _mockUnitOfWork.Object,
                           _mockUnifiedOptinRepository.Object, _mockMemberPreferenceRepository.Object,
                           _mockFileOperationsApiService.Object);
        }

        [Test]
        public async Task Test_Item_Exists()
        {
            var existing = new XdiBatchItem()
            {
                Created = DateTime.Now,
                BatchState = BatchState.New,
                LastUpdated = DateTime.Now,
                UserId = "99"
            };
            _mockBatchItemsRepository.Setup(x => x.FindExistingItem(existing.UserId, existing.BatchState))
                .ReturnsAsync(existing);
            _mockBatchItemsRepository.Setup(x => x.Update(existing)).Verifiable();
            _mockBatchItemsRepository.Setup(x => x.SaveAsync(existing)).Verifiable();
            _mockUnitOfWork.Setup(x => x.CompleteAsync()).Verifiable();

            XdiBatchItem testItem = new XdiBatchItem()
            {
                Created = DateTime.Now,
                BatchState = BatchState.New,
                LastUpdated = DateTime.Now,
                UserId = "99"
            };
            await _xdiBatchItemService.AddXdiBatchItem(testItem);

            _mockBatchItemsRepository.Verify(x => x.FindExistingItem(existing.UserId, existing.BatchState),
                Times.Once);
            _mockBatchItemsRepository.Verify(x => x.Update(existing), Times.Once);
            _mockBatchItemsRepository.Verify(x => x.SaveAsync(existing), Times.Never);
            _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
        }

        [Test]
        public async Task Test_Item_New()
        {
            _mockBatchItemsRepository.Setup(x => x.FindExistingItem(It.IsAny<string>(), It.IsAny<BatchState>()))
                .ReturnsAsync((XdiBatchItem)null);
            _mockBatchItemsRepository.Setup(x => x.Update(It.IsAny<XdiBatchItem>())).Verifiable();
            _mockBatchItemsRepository.Setup(x => x.SaveAsync(It.IsAny<XdiBatchItem>())).Verifiable();
            _mockUnitOfWork.Setup(x => x.CompleteAsync()).Verifiable();

            XdiBatchItem testItem = new XdiBatchItem()
            {
                Created = DateTime.Now,
                BatchState = BatchState.New,
                LastUpdated = DateTime.Now,
                UserId = "99"
            };
            await _xdiBatchItemService.AddXdiBatchItem(testItem);

            _mockBatchItemsRepository.Verify(x => x.FindExistingItem(It.IsAny<string>(), It.IsAny<BatchState>()),
                Times.Once);
            _mockBatchItemsRepository.Verify(x => x.Update(It.IsAny<XdiBatchItem>()), Times.Never);
            _mockBatchItemsRepository.Verify(x => x.SaveAsync(It.IsAny<XdiBatchItem>()), Times.Once);
            _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
        }

        [Test]
        public async Task Test_Create_Batch_Files()
        {
            IReadOnlyCollection<XdiBatchItem> items = new List<XdiBatchItem>()
            {
                new XdiBatchItem()
                {
                    Created = DateTime.Now,
                    BatchState = BatchState.New,
                    LastUpdated = DateTime.Now,
                    UserId = "99"
                },
                new XdiBatchItem()
                {
                    Created = DateTime.Now,
                    BatchState = BatchState.New,
                    LastUpdated = DateTime.Now,
                    UserId = "100"
                },
                new XdiBatchItem()
                {
                    Created = DateTime.Now,
                    BatchState = BatchState.New,
                    LastUpdated = DateTime.Now,
                    UserId = "101"
                },
                new XdiBatchItem()
                {
                    Created = DateTime.Now,
                    BatchState = BatchState.New,
                    LastUpdated = DateTime.Now,
                    UserId = "102"
                },
                //This is pending and we will process it again
                new XdiBatchItem()
                {
                    Created = DateTime.Now,
                    BatchState = BatchState.TransferPending,
                    LastUpdated = DateTime.Now,
                    UserId = "103"
                }
            };

            // Should be one of each type of change, resulting in a single line batch file for all types.
            var settings = new List<MemberOptInSettings>()
            {
                new MemberOptInSettings()
                {
                    Id = 1000,
                    UniversalOptIn = DeliveryPreference.Paper,
                    ENotifications = DeliveryPreference.Electronic,
                    EStatements = DeliveryPreference.Electronic,
                    UnifiedOptInEmail = "test@test.com",
                    ENotificationsEmail = "test@test.com",
                    EStatementsEmail = "test@test.com",
                    LastUpdated = DateTime.Now,
                    LegalDate = DateTime.Now,
                    LegalVersion = "1.2.3",
                    UserId = "99",
                    CreatedByType = UserType.Associate,
                    LastUpdatedByType = UserType.System,
                    CreatedBy = "test",
                    Created = DateTime.Now,
                    LastUpdatedBy = "test"
                },
                new MemberOptInSettings()
                {
                    Id = 1001,
                    UniversalOptIn = DeliveryPreference.Paper,
                    ENotifications = null,
                    EStatements = DeliveryPreference.Electronic,
                    UnifiedOptInEmail = "test@test.com",
                    ENotificationsEmail = null,
                    EStatementsEmail = "test@test.com",
                    UserId = "100"
                },
                new MemberOptInSettings()
                {
                    Id = 1002,
                    UniversalOptIn = DeliveryPreference.Electronic,
                    ENotifications = DeliveryPreference.Paper,
                    EStatements = DeliveryPreference.Paper,
                    UnifiedOptInEmail = "test@test.com",
                    ENotificationsEmail = "test@test.com",
                    EStatementsEmail = "test@test.com",
                    UserId = "101"
                },
                new MemberOptInSettings()
                {
                    Id = 1003,
                    UniversalOptIn = DeliveryPreference.Electronic,
                    ENotifications = null,
                    EStatements = DeliveryPreference.Paper,
                    UnifiedOptInEmail = "test@test.com",
                    ENotificationsEmail = null,
                    EStatementsEmail = null,
                    UserId = "102"
                },
                new MemberOptInSettings()
                {
                    Id = 1004,
                    UniversalOptIn = DeliveryPreference.Electronic,
                    ENotifications = DeliveryPreference.Electronic,
                    EStatements = DeliveryPreference.Electronic,
                    UnifiedOptInEmail = "updated_email@test.com",
                    ENotificationsEmail = "test@test.com",
                    EStatementsEmail = "test@test.com",
                    UserId = "103"
                }
            };
            _mockBatchItemsRepository.Setup(x => x.GetXdiBatchItems()).ReturnsAsync(items);
            foreach (var setting in settings)
            {
                _mockUnifiedOptinRepository.Setup(x => x.GetMemberOptInSettings(setting.UserId))
                    .ReturnsAsync(setting);
            }

            _mockBatchItemsRepository.Setup(x => x.Update(It.IsAny<XdiBatchItem>())).Verifiable();
            _mockBatchItemsRepository.Setup(x => x.Delete(It.IsAny<XdiBatchItem>())).Verifiable();
            _mockUnitOfWork.Setup(x => x.CompleteAsync(It.IsAny<string>(), It.IsAny<DateTime>(), It.IsAny<UserType>()))
                .Verifiable();
        }

        [Test]
        public async Task CreateXdiBatchExport_MultipleResults_Ok()
        {
            var testFile = new XdiBatchFile
            {
                Data = new List<XdiBatchFileRow>
                {
                    new XdiBatchFileRow {UserId = "100", Email = "test@test.com",},
                    new XdiBatchFileRow {UserId = "101", Email = "test@test.com",},
                    new XdiBatchFileRow {UserId = "102", Email = "test@test.com",},
                    new XdiBatchFileRow {UserId = "103", Email = "test@test.com",}
                }
            };

            IReadOnlyCollection<XdiBatchItem> items = new List<XdiBatchItem>()
            {
                new XdiBatchItem()
                {
                    Created = DateTime.Now,
                    BatchState = BatchState.New,
                    LastUpdated = DateTime.Now,
                    UserId = "99"
                },
                new XdiBatchItem()
                {
                    Created = DateTime.Now,
                    BatchState = BatchState.New,
                    LastUpdated = DateTime.Now,
                    UserId = "100"
                },
                new XdiBatchItem()
                {
                    Created = DateTime.Now,
                    BatchState = BatchState.New,
                    LastUpdated = DateTime.Now,
                    UserId = "101"
                },
                new XdiBatchItem()
                {
                    Created = DateTime.Now,
                    BatchState = BatchState.New,
                    LastUpdated = DateTime.Now,
                    UserId = "102"
                },
                //This is pending and we will process it again
                new XdiBatchItem()
                {
                    Created = DateTime.Now,
                    BatchState = BatchState.TransferPending,
                    LastUpdated = DateTime.Now,
                    UserId = "103"
                }
            };

            _mockUnifiedOptinRepository
                .Setup(x => x.GetMemberOptInSettingsNoTracking("100")).ReturnsAsync(new MemberOptInSettings
                {
                    UserId = "100",
                    UniversalOptIn = DeliveryPreference.Electronic,
                    UnifiedOptInEmail = "newemail@email.com"
                });

            _mockUnifiedOptinRepository
                .Setup(x => x.GetMemberOptInSettingsNoTracking("101")).ReturnsAsync(new MemberOptInSettings
                {
                    UserId = "101",
                    UniversalOptIn = DeliveryPreference.Paper
                });

            _mockUnifiedOptinRepository
                .Setup(x => x.GetMemberOptInSettingsNoTracking("102")).ReturnsAsync(new MemberOptInSettings
                {
                    UserId = "102",
                    UniversalOptIn = DeliveryPreference.Microfiche
                });

            _mockUnifiedOptinRepository
                .Setup(x => x.GetMemberOptInSettingsNoTracking("103")).ReturnsAsync(new MemberOptInSettings
                {
                    UserId = "103",
                    UniversalOptIn = DeliveryPreference.Hold
                });

            var appendFileResponse = new RequestResponse
            {
                IsSuccessful = true,
                ReturnResponse = new ReturnResponse
                {
                    ResponseItems = new List<ResponseItem>() {
                        new()
                        {
                            ResponsePayload = "File Created"
                        }
                }
                }
            };

            var request = new XdiBatchRequest()
            {
                XdiAppendFileRootBasePath = "test/test"
            };

            _mockFileOperationsApiService.Setup(x => x.AppendFile(It.IsAny<AppendFileRequest>())).ReturnsAsync(appendFileResponse).Verifiable();

            var results = await _xdiBatchItemService.BuildXdiFiles(testFile, request.XdiAppendFileRootBasePath);

            Assert.AreEqual(4, results.Count);
            Assert.True(results.Exists(x => x.UserId == "100" && x.Value == "newemail@email.com"));
            Assert.True(results.Exists(x => x.UserId == "101" && x.Value == DeliveryPreference.Paper));
            Assert.True(results.Exists(x => x.UserId == "102" && x.Value == DeliveryPreference.Paper));
            Assert.True(results.Exists(x => x.UserId == "103" && x.Value == DeliveryPreference.Paper));
        }

        [Test]
        public async Task CreateXdiBatchExport_Result_Ok()
        {
            var testFile = new XdiBatchFile
            {
                Data = new List<XdiBatchFileRow>
                {
                    new XdiBatchFileRow {UserId = "100", Email = "test@test.com",},
                    new XdiBatchFileRow {UserId = "101", Email = "test@test.com",},
                    new XdiBatchFileRow {UserId = "102", Email = "test@test.com",},
                    new XdiBatchFileRow {UserId = "103", Email = "test@test.com",}
                }
            };

            _mockUnifiedOptinRepository
                .Setup(x => x.GetMemberOptInSettingsNoTracking("100")).ReturnsAsync(new MemberOptInSettings
                {
                    UserId = "100",
                    UniversalOptIn = DeliveryPreference.Paper
                }).Verifiable();

            _mockUnifiedOptinRepository
                .Setup(x => x.GetMemberOptInSettingsNoTracking(It.Is<string>(userId => int.Parse(userId) > 100)))
                .Returns(Task.FromResult<MemberOptInSettings>(null));

            var request = new XdiBatchRequest()
            {
                XdiAppendFileRootBasePath = "test/test"
            };

            var appendFileResponse = new RequestResponse
            {
                IsSuccessful = true,
                ReturnResponse = new ReturnResponse
                {
                    ResponseItems = new List<ResponseItem>() {
                        new()
                        {
                            ResponsePayload = "File Created"
                        }
                }
                }
            };

            _mockFileOperationsApiService.Setup(x => x.AppendFile(It.IsAny<AppendFileRequest>())).ReturnsAsync(appendFileResponse).Verifiable();

            var results = await _xdiBatchItemService.BuildXdiFiles(testFile, request.XdiAppendFileRootBasePath);

            Assert.AreEqual(1, results.Count);
            Assert.True(results.Exists(x => x.UserId == "100" && x.Value == DeliveryPreference.Paper));
        }

        [Test]
        public async Task MarkPendingSuccessful_OK()
        {
            var batchFileExportList = new List<XdiBatchFileExport>()
            {
                new XdiBatchFileExport()
                {
                    UserId = "100",
                    Value = DeliveryPreference.Paper
                },
                new XdiBatchFileExport()
                {
                    UserId = "101",
                    Value = "test@test.com"
                }
            };
            var payloadString = JsonConvert.SerializeObject(batchFileExportList);

            var response = new LCU.Library.Internal.ApiResponse.Models.Response()
            {
                ResponsePayload = payloadString,
                Successful = true
            };

            _mockMemberPreferenceRepository.Setup(x => x.SaveMemberPreferenceAsync(It.IsAny<MemberPreference>()))
                .Verifiable();
            _mockMemberPreferenceRepository
                .Setup(x => x.BulkSaveMemberPreferenceAsync(It.IsAny<List<MemberPreference>>())).Verifiable();
            _mockUnifiedOptinRepository.Setup(x => x.GetOrCreateMemberOptinSettings(It.IsAny<string>()))
                .ReturnsAsync(new MemberOptInSettings());
            _mockBatchItemsRepository.Setup(x => x.MarkPendingSuccessful(It.IsAny<List<string>>())).ReturnsAsync(true)
                .Verifiable();

            var result = await _xdiBatchItemService.MarkPendingSuccessful(batchFileExportList);

            Assert.True(result);

            _mockBatchItemsRepository.Verify(x =>
                x.MarkPendingSuccessful(It.Is<List<string>>(list =>
                    list.Contains("100") && list.Contains("101"))));

            _mockMemberPreferenceRepository.Verify(x => x.SaveMemberPreferenceAsync(It.Is<MemberPreference>(preference =>
                preference.UserId == "100" && preference.Value == DeliveryPreference.Paper)));

            _mockMemberPreferenceRepository.Verify(x => x.BulkSaveMemberPreferenceAsync(It.Is<List<MemberPreference>>(
                preferenceList =>
                    preferenceList.Exists(x => x.UserId == "101" && x.Value == DeliveryPreference.Electronic) &&
                    preferenceList.Exists(x => x.UserId == "101" && x.Value == "test@test.com"))));

            _mockMemberPreferenceRepository.Verify(x =>
                x.SaveMemberPreferenceAsync(It.IsAny<MemberPreference>()), Times.Once());

            _mockMemberPreferenceRepository.Verify(x =>
                x.BulkSaveMemberPreferenceAsync(It.IsAny<List<MemberPreference>>()), Times.Once());
        }
    }
}