using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using LCU.API.Internal.Operations.IncentiveApi.Services;
using LCU.Library.Internal.IncentiveApiModels.Entities;
using LCU.Library.Internal.IncentiveApiModels.Enums;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Transaction;
using Moq;
using NUnit.Framework;
using LCU.API.Internal.Operations.IncentiveApi.Services.AutoDecision;
using LCU.Library.Internal.IncentiveApiModels.Common;
using LCU.API.Internal.Operations.IncentiveApi.Exceptions;
using LCU.Library.Internal.IncentiveApiModels.Requests;

namespace Application.UnitTests.Services.AutoDecision
{
    public class ActivityDecisionServiceTest
    {
        private ActivityDecisionService _activityDecisionService;
        private IActivityService _activityService;
        private IActivityDetailService _activityDetailService;
        private DebtProtectionAccessoryService _debtProtectionAccessoryService;
        private IDnaService _dnaService;

        [SetUp]
        public void Setup()
        {
            var strategies = new List<IDecisionStrategy>()
            {
                new ManualDecisionStrategy(),
                new ReferralDecisionStrategy(),
                new NewCheckingDecisionStrategy(),
                new CardSaleDecisionStrategy(),
                new MortgageSaleDecisionStrategy(),
                new VehicleDecisionStrategy(),
                new DebtProtectionEligibleLoanDecisionStrategy()
            };
            _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);
        }

        [Test]
        public async Task Decision_Basic_Accept()
        {
            var activity = new Activity()
            {
                DepartmentId = 56,
                EmployeeId = "11771",
                Type = ActivityType.Other,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                Detail = new ActivityDetail()
                {
                    AccountStatus = "ACT"
                }
            };
            var decision = await _activityDecisionService.TryDecisionActivity(activity);
            Assert.NotNull(activity);
            Assert.AreNotEqual(activity.State, decision.State);
            Assert.AreEqual(ActivityState.Accepted, decision.State);
            Assert.AreEqual(activity.Id, decision.ActivityId);
        }

        [Test]
        public async Task Decision_ByState_Basic()
        {
            var activity = new Activity()
            {
                DepartmentId = 56,
                EmployeeId = "11771",
                Type = ActivityType.Other,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                Detail = new ActivityDetail()
                {
                    AccountStatus = "ACT"
                },
                State = ActivityState.Created
            };
            var pagedResult = new PagedResult<Activity>()
            {
                Total = 1,
                Items = new List<Activity>() { activity }
            };
            Mock.Get(_activityService).Setup(x => x.ListByFilterAsync(It.IsAny<ActivityFilter>()))
                .ReturnsAsync(pagedResult);
            Mock.Get(_activityService).Setup(x => x.ApplyStateChange(It.IsAny<ActivityStateChange>(),true))
                .Verifiable();

            var changes = await _activityDecisionService.DecisionActivityByState(ActivityState.Created);

            Assert.NotNull(changes);
            Assert.IsNotEmpty(changes);
            var decision = changes.FirstOrDefault();
            Assert.NotNull(decision);
            Assert.AreNotEqual(activity.State, decision.State);
            Assert.AreEqual(ActivityState.Accepted, decision.State);
            Assert.AreEqual(activity.Id, decision.ActivityId);

            Mock.Get(_activityService).Verify(x => x.ListByFilterAsync(It.IsAny<ActivityFilter>()), Times.Once);
            Mock.Get(_activityService).Verify(x => x.ApplyStateChange(It.IsAny<ActivityStateChange>(),true), Times.Once);
        }

        [Test]
        public async Task Decision_ManualReview_Basic()
        {
            var activity = new Activity()
            {
                DepartmentId = 56,
                EmployeeId = "11771",
                Type = ActivityType.Other,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                Detail = new ActivityDetail()
                {
                    AccountStatus = "ACT"
                },
                State = ActivityState.Created
            };
            var pagedResult = new PagedResult<Activity>()
            {
                Total = 1,
                Items = new List<Activity>() { activity }
            };
            Mock.Get(_activityService).Setup(x => x.ListByFilterAsync(It.IsAny<ActivityFilter>()))
                .ReturnsAsync(pagedResult).Verifiable();
            Mock.Get(_activityDetailService)
                .Setup(x => x.TryUpdateActivityAccountDetails(It.IsAny<List<Activity>>()))
                .ReturnsAsync(new List<Activity>() { activity }).Verifiable();
            Mock.Get(_activityService).Setup(x => x.ApplyStateChange(It.IsAny<ActivityStateChange>(),true))
                .Verifiable();

            var changes = await _activityDecisionService.UpdateAndDecideManualReviewActivities();

            Assert.NotNull(changes);
            Assert.IsNotEmpty(changes);
            var decision = changes.FirstOrDefault();
            Assert.NotNull(decision);
            Assert.AreNotEqual(activity.State, decision.State);
            Assert.AreEqual(ActivityState.Accepted, decision.State);
            Assert.AreEqual(activity.Id, decision.ActivityId);

            Mock.Get(_activityService).Verify();
            Mock.Get(_activityDetailService).Verify();

            Mock.Get(_activityService).Verify(x => x.ListByFilterAsync(It.IsAny<ActivityFilter>()), Times.Once);
            Mock.Get(_activityService).Verify(x => x.ApplyStateChange(It.IsAny<ActivityStateChange>(),true), Times.Once);
        }

        [TestCase(Product.LIC, ActivityType.Sale)]
        [TestCase(Product.DirectDeposit, ActivityType.Sale)]
        [TestCase(Product.CreditCardBalanceTransfer, ActivityType.Sale)]
        public async Task Decision_Basic_NoDecision(Product product, ActivityType type)
        {
            var activity = new Activity()
            {
                DepartmentId = 56,
                EmployeeId = "11771",
                Type = type,
                Product = product,
                Accepted = DateTime.Today
            };
            var decision = await _activityDecisionService.TryDecisionActivity(activity);
            Assert.NotNull(activity);
            Assert.AreNotEqual(activity.State, decision.State);
            Assert.AreEqual(ActivityState.ManualReview, decision.State);
            Assert.AreEqual(activity.Id, decision.ActivityId);
        }

        [TestCase("APPR", ActivityState.ManualReview)]
        [TestCase("ACT", ActivityState.Accepted)]
        [TestCase("CLS", ActivityState.Rejected)]
        [TestCase("YeeHaw", ActivityState.ManualReview)]
        [TestCase(null, ActivityState.Rejected)]
        public async Task Decision_Mortgage(string status, ActivityState state)

        {
            var activity = new Activity()
            {
                DepartmentId = 56,
                EmployeeId = "11771",
                Type = ActivityType.Sale,
                Detail = new ActivityDetail()
                {
                    AccountStatus = status
                },
                Product = Product.Mortgage,
                Accepted = DateTime.Today
            };
            var decision = await _activityDecisionService.TryDecisionActivity(activity);
            Assert.NotNull(activity);
            Assert.AreEqual(state, decision.State);
            Assert.AreEqual(activity.Id, decision.ActivityId);
        }

        [TestCase(Product.ATMCard, ActivityState.PendingReferral, "60")]
        [TestCase(Product.CheckCard, ActivityState.PendingReferral, "60")]
        [TestCase(Product.NewChecking, ActivityState.PendingReferral, "60")]
        [TestCase(Product.Mortgage, ActivityState.PendingReferral, "60")]
        [TestCase(Product.FirstMortgageReferral, ActivityState.PendingReferral, "120")]
        [TestCase(Product.DirectDeposit, ActivityState.PendingReferral, "60")]
        [TestCase(Product.CreditCardBalanceTransfer, ActivityState.PendingReferral, "60")]
        [TestCase(Product.LIC, ActivityState.ManualReview, "Not In Final Station")]
        public async Task Decision_Referrals(Product product, ActivityState expectedState, string expectedExpirationDays)
        {
            var activity = new Activity()
            {
                DepartmentId = 56,
                EmployeeId = "11771",
                Type = ActivityType.Referral,
                Product = product,
                Accepted = DateTime.Today,
                Detail = new ActivityDetail()
            };
            var decision = await _activityDecisionService.TryDecisionActivity(activity);
            Assert.NotNull(activity);
            Assert.AreEqual(expectedState, decision.State);
            Assert.AreEqual(activity.Id, decision.ActivityId);
            Assert.IsTrue(decision.Note.Contains(expectedExpirationDays));
        }

        [TestCase(null, ActivityState.ManualReview)]
        [TestCase("NotRealStation", ActivityState.ManualReview)]
        [TestCase("LIC Referral-Qualified", ActivityState.Accepted)]
        [TestCase("LIC Referral- Not Qualified", ActivityState.Rejected)]
        public async Task Decision_LIC_Referrals(String stationName, ActivityState expectedState)
        {
            var activity = new Activity()
            {
                DepartmentId = 56,
                EmployeeId = "11771",
                Type = ActivityType.Referral,
                Product = Product.LIC,
                Accepted = DateTime.Today,
                Detail = new ActivityDetail()
                {
                    StationName = stationName
                }
            };
            var decision = await _activityDecisionService.TryDecisionActivity(activity);
            Assert.NotNull(activity);
            Assert.AreEqual(expectedState, decision.State);
            Assert.AreEqual(activity.Id, decision.ActivityId);
        }

        [TestCase(Product.GAPInsurance)]
        [TestCase(Product.MechanicalBreakdownProtection)]
        [TestCase(Product.DebtProtectionEligibleLoan)]
        [TestCase(Product.Vehicle)]
        [TestCase(Product.CreditCard)]
        public void Decision_Referrals_Throws(Product product)
        {
            var activity = new Activity()
            {
                DepartmentId = 56,
                EmployeeId = "11771",
                Type = ActivityType.Referral,
                Product = product,
                Accepted = DateTime.Today
            };
            Assert.ThrowsAsync<NoAvailableDecisionStrategy>(async () => await _activityDecisionService.TryDecisionActivity(activity));
        }


        [TestCase(Product.ATMCard, "ACT", ActivityState.Accepted)]
        [TestCase(Product.CheckCard, "ACT", ActivityState.Accepted)]
        [TestCase(Product.ATMCard, "APPR", ActivityState.Accepted)]
        [TestCase(Product.CheckCard, "APPR", ActivityState.Accepted)]
        [TestCase(Product.ATMCard, "ORIG", ActivityState.Accepted)]
        [TestCase(Product.CheckCard, "ORIG", ActivityState.Accepted)]
        [TestCase(Product.ATMCard, "CLS", ActivityState.Accepted)]
        [TestCase(Product.CheckCard, "CLS", ActivityState.Accepted)]
        public async Task Decision_Cards(Product product, string status, ActivityState state)
        {
            var activity = new Activity()
            {
                DepartmentId = 56,
                EmployeeId = "11771",
                Type = ActivityType.Other,
                Detail = new ActivityDetail()
                {
                    AccountStatus = status
                },
                Product = product,
                Accepted = DateTime.Today
            };
            var decision = await _activityDecisionService.TryDecisionActivity(activity);
            Assert.NotNull(activity);
            Assert.AreEqual(state, decision.State);
            Assert.AreEqual(activity.Id, decision.ActivityId);
        }

        [TestCase("ACT", ActivityState.Accepted)]
        [TestCase("APPR", ActivityState.ManualReview)]
        [TestCase("ORIG", ActivityState.ManualReview)]
        [TestCase("CLS", ActivityState.Rejected)]
        [TestCase(null, ActivityState.Rejected)]
        public async Task Decision_NewChecking(string status, ActivityState state)
        {
            var activity = new Activity()
            {
                DepartmentId = 56,
                EmployeeId = "11771",
                Type = ActivityType.Sale,
                Detail = new ActivityDetail()
                {
                    AccountStatus = status
                },
                Product = Product.NewChecking,
                Accepted = DateTime.Today
            };
            var decision = await _activityDecisionService.TryDecisionActivity(activity);
            Assert.NotNull(activity);
            Assert.AreEqual(state, decision.State);
            Assert.AreEqual(activity.Id, decision.ActivityId);
        }

        [TestCase("ACT", ActivityState.Accepted)]
        [TestCase("APPR", ActivityState.ManualReview)]
        [TestCase("ORIG", ActivityState.ManualReview)]
        [TestCase("CLS", ActivityState.Rejected)]
        [TestCase(null, ActivityState.Rejected)]
        public async Task Decision_NewDigitalBankingChecking(string status, ActivityState state)
        {
            var activity = new Activity()
            {
                DepartmentId = 43,
                EmployeeId = "DigitalBankingAppUserEmployeeId",
                Type = ActivityType.Sale,
                Detail = new ActivityDetail()
                {
                    AccountStatus = status
                },
                Product = Product.NewChecking,
                Accepted = DateTime.Today
            };
            var decision = await _activityDecisionService.TryDecisionActivity(activity);
            Assert.NotNull(activity);
            Assert.AreEqual(state, decision.State);
            Assert.AreEqual(activity.Id, decision.ActivityId);
        }

        [TestCase("ACT", ActivityState.Accepted)]
        [TestCase("APPR", ActivityState.ManualReview)]
        [TestCase("CLS", ActivityState.Rejected)]
        [TestCase("ORIG", ActivityState.ManualReview)]
        [TestCase(null, ActivityState.Rejected)]
        public async Task Decision_Vehicle(string status, ActivityState state)
        {
            var activity = new Activity()
            {
                DepartmentId = 56,
                EmployeeId = "11771",
                Type = ActivityType.Sale,
                Detail = new ActivityDetail()
                {
                    AccountStatus = status
                },
                Product = Product.Vehicle,
                Accepted = DateTime.Today
            };
            var decision = await _activityDecisionService.TryDecisionActivity(activity);
            Assert.NotNull(activity);
            Assert.AreEqual(state, decision.State);
            Assert.AreEqual(activity.Id, decision.ActivityId);
        }

        [TestCase("ACT", ActivityState.Accepted)]
        [TestCase("APPR", ActivityState.ManualReview)]
        [TestCase("CLS", ActivityState.Rejected)]
        [TestCase("ORIG", ActivityState.ManualReview)]
        [TestCase(null, ActivityState.Rejected)]
        public async Task Decision_DPEligibleLoan(string status, ActivityState state)
        {
            var activity = new Activity()
            {
                DepartmentId = 56,
                EmployeeId = "11771",
                Type = ActivityType.Sale,
                Detail = new ActivityDetail()
                {
                    AccountStatus = status
                },
                Product = Product.DebtProtectionEligibleLoan,
                Accepted = DateTime.Today
            };
            var decision = await _activityDecisionService.TryDecisionActivity(activity);
            Assert.NotNull(activity);
            Assert.AreEqual(state, decision.State);
            Assert.AreEqual(activity.Id, decision.ActivityId);
        }

        [Test]
        public async Task UpdateAndDecideDirectDepositPendingReferralActivities_OK()
        {
            var activity = new Activity
            {
                Id = 123,
                DepartmentId = 56,
                EmployeeId = "11771",
                Type = ActivityType.Referral,
                Detail = new ActivityDetail
                {
                    AccountNumber = "12345"
                },
                Created = DateTime.Parse("2021/11/23 10:00:00"),
                Product = Product.DebtProtectionEligibleLoan,
                Accepted = DateTime.Today
            };

            var pagedResult = new PagedResult<Activity>
            {
                Items = new[]
                {
                    activity
                }
            };

            Mock.Get(_activityService).Setup(x => x.ListByFilterAsync(It.Is<ActivityFilter>(x =>
                    x.Limit.Equals(1000) && x.State.Contains(ActivityState.PendingReferral) && x.Product.Contains(Product.DirectDeposit))))
                .ReturnsAsync(pagedResult).Verifiable();

            Mock.Get(_dnaService).Setup(x => x.GetTransactionHistory(It.Is<string>(x => x.Equals("12345")),
                    It.Is<DateTime>(x => x.Equals(DateTime.Parse("2021/11/23 10:00:00"))), It.IsAny<DateTime>(), It.Is<List<string>>(x => x.Contains("XDEP"))))
                .ReturnsAsync(new List<TransactionHistory>
                {
                    new TransactionHistory
                    {
                        Id = "1"
                    }
                }).Verifiable();

            var decision = await _activityDecisionService.UpdateAndDecideDirectDepositPendingReferralActivities();

            Mock.Get(_activityService).Verify();
            Mock.Get(_dnaService).Verify();
            Assert.NotNull(decision);
            var firstDecision = decision.First();
            Assert.AreEqual(ActivityState.Accepted, firstDecision.State);
            Assert.AreEqual(123, firstDecision.ActivityId);
        }

        [Test]
        public async Task UpdateAndDecideDirectDepositPendingReferralActivities_NullReturned_RejectActivity()
        {
            var activity = new Activity
            {
                Id = 123,
                DepartmentId = 56,
                EmployeeId = "11771",
                Type = ActivityType.Referral,
                Detail = new ActivityDetail
                {
                    AccountNumber = "12345"
                },
                Created = DateTime.Parse("2021/11/23 10:00:00"),
                Product = Product.DebtProtectionEligibleLoan,
                Accepted = DateTime.Today
            };

            var pagedResult = new PagedResult<Activity>
            {
                Items = new[]
                {
                    activity
                }
            };

            Mock.Get(_activityService).Setup(x => x.ListByFilterAsync(It.Is<ActivityFilter>(x =>
                    x.Limit.Equals(1000) && x.State.Contains(ActivityState.PendingReferral) && x.Product.Contains(Product.DirectDeposit))))
                .ReturnsAsync(pagedResult).Verifiable();

            Mock.Get(_dnaService).Setup(x => x.GetTransactionHistory(It.Is<string>(x => x.Equals("12345")),
                    It.Is<DateTime>(x => x.Equals(DateTime.Parse("2021/11/23 10:00:00"))), It.IsAny<DateTime>(), It.Is<List<string>>(x => x.Contains("XDEP"))))
                .ReturnsAsync((List<TransactionHistory>)null).Verifiable();

            var decision = await _activityDecisionService.UpdateAndDecideDirectDepositPendingReferralActivities();

            Mock.Get(_activityService).Verify();
            Mock.Get(_dnaService).Verify();
            Assert.NotNull(decision);
            var firstDecision = decision.First();
            Assert.AreEqual(ActivityState.Rejected, firstDecision.State);
            Assert.AreEqual(123, firstDecision.ActivityId);
        }

        [Test]
        public async Task UpdateAndDecideDirectDepositPendingReferralActivities_None_NoActivitiesReturned()
        {
            var pagedResult = new PagedResult<Activity>();

            Mock.Get(_activityService).Setup(x => x.ListByFilterAsync(It.Is<ActivityFilter>(x =>
                    x.Limit.Equals(1000) && x.State.Contains(ActivityState.PendingReferral) && x.Product.Contains(Product.DirectDeposit))))
                .ReturnsAsync(pagedResult).Verifiable();

            var decision = await _activityDecisionService.UpdateAndDecideDirectDepositPendingReferralActivities();

            Mock.Get(_activityService).Verify();
            Mock.Get(_dnaService).Verify(x => x.GetTransactionHistory(It.IsAny<string>(), It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<List<string>>()),
                Times.Never);
            Assert.IsEmpty(decision);
        }

        [Test]
        public async Task UpdateAndDecideDirectDepositPendingReferralActivities_Empty_NoActivitiesReturned()
        {
            var pagedResult = new PagedResult<Activity>
            {
                Items = new Activity[] { }
            };

            Mock.Get(_activityService).Setup(x => x.ListByFilterAsync(It.Is<ActivityFilter>(x =>
                    x.Limit.Equals(1000) && x.State.Contains(ActivityState.PendingReferral) && x.Product.Contains(Product.DirectDeposit))))
                .ReturnsAsync(pagedResult).Verifiable();

            var decision = await _activityDecisionService.UpdateAndDecideDirectDepositPendingReferralActivities();

            Mock.Get(_activityService).Verify();
            Mock.Get(_dnaService).Verify(x => x.GetTransactionHistory(It.IsAny<string>(), It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<List<string>>()),
                Times.Never);
            Assert.IsEmpty(decision);
        }

        [Test]
        public async Task UpdateAndDecideDpEligibleLoanActivities_NoPagedResults_Ok()
        {
            var activity = new Activity
            {
                Id = 123,
                DepartmentId = 56,
                EmployeeId = "11771",
                Type = ActivityType.Sale,
                MatchingDpAccessoryActivityId = 0,

                Detail = new ActivityDetail
                {
                    AccountNumber = "12345",
                    DebtProtectionAddDate = DateTime.UtcNow, 
                    IsDebtProtectionEligible = true,
                    IsGapInsuranceEligible = true
                },
                Created = DateTime.Parse("2021/11/23 10:00:00"),
                Product = Product.Vehicle,
                Accepted = DateTime.Today
            };

            var pagedResult = new PagedResult<Activity>
            {
                Items = null,
                Total = 0
            };

            Mock.Get(_activityService).Setup(x => x.ListByFilterAsync(It.Is<ActivityFilter>(x =>
            x.Limit.Equals(1000) && x.State.Contains(ActivityState.Accepted) && x.Product.Contains(Product.Vehicle))))
            .ReturnsAsync(pagedResult).Verifiable();

            Mock.Get(_activityDetailService).Setup(x => x.TryUpdateActivityAccountDetails(It.IsAny<List<Activity>>()))
              .ReturnsAsync(new List<Activity>() { activity }).Verifiable();

            Mock.Get(_activityDetailService).Setup(x => x.TryUpdateDpEligibleLoanDetail(It.IsAny<List<Activity>>()))
            .ReturnsAsync(new List<Activity>() { activity }).Verifiable();

            var decision = await _activityDecisionService.UpdateAndDecideDpEligibleLoanActivities();

            Mock.Get(_activityService).Verify();
            Mock.Get(_dnaService)
                .Verify(x => x.GetTransactionHistory(It.IsAny<string>(), It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<List<string>>()),
                Times.Never);
            Assert.IsEmpty(decision);
        }

        [Test]
        public async Task UpdateAndDecideDpEligibleLoanActivities_GapInsuranceWasEligible_DebtProtectionAdded()
        {
            var activity = new Activity
            {
                Id = 123,
                DepartmentId = 56,
                EmployeeId = "11771",
                Type = ActivityType.Sale,
                MatchingDpAccessoryActivityId = 0,
                
                Detail = new ActivityDetail
                {
                    AccountNumber = "12345",
                    DebtProtectionAddDate = DateTime.UtcNow, 
                    IsDebtProtectionEligible = true,
                    IsGapInsuranceEligible = true
                },
                Created = DateTime.Parse("2021/11/23 10:00:00"),
                Product = Product.Vehicle,
                Accepted = DateTime.Today
            };

            var pagedResult = new PagedResult<Activity>
            {
                Items = new[]
                {
                    activity
                },
                Total = 1
            };

            Mock.Get(_activityService).Setup(x => x.ListByFilterAsync(It.Is<ActivityFilter>(x =>
            x.Limit.Equals(1000) && x.State.Contains(ActivityState.Accepted) && x.Product.Contains(Product.Vehicle))))
            .ReturnsAsync(pagedResult).Verifiable();

            Mock.Get(_activityDetailService).Setup(x => x.TryUpdateActivityAccountDetails(It.IsAny<List<Activity>>()))
              .ReturnsAsync(new List<Activity>() { activity }).Verifiable();

            Mock.Get(_activityDetailService).Setup(x => x.TryUpdateDpEligibleLoanDetail(It.IsAny<List<Activity>>()))
            .ReturnsAsync(new List<Activity>() { activity }).Verifiable();

            var decision = await _activityDecisionService.UpdateAndDecideDpEligibleLoanActivities();
            
            Mock.Get(_activityService).Verify();
            Mock.Get(_dnaService)
                .Verify(x => x.GetTransactionHistory(It.IsAny<string>(), It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<List<string>>()),
                Times.Never);
            Assert.NotNull(decision);
        }

        [Test]
        public async Task UpdateAndDecideDpEligibleLoanActivities_GapInsuranceWasNotEligible_DebtProtectionAdded()
        {
            var activity = new Activity
            {
                Id = 123,
                DepartmentId = 56,
                EmployeeId = "11771",
                Type = ActivityType.Sale,
                MatchingDpAccessoryActivityId = 0,

                Detail = new ActivityDetail
                {
                    AccountNumber = "12345",
                    DebtProtectionAddDate = DateTime.UtcNow, 
                    IsDebtProtectionEligible = true,
                    IsGapInsuranceEligible = false
                },
                Created = DateTime.Parse("2021/11/23 10:00:00"),
                Product = Product.Vehicle,
                Accepted = DateTime.Today
            };

            var pagedResult = new PagedResult<Activity>
            {
                Items = new[]
                {
                    activity
                },
                Total = 1
            };

            Mock.Get(_activityService).Setup(x => x.ListByFilterAsync(It.Is<ActivityFilter>(x =>
                    x.Limit.Equals(1000) && x.State.Contains(ActivityState.Accepted) && x.Product.Contains(Product.Vehicle))))
                .ReturnsAsync(pagedResult).Verifiable();

            Mock.Get(_activityDetailService).Setup(x => x.TryUpdateActivityAccountDetails(It.IsAny<List<Activity>>()))
              .ReturnsAsync(new List<Activity>() { activity }).Verifiable();

            Mock.Get(_activityDetailService).Setup(x => x.TryUpdateDpEligibleLoanDetail(It.IsAny<List<Activity>>()))
           .ReturnsAsync(new List<Activity>() { activity }).Verifiable();

            var decision = await _activityDecisionService.UpdateAndDecideDpEligibleLoanActivities();

            Mock.Get(_activityService).Verify();
            Mock.Get(_dnaService).Verify(x => x.GetTransactionHistory(It.IsAny<string>(), It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<List<string>>()),
                Times.Never);
            Assert.NotNull(decision);
        }
    }
}