using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using LCU.API.Internal.Operations.IncentiveApiLib.Repositories;
using LCU.API.Internal.Operations.IncentiveApi.Services;
using CsvHelper;
using LCU.Library.Internal.IncentiveApiModels.Entities;
using LCU.Library.Internal.IncentiveApiModels.Enums;
using Moq;
using NUnit.Framework;
using LCU.API.Internal.Operations.IncentiveApi.Services.Allied;
using LCU.API.Internal.Operations.IncentiveApi.Services.AutoDecision;
using LCU.Library.Internal.IncentiveApiModels.Requests;
using LCU.API.Internal.Operations.IncentiveApi.Models.Allied;
using LCU.API.Internal.Operations.IncentiveApi.Models;
using LCU.API.Internal.Operations.IncentiveApi.Services.MicroApiServices;
using LCU.Library.Internal.FileOperationsModels.Models.NameSettings;
using LCU.Library.Internal.FileOperationsModels.Models;

namespace Application.UnitTests.Services.Allied
{
    public class AlliedTransactionImportServiceTest
    {
        private IAlliedGapMbpTransactionImportService _service;
        private IUserRepository _userRepository;
        private IActivityService _activityService;
        private IActivityDecisionService _activityDecisionService;
        private IActivityDetailService _activityDetailService;
        private DebtProtectionAccessoryService _debtProtectionAccessoryService;
        private IDnaService _dnaService;
        private IFileOperationsApiService _fileOperationsApiService;
        private Mock<IDeadActivityService> _deadActivityService;
        private IGapInsuranceActivityService _gapInsuranceActivityService;
        private Mock<IActivityRepository> _activityRepository;
        private Mock<IUnitOfWork> _unitOfWork;
        private int _expectedRecordCount;
        private string _testDataFilePath;

        [SetUp]
        public void Setup()
        {
            var strategies = new List<IDecisionStrategy>
            {
                new DebtProtectionEligibleLoanDecisionStrategy(),
                new GapDecisionStrategy(),
                new ManualDecisionStrategy(),
                new MbpDecisionStrategy(),
                new MortgageSaleDecisionStrategy(),
                new NewCheckingDecisionStrategy(),
                new ReferralDecisionStrategy(),
                new VehicleDecisionStrategy()
            };
            _userRepository = Mock.Of<IUserRepository>();
            _fileOperationsApiService = Mock.Of<IFileOperationsApiService>();
            _activityService = Mock.Of<IActivityService>();
            _activityDetailService = Mock.Of<IActivityDetailService>();
            _debtProtectionAccessoryService = new DebtProtectionAccessoryService(_activityService, _activityDetailService);
            _dnaService = Mock.Of<IDnaService>();
            _activityDecisionService = new ActivityDecisionService(strategies, _activityService, _activityDetailService, _debtProtectionAccessoryService, _dnaService);
            _deadActivityService = new Mock<IDeadActivityService>();
            _activityRepository = new Mock<IActivityRepository>();
            _unitOfWork = new Mock<IUnitOfWork>();
            _gapInsuranceActivityService = new GapInsuranceActivityService(_activityDetailService, _activityRepository.Object, _activityService, _unitOfWork.Object);
            _service = new AlliedGapMbpTransactionImportService(
                _userRepository,
                _gapInsuranceActivityService,
                _fileOperationsApiService,
                _activityService,
                _activityDecisionService,
                _activityDetailService,
                _deadActivityService.Object
            );
            _expectedRecordCount = 12;
            _testDataFilePath = @"Services/Allied/SalesWithCancellationsByEmployee.csv";
        }

        public StreamReader GetAlliedFile()
        {
            var path = _testDataFilePath;
            var reader = new StreamReader(path);
            return reader;
        }

        [Test]
        public async Task ProcessFileNames_OK()
        {
            var department = new Department()
            {
                DepartmentName = "Dept1",
                Id = 55,
                State = DepartmentState.Active
            };
            var user = new AppUser()
            {
                AdEmail = "johndoe@test.com",
                EmployeeId = "11771",
                FullName = "John Doe",
                Departments = new List<UserDepartment>()
            };
            var assignment = new UserDepartment()
            {
                Id = 99,
                Department = department,
                Employee = user,
                Role = Role.BM,
                IsHome = true,
                StartDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1),
                EndDate = null
            };
            user.Departments.Add(assignment);

            var request = new AlliedGapMbpRequest
            {
                DynamicFileName = "alliedgapmbp",
                FilePath = "clean",
                DynamicFileSettings = new DynamicNameSetting() { }
            };

            var files = new string[]
            {
                "x"
            };

            byte[] array = File.ReadAllBytes(_testDataFilePath);

            //Setup
            Mock.Get(_fileOperationsApiService).Setup(x => x.BuildDynamicFileList(It.IsAny<DynamicFileListRequest>())).ReturnsAsync(files);
            Mock.Get(_fileOperationsApiService).Setup(x => x.GetFileContent(It.IsAny<string>())).ReturnsAsync(array.ToString());
            Mock.Get(_userRepository).Setup(s => s.SearchUsersAsync(It.IsAny<UserSearchRequest>())).ReturnsAsync(new List<AppUser>() { user });
           
            var results = await _service.ImportTransactions<AlliedSaleRow>(request);
            var activities = await _service.CreateActivity(It.IsAny<IEnumerable<AlliedSaleRow>>());
            Mock.Get(_fileOperationsApiService).Verify(x => x.GetFileContent(It.IsAny<string>()), Times.Once);
            Assert.AreEqual("alliedgapmbp", request.DynamicFileName);
        }

        [Test]
        public async Task ProcessCsv_OK()
        {
            SetupTestUsers();
            SetupTestActivities();

            var transactions = ImportTestTransactions();
            Assert.NotNull(transactions);
            var alliedSaleRows = transactions.ToList();
            Assert.IsNotEmpty(alliedSaleRows);
            Assert.AreEqual(_expectedRecordCount, alliedSaleRows.Count());

            var results = await _service.CreateActivity(alliedSaleRows);
            Assert.NotNull(results);
            Assert.AreEqual(_expectedRecordCount, results.Count);
            Assert.AreEqual(_expectedRecordCount, results.Count(x => x.SourceSystem == SystemType.Allied));
        }

        public IEnumerable<AlliedSaleRow> ImportTestTransactions()
        {
            var input = GetAlliedFile();
            var csvReader = new CsvReader(input, CultureInfo.InvariantCulture);
            return csvReader.GetRecords<AlliedSaleRow>().ToList();
        }

        public void SetupTestUsers()
        {
            var department = new Department()
            {
                DepartmentName = "Dept1",
                Id = 55,
                State = DepartmentState.Active
            };

            var testUsers = new List<AppUser>
            {
                new()
                {
                    AdEmail = "AbrahamTestAssociate1@test.com",
                    EmployeeId = "11771",
                    FullName = "Abraham TestAssociate1",
                    Id = Guid.NewGuid(),
                    Departments = new List<UserDepartment>
                    {
                        new()
                        {
                            Id = 99,
                            Department = department,
                            Employee = null,
                            Role = Role.BM,
                            IsHome = true,
                            StartDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1),
                            EndDate = null
                        }
                    }
                },
                new()
                {
                    AdEmail = "FranchelieTestAssociate2@test.com",
                    EmployeeId = "11772",
                    FullName = "Franchelie TestAssociate2",
                    Id = Guid.NewGuid(),
                    Departments = new List<UserDepartment>
                    {
                        new()
                        {
                            Id = 100,
                            Department = department,
                            Employee = null,
                            Role = Role.BM,
                            IsHome = true,
                            StartDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1),
                            EndDate = null
                        }
                    }
                },
                new()
                {
                    AdEmail = "StefaniTestAssociate3@test.com",
                    EmployeeId = "11773",
                    FullName = "Stefani TestAssociate3",
                    Id = Guid.NewGuid(),
                    Departments = new List<UserDepartment>
                    {
                        new()
                        {
                            Id = 101,
                            Department = department,
                            Employee = null,
                            Role = Role.BM,
                            IsHome = true,
                            StartDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1),
                            EndDate = null
                        }
                    }
                },
                new()
                {
                    AdEmail = "AmarisaTestAssociate4@test.com",
                    EmployeeId = "11774",
                    FullName = "Amarisa TestAssociate4",
                    Id = Guid.NewGuid(),
                    Departments = new List<UserDepartment>
                    {
                        new()
                        {
                            Id = 102,
                            Department = department,
                            Employee = null,
                            Role = Role.BM,
                            IsHome = true,
                            StartDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1),
                            EndDate = null
                        }
                    }
                },
                new()
                {
                    AdEmail = "AmaliaTestAssociate5@test.com",
                    EmployeeId = "11774",
                    FullName = "Amalia TestAssociate5",
                    Id = Guid.NewGuid(),
                    Departments = new List<UserDepartment>
                    {
                        new()
                        {
                            Id = 103,
                            Department = department,
                            Employee = null,
                            Role = Role.BM,
                            IsHome = true,
                            StartDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1),
                            EndDate = null
                        }
                    }
                }
            };

            foreach (var user in testUsers)
            {
                user.Departments.First().Employee = user;
                Mock.Get(_userRepository)
                    .Setup(r => r.SearchUsersAsync(It.Is<UserSearchRequest>(x => x.Query == user.FullName)))
                    .ReturnsAsync(new List<AppUser> { testUsers.First(x => x.FullName == user.FullName) });
            }
        }

        public void SetupTestActivities()
        {
            var existingActivities = new List<Activity>
            {
                new()
                {
                    Id = 1,
                    DepartmentId = 55,
                    EmployeeId = "11774",
                    Type = ActivityType.Sale,
                    Product = Product.GAPInsurance,
                    Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                    SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                    SourceSystem = SystemType.Allied,
                    State = ActivityState.Accepted,
                    Detail = new ActivityDetail()
                    {
                        AccountNumber = "867530986",
                        MemberName = "ORLANDO TESTCUSTOMER10"
                    }
                },
                new()
                {
                    Id = 2,
                    DepartmentId = 55,
                    EmployeeId = "11774",
                    Type = ActivityType.Sale,
                    Product = Product.GAPInsurance,
                    Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                    SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                    SourceSystem = SystemType.Allied,
                    State = ActivityState.Accepted,
                    Detail = new ActivityDetail()
                    {
                        AccountNumber = "8675309861",
                        MemberName = "ORLANDO TESTCUSTOMER11"
                    }
                },
                new()
                {
                    Id = 3,
                    DepartmentId = 55,
                    EmployeeId = "11774",
                    Type = ActivityType.Sale,
                    Product = Product.GAPInsurance,
                    Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                    SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                    SourceSystem = SystemType.Allied,
                    State = ActivityState.Accepted,
                    Detail = new ActivityDetail()
                    {
                        AccountNumber = "8675309862",
                        MemberName = "ORLANDO TESTCUSTOMER12"
                    }
                }
            };

            foreach (var queryActivity in existingActivities)
            {
                Mock.Get(_activityService)
                    .Setup(r => r
                        .GetActivityForStateUpdate(It.Is<Activity>(x => x.EmployeeId == queryActivity.EmployeeId
                                                                        && x.Product == queryActivity.Product
                                                                        && x.Detail.AccountNumber == queryActivity.Detail.AccountNumber
                        )))
                    .ReturnsAsync(existingActivities.First(x => x.EmployeeId == queryActivity.EmployeeId
                                                                && x.Product == queryActivity.Product
                                                                && x.Detail.AccountNumber == queryActivity.Detail.AccountNumber
                    ));

                Mock.Get(_activityService)
                    .Setup(r => r
                        .GetActivityForDetailUpdate(It.Is<Activity>(x => x.EmployeeId == queryActivity.EmployeeId
                                                                         && x.Product == queryActivity.Product
                                                                         && x.Detail.AccountNumber == queryActivity.Detail.AccountNumber
                        )))
                    .ReturnsAsync(existingActivities.First(x => x.EmployeeId == queryActivity.EmployeeId
                                                                && x.Product == queryActivity.Product
                                                                && x.Detail.AccountNumber == queryActivity.Detail.AccountNumber
                    ));

                Mock.Get(_activityService)
                    .Setup(r => r
                        .GetActivity(It.IsAny<int>()))
                    .ReturnsAsync(existingActivities.First(x => x.Id == queryActivity.Id
                    ));

                Mock.Get(_activityService)
                    .Setup(r => r
                        .CreateAndRetrieveActivity(It.Is<Activity>(x =>
                            x.AppUserId == queryActivity.AppUserId
                            && x.EmployeeId == queryActivity.EmployeeId
                            && x.Product == queryActivity.Product
                            && x.Detail.AccountNumber == queryActivity.Detail.AccountNumber
                            && x.Detail.SubAccountNumber == queryActivity.Detail.SubAccountNumber
                        )))
                    .ReturnsAsync(existingActivities.First(x =>
                        x.AppUserId == queryActivity.AppUserId
                        && x.EmployeeId == queryActivity.EmployeeId
                        && x.Product == queryActivity.Product
                        && x.Detail.AccountNumber == queryActivity.Detail.AccountNumber
                        && x.Detail.SubAccountNumber == queryActivity.Detail.SubAccountNumber
                    ));
            }

            Mock.Get(_activityService)
                .Setup(r => r
                    .CreateAndRetrieveActivity(It.IsAny<Activity>()))
                .ReturnsAsync(new Activity()
                {
                    AppUserId = Guid.NewGuid(),
                    DepartmentId = 55,
                    EmployeeId = "11774",
                    Type = ActivityType.Sale,
                    Product = Product.GAPInsurance,
                    Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                    SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                    SourceSystem = SystemType.Allied,
                    State = ActivityState.Accepted,
                    Detail = new ActivityDetail()
                    {
                        AccountNumber = "8675309862",
                        MemberName = "ORLANDO TESTCUSTOMER12"
                    }
                });
        }

        [Test]
        public async Task SavesDeadActivity_WhenNoUserFound()
        {
            Mock.Get(_userRepository).Setup(s => s.FindUserByAdEmailAsync(It.IsAny<string>())).ReturnsAsync((AppUser)null);

            var transactions = ImportTestTransactions();
            Assert.NotNull(transactions);
            Assert.IsNotEmpty(transactions);
            Assert.AreEqual(_expectedRecordCount, transactions.Count());

            var results = await _service.CreateActivity(transactions);
            Assert.NotNull(results);
            Assert.IsEmpty(results);

            _deadActivityService.Verify(x => x.SaveDeadActivityRange(It.Is<List<DeadActivity>>(
                da =>
                    da.Count() == _expectedRecordCount &&
                    da.All(y => y.Reason == DeadActivityReason.MissingRequiredField) &&
                    da.All(y => y.ReasonNote.ToLowerInvariant().Contains("allied import, no user for")))));
        }

        [Test]
        public async Task SavesDeadActivity_WhenFindingUserFails()
        {
            Mock.Get(_userRepository)
                .Setup(s => s.FindUserByAdEmailAsync(It.IsAny<string>()))
                .Throws(new Exception("OOops"));

            var transactions = ImportTestTransactions();
            Assert.NotNull(transactions);
            Assert.IsNotEmpty(transactions);
            Assert.AreEqual(_expectedRecordCount, transactions.Count());

            var results = await _service.CreateActivity(transactions);
            Assert.NotNull(results);
            Assert.IsEmpty(results);

            _deadActivityService.Verify(x => x.SaveDeadActivityRange(It.Is<List<DeadActivity>>(
                da =>
                    da.Count() == _expectedRecordCount &&
                    da.All(y => y.Reason == DeadActivityReason.MissingRequiredField) &&
                    da.All(y => y.ReasonNote.ToLowerInvariant().Contains("allied import, no user for")))));
        }

        [Test]
        public async Task SavesDeadActivity_WhenTooManyUserFound()
        {
            Mock.Get(_userRepository)
                .Setup(s => s.SearchUsersAsync(It.IsAny<UserSearchRequest>()))
                .ReturnsAsync(new List<AppUser>()
                    { new() { EmployeeId = "One" }, new() { EmployeeId = "Two" } });

            var transactions = ImportTestTransactions();
            Assert.NotNull(transactions);
            Assert.IsNotEmpty(transactions);
            Assert.AreEqual(_expectedRecordCount, transactions.Count());

            var results = await _service.CreateActivity(transactions);
            Assert.NotNull(results);
            Assert.IsEmpty(results);

            _deadActivityService.Verify(x => x.SaveDeadActivityRange(It.Is<List<DeadActivity>>(
                da =>
                    da.Count() == _expectedRecordCount &&
                    da.All(y => y.Reason == DeadActivityReason.MissingRequiredField) &&
                    da.All(y => y.ReasonNote.ToLowerInvariant().Contains("allied import, no user for")))));
        }

        [Test]
        public async Task SavesDeadActivity_WhenNoHomeDepartmentFound()
        {
            //Use one user for all lines for simplicity
            var user = new AppUser()
            {
                AdEmail = "johndoe@test.com",
                EmployeeId = "11771",
                FullName = "John Doe",
                Departments = new List<UserDepartment>()
            };

            Mock.Get(_userRepository).Setup(s => s.SearchUsersAsync(It.IsAny<UserSearchRequest>())).ReturnsAsync(new List<AppUser> { user });

            var transactions = ImportTestTransactions();
            Assert.NotNull(transactions);
            Assert.IsNotEmpty(transactions);
            Assert.AreEqual(_expectedRecordCount, transactions.Count());

            var results = await _service.CreateActivity(transactions);
            Assert.NotNull(results);
            Assert.IsEmpty(results);

            _deadActivityService.Verify(x => x.SaveDeadActivityRange(It.Is<List<DeadActivity>>(
                da =>
                    da.Count() == _expectedRecordCount &&
                    da.All(y => y.Reason == DeadActivityReason.MissingRequiredField) &&
                    da.All(y => y.ReasonNote.ToLowerInvariant().Contains("reliably determinable home")))));
        }

        [Test]
        public async Task SavesDeadActivity_BothKinds()
        {
            var noHomeDepartmentUser = new AppUser()
            {
                AdEmail = "StefaniTestAssociate3@test.com",
                EmployeeId = "11773",
                FullName = "Stefani TestAssociate3",
                Departments = new List<UserDepartment>()
            };

            Mock.Get(_userRepository)
                .Setup(s => s.SearchUsersAsync(It.Is<UserSearchRequest>(x => x.Query == noHomeDepartmentUser.FullName)))
                .ReturnsAsync(new List<AppUser> { noHomeDepartmentUser });

            var transactions = ImportTestTransactions();
            var expectedHomelessDeadRecordCount = transactions.Count(x => x.Quoter == noHomeDepartmentUser.FullName);

            Assert.NotNull(transactions);
            Assert.IsNotEmpty(transactions);
            Assert.AreEqual(_expectedRecordCount, transactions.Count());

            var results = await _service.CreateActivity(transactions);
            Assert.NotNull(results);
            Assert.IsEmpty(results);

            _deadActivityService.Verify(x => x.SaveDeadActivityRange(It.Is<List<DeadActivity>>(
                da =>
                    da.Count(y =>
                        y.Reason == DeadActivityReason.MissingRequiredField &&
                        y.ReasonNote.ToLowerInvariant().Contains("allied import, no user for")) ==
                    _expectedRecordCount - expectedHomelessDeadRecordCount)));

            _deadActivityService.Verify(x => x.SaveDeadActivityRange(It.Is<List<DeadActivity>>(
                da =>
                    da.Count(y =>
                        y.Reason == DeadActivityReason.MissingRequiredField &&
                        y.ReasonNote.ToLowerInvariant().Contains("reliably determinable home")) == expectedHomelessDeadRecordCount)));
        }

        [Test]
        public async Task FailToSaveDeadActivity_DoesntThrow()
        {
            Mock.Get(_userRepository).Setup(s => s.FindUserByAdEmailAsync(It.IsAny<string>())).ReturnsAsync((AppUser)null);
            _deadActivityService.Setup(x => x.SaveDeadActivityRange(It.IsAny<List<DeadActivity>>()))
                .ThrowsAsync(new Exception("Oops"));

            var transactions = ImportTestTransactions();
            Assert.NotNull(transactions);
            Assert.IsNotEmpty(transactions);
            Assert.AreEqual(_expectedRecordCount, transactions.Count());

            List<Activity> results = null;
            Assert.DoesNotThrowAsync(async () =>
            {
                var res = await _service.CreateActivity(transactions);
                results = res.ToList();
            });
            Assert.NotNull(results);
            Assert.IsEmpty(results);

            _deadActivityService.Verify(x => x.SaveDeadActivityRange(It.Is<List<DeadActivity>>(
                da =>
                    da.Count() == _expectedRecordCount &&
                    da.All(y => y.Reason == DeadActivityReason.MissingRequiredField) &&
                    da.All(y => y.ReasonNote.ToLowerInvariant().Contains("allied import, no user for")))));
        }

        [Test]
        public async Task FilterAndOrderUpdates_DefaultWithNullExisting()
        {
            var sourceCreatedNewer = DateTime.Today.Subtract(TimeSpan.FromDays(3));
            var sourceCreatedOlder = DateTime.Today.Subtract(TimeSpan.FromDays(7));

            var activityProcessingOrder = new ActivityProcessingOrder
            {
                ExistingActivity = null,
                ActivityUpdateItems = new List<Activity>()
                {
                    new()
                    {
                        DepartmentId = 55,
                        EmployeeId = "11774",
                        Type = ActivityType.Sale,
                        Product = Product.MechanicalBreakdownProtection,
                        Accepted = sourceCreatedOlder,
                        SourceCreated = sourceCreatedOlder,
                        SourceId = "1",
                        State = ActivityState.Accepted,
                        Detail = new ActivityDetail
                        {
                            AccountNumber = "867530986",
                            AccountStatus = "Cancelled",
                            MemberName = "ORLANDO TESTCUSTOMER10",
                            SubAccountNumber = "8675309-AAG"
                        }
                    },
                    new()
                    {
                        DepartmentId = 55,
                        EmployeeId = "11774",
                        Type = ActivityType.Sale,
                        Product = Product.MechanicalBreakdownProtection,
                        Accepted = sourceCreatedOlder,
                        SourceCreated = sourceCreatedOlder,
                        SourceId = "1",
                        State = ActivityState.Accepted,
                        Detail = new ActivityDetail
                        {
                            AccountNumber = "867530986",
                            AccountStatus = "Flagged",
                            MemberName = "ORLANDO TESTCUSTOMER10",
                            SubAccountNumber = "8675309-AAG"
                        }
                    },
                    new()
                    {
                        DepartmentId = 55,
                        EmployeeId = "11774",
                        Type = ActivityType.Sale,
                        Product = Product.MechanicalBreakdownProtection,
                        Accepted = sourceCreatedNewer,
                        SourceCreated = sourceCreatedNewer,
                        SourceId = "1",
                        State = ActivityState.Accepted,
                        Detail = new ActivityDetail
                        {
                            AccountNumber = "867530986",
                            AccountStatus = "Sold",
                            MemberName = "ORLANDO TESTCUSTOMER10",
                            SubAccountNumber = "8675309-AAG"
                        }
                    },
                    new()
                    {
                        DepartmentId = 55,
                        EmployeeId = "11774",
                        Type = ActivityType.Sale,
                        Product = Product.MechanicalBreakdownProtection,
                        Accepted = sourceCreatedOlder,
                        SourceCreated = sourceCreatedOlder,
                        SourceId = "1",
                        State = ActivityState.Accepted,
                        Detail = new ActivityDetail
                        {
                            AccountNumber = "867530986",
                            AccountStatus = "Reinstated",
                            MemberName = "ORLANDO TESTCUSTOMER10",
                            SubAccountNumber = "8675309-AAG"
                        }
                    },
                    new()
                    {
                        DepartmentId = 55,
                        EmployeeId = "11774",
                        Type = ActivityType.Sale,
                        Product = Product.MechanicalBreakdownProtection,
                        Accepted = sourceCreatedOlder,
                        SourceCreated = sourceCreatedOlder,
                        SourceId = "1",
                        State = ActivityState.Accepted,
                        Detail = new ActivityDetail
                        {
                            AccountNumber = "867530986",
                            AccountStatus = "Sold",
                            MemberName = "ORLANDO TESTCUSTOMER10",
                            SubAccountNumber = "8675309-AAG"
                        }
                    },
                    new Activity()
                    {
                        DepartmentId = 55,
                        EmployeeId = "11774",
                        Type = ActivityType.Sale,
                        Product = Product.MechanicalBreakdownProtection,
                        Accepted = sourceCreatedOlder,
                        SourceCreated = sourceCreatedOlder,
                        SourceId = "1",
                        State = ActivityState.Accepted,
                        Detail = new ActivityDetail
                        {
                            AccountNumber = "867530986",
                            AccountStatus = "Cancelled/Re-Quoted",
                            MemberName = "ORLANDO TESTCUSTOMER10",
                            SubAccountNumber = "8675309-AAG"
                        }
                    }
                }
            };

            activityProcessingOrder = _service.FilterAndOrderUpdates(activityProcessingOrder);

            Assert.AreEqual(6, activityProcessingOrder.ActivityUpdateItems.Count);

            Assert.AreEqual(0, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.Detail.AccountStatus == "Flagged"));
            Assert.AreEqual(1, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.Detail.AccountStatus == "Sold" && x.SourceCreated == sourceCreatedOlder));
            Assert.AreEqual(2, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.Detail.AccountStatus == "Cancelled/Re-Quoted"));
            Assert.AreEqual(3, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.Detail.AccountStatus == "Cancelled"));
            Assert.AreEqual(4, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.Detail.AccountStatus == "Reinstated"));
            Assert.AreEqual(5, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.SourceCreated == sourceCreatedNewer));
        }

        [Test]
        public async Task FilterAndOrderUpdates_DefaultWithNonNullExisting()
        {
            var sourceCreatedNewer = DateTime.Today.Subtract(TimeSpan.FromDays(3));
            var sourceCreatedOlder = DateTime.Today.Subtract(TimeSpan.FromDays(7));

            var activityProcessingOrder = new ActivityProcessingOrder
            {
                ExistingActivity = new Activity
                {
                    Id = 1,
                    DepartmentId = 55,
                    EmployeeId = "11774",
                    Type = ActivityType.Sale,
                    Product = Product.MechanicalBreakdownProtection,
                    Accepted = sourceCreatedOlder,
                    SourceCreated = sourceCreatedOlder,
                    SourceId = "1",
                    State = ActivityState.Accepted,
                    Detail = new ActivityDetail
                    {
                        AccountNumber = "867530986",
                        AccountStatus = "Cancelled/Re-Quoted",
                        MemberName = "ORLANDO TESTCUSTOMER10",
                        SubAccountNumber = "8675309-AAG"
                    }
                },
                ActivityUpdateItems = new List<Activity>()
                {
                    new()
                    {
                        DepartmentId = 55,
                        EmployeeId = "11774",
                        Type = ActivityType.Sale,
                        Product = Product.MechanicalBreakdownProtection,
                        Accepted = sourceCreatedOlder,
                        SourceCreated = sourceCreatedOlder,
                        SourceId = "1",
                        State = ActivityState.Accepted,
                        Detail = new ActivityDetail
                        {
                            AccountNumber = "867530986",
                            AccountStatus = "Cancelled",
                            MemberName = "ORLANDO TESTCUSTOMER10",
                            SubAccountNumber = "8675309-AAG"
                        }
                    },
                    new()
                    {
                        DepartmentId = 55,
                        EmployeeId = "11774",
                        Type = ActivityType.Sale,
                        Product = Product.MechanicalBreakdownProtection,
                        Accepted = sourceCreatedOlder,
                        SourceCreated = sourceCreatedOlder,
                        SourceId = "1",
                        State = ActivityState.Accepted,
                        Detail = new ActivityDetail
                        {
                            AccountNumber = "867530986",
                            AccountStatus = "Flagged",
                            MemberName = "ORLANDO TESTCUSTOMER10",
                            SubAccountNumber = "8675309-AAG"
                        }
                    },
                    new()
                    {
                        DepartmentId = 55,
                        EmployeeId = "11774",
                        Type = ActivityType.Sale,
                        Product = Product.MechanicalBreakdownProtection,
                        Accepted = sourceCreatedNewer,
                        SourceCreated = sourceCreatedNewer,
                        SourceId = "1",
                        State = ActivityState.Accepted,
                        Detail = new ActivityDetail
                        {
                            AccountNumber = "867530986",
                            AccountStatus = "Sold",
                            MemberName = "ORLANDO TESTCUSTOMER10",
                            SubAccountNumber = "8675309-AAG"
                        }
                    },
                    new()
                    {
                        DepartmentId = 55,
                        EmployeeId = "11774",
                        Type = ActivityType.Sale,
                        Product = Product.MechanicalBreakdownProtection,
                        Accepted = sourceCreatedOlder,
                        SourceCreated = sourceCreatedOlder,
                        SourceId = "1",
                        State = ActivityState.Accepted,
                        Detail = new ActivityDetail
                        {
                            AccountNumber = "867530986",
                            AccountStatus = "Reinstated",
                            MemberName = "ORLANDO TESTCUSTOMER10",
                            SubAccountNumber = "8675309-AAG"
                        }
                    },
                    new()
                    {
                        DepartmentId = 55,
                        EmployeeId = "11774",
                        Type = ActivityType.Sale,
                        Product = Product.MechanicalBreakdownProtection,
                        Accepted = sourceCreatedOlder,
                        SourceCreated = sourceCreatedOlder,
                        SourceId = "1",
                        State = ActivityState.Accepted,
                        Detail = new ActivityDetail
                        {
                            AccountNumber = "867530986",
                            AccountStatus = "Sold",
                            MemberName = "ORLANDO TESTCUSTOMER10",
                            SubAccountNumber = "8675309-AAG"
                        }
                    },
                    new Activity()
                    {
                        DepartmentId = 55,
                        EmployeeId = "11774",
                        Type = ActivityType.Sale,
                        Product = Product.MechanicalBreakdownProtection,
                        Accepted = sourceCreatedOlder,
                        SourceCreated = sourceCreatedOlder,
                        SourceId = "1",
                        State = ActivityState.Accepted,
                        Detail = new ActivityDetail
                        {
                            AccountNumber = "867530986",
                            AccountStatus = "Cancelled/Re-Quoted",
                            MemberName = "ORLANDO TESTCUSTOMER10",
                            SubAccountNumber = "8675309-AAG"
                        }
                    }
                }
            };

            activityProcessingOrder = _service.FilterAndOrderUpdates(activityProcessingOrder);

            Assert.AreEqual(4, activityProcessingOrder.ActivityUpdateItems.Count);

            // These items should return an index of -1 since they should be removed in order to not run already run updates against the existing item
            Assert.AreEqual(-1, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.Detail.AccountStatus == "Flagged"));
            Assert.AreEqual(-1, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.Detail.AccountStatus == "Sold" && x.SourceCreated == sourceCreatedOlder));
            Assert.AreEqual(0, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.Detail.AccountStatus == "Cancelled/Re-Quoted"));
            Assert.AreEqual(1, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.Detail.AccountStatus == "Cancelled"));
            Assert.AreEqual(2, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.Detail.AccountStatus == "Reinstated"));
            Assert.AreEqual(3, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.SourceCreated == sourceCreatedNewer));
        }

        [TestCase(ActivityState.PendingTransfer, 0, true)] // Activity exists, is pending transfer, and not updated
        [TestCase(ActivityState.Rejected, 0, true)] // Activity exists, is pending transfer, and not updated
        [TestCase(ActivityState.Transferred, 0, true)] // Activity exists, is pending transfer, and not updated
        [TestCase(ActivityState.Accepted, 1, false)] // Activity does not exist and is created
        [TestCase(ActivityState.Accepted, 0, true)] // Activity exists and is not created
        [Test]
        public async Task CreateActivity_ExistingActivityInVariousStates_ReturnsExpectedResultsCount(ActivityState activityState, int expectedResultCount, bool returnsActivity)
        {
            SetupTestUsers();
            var transactions = new List<AlliedSaleRow>()
            {
                new AlliedSaleRow()
                {
                    AccountNumber = "1234",
                    Origin = "LenderWebsite",
                    ProductType = "GAP",
                    Status = "Sold",
                    SaleDate = DateTime.Now.ToString(),
                    Buyer = "Buyer",
                    SalesContractNumber = "1",
                    Issuer = "Abraham TestAssociate1"
                }
            };

            var existingActivity = new Activity()
            {
                Id = 1,
                DepartmentId = 55,
                EmployeeId = "11774",
                Type = ActivityType.Sale,
                Product = Product.GAPInsurance,
                Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceSystem = SystemType.Allied,
                State = activityState,
                Detail = new ActivityDetail()
                {
                    AccountNumber = "867530986",
                    MemberName = "ORLANDO TESTCUSTOMER10",
                    SubAccountNumber = "1",
                    AccountStatus = "Sold"
                }
            };

            var newlyCreatedActivity = new Activity()
            {
                Id = 1,
                DepartmentId = 55,
                EmployeeId = "11774",
                Type = ActivityType.Sale,
                Product = Product.GAPInsurance,
                Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceSystem = SystemType.Allied,
                State = returnsActivity == true ? activityState : ActivityState.Created, // if an activity does not exist, the new activity is initially in Created state
                Detail = new ActivityDetail()
                {
                    AccountNumber = "867530986",
                    MemberName = "ORLANDO TESTCUSTOMER10",
                    SubAccountNumber = "1",
                    AccountStatus = "Sold"
                }
            };

            Mock.Get(_activityService)
                .Setup(a => a.GetActivityForDetailUpdate(It.IsAny<Activity>()))
                .ReturnsAsync(returnsActivity == true ? existingActivity : (Activity)null);

            Mock.Get(_activityService)
                .Setup(a => a.CreateAndRetrieveActivity(It.IsAny<Activity>()))
                .ReturnsAsync(newlyCreatedActivity);            

            var resutls = await _service.CreateActivity(transactions);

            Assert.IsNotNull(resutls);
            Assert.AreEqual(expectedResultCount, resutls.Count);
        }
    }
}