using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using LCU.Api.Internal.CoreApiWrapper.Services;
using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Activity;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Tax;
using LCU.Library.Internal.CoreApiWrapperModel.LcuModels.Activity;
using LCU.Library.Internal.Exceptions;
using Moq;
using NUnit.Framework;
using FailedToParseException = LCU.Library.Internal.CoreApiWrapperLib.Exceptions.FailedToParseException;

namespace LCU.Api.Internal.CoreApiWrapperTest.Service
{
    public class ActivityServiceTest
    {
        private ActivityService _activityService;
        private Mock<ITaxService> _mockTaxService;
        private Mock<IActivityDao> _mockActivityDao;

        [SetUp]
        public void SetUp()
        {
            _mockActivityDao = new Mock<IActivityDao>();
            _mockTaxService = new Mock<ITaxService>();
            _activityService = new ActivityService(_mockActivityDao.Object, _mockTaxService.Object);

            _mockActivityDao.Setup(x => x.GetNewCheckingActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>())).ReturnsAsync(
                new List<NewCheckingAccountActivity>()
                {
                    new NewCheckingAccountActivity() { ActivityNbr = 1 },
                    new NewCheckingAccountActivity() { ActivityNbr = 2 },
                    new NewCheckingAccountActivity() { ActivityNbr = 3 }
                }).Verifiable();

            _mockActivityDao.Setup(x => x.GetNewCheckingActivitiesNewerThanDate(It.IsAny<DateTime>(), It.IsAny<int>())).ReturnsAsync(
                new List<NewCheckingAccountActivity>()
                {
                    new NewCheckingAccountActivity() { ActivityNbr = 1 },
                    new NewCheckingAccountActivity() { ActivityNbr = 2 },
                    new NewCheckingAccountActivity() { ActivityNbr = 3 }
                }).Verifiable();


            _mockActivityDao.Setup(x => x.GetNewCheckingActivitiesAfterActivityNbr(It.IsAny<long>(), It.IsAny<int>())).ReturnsAsync(
                new List<NewCheckingAccountActivity>()
                {
                    new NewCheckingAccountActivity() { ActivityNbr = 1 },
                    new NewCheckingAccountActivity() { ActivityNbr = 2 },
                    new NewCheckingAccountActivity() { ActivityNbr = 3 }
                }).Verifiable();

            _mockActivityDao.Setup(x => x.GetNewAtmCheckCardActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>())).ReturnsAsync(
                new List<NewAtmCheckCardActivity>()
                {
                    new NewAtmCheckCardActivity() { ActivityNbr = 1 },
                    new NewAtmCheckCardActivity() { ActivityNbr = 2 },
                    new NewAtmCheckCardActivity() { ActivityNbr = 3 }
                }).Verifiable();

            _mockActivityDao.Setup(x => x.GetNewAtmCheckCardActivitiesNewerThanDate(It.IsAny<DateTime>(), It.IsAny<int>())).ReturnsAsync(
                new List<NewAtmCheckCardActivity>()
                {
                    new NewAtmCheckCardActivity() { ActivityNbr = 1 },
                    new NewAtmCheckCardActivity() { ActivityNbr = 2 },
                    new NewAtmCheckCardActivity() { ActivityNbr = 3 }
                }).Verifiable();


            _mockActivityDao.Setup(x => x.GetNewAtmCheckCardActivitiesAfterActivityNbr(It.IsAny<long>(), It.IsAny<int>())).ReturnsAsync(
                new List<NewAtmCheckCardActivity>()
                {
                    new NewAtmCheckCardActivity() { ActivityNbr = 1 },
                    new NewAtmCheckCardActivity() { ActivityNbr = 2 },
                    new NewAtmCheckCardActivity() { ActivityNbr = 3 }
                }).Verifiable();

            _mockActivityDao.Setup(x => x.GetNewActivityManagerReferrals(It.IsAny<DateTime>(), It.IsAny<long>())).ReturnsAsync(
                new List<NewActivityManagerIncentiveReferral>()
                {
                    new NewActivityManagerIncentiveReferral() { ActivityId = 1 },
                    new NewActivityManagerIncentiveReferral() { ActivityId = 2 },
                    new NewActivityManagerIncentiveReferral() { ActivityId = 3 }
                }).Verifiable();

            _mockActivityDao.Setup(x => x.QueryActivityManagerActivity(It.IsAny<ActivityQueryRequest>())).ReturnsAsync(
                new List<NewActivityManagerIncentiveReferral>()
                {
                    new NewActivityManagerIncentiveReferral() { ActivityId = 1 },
                    new NewActivityManagerIncentiveReferral() { ActivityId = 2 },
                    new NewActivityManagerIncentiveReferral() { ActivityId = 3 }
                }).Verifiable();

            _mockActivityDao.Setup(x => x.GetNewActivityManagerReferralsNewerThan(It.IsAny<DateTime>())).ReturnsAsync(
                new List<NewActivityManagerIncentiveReferral>()
                {
                    new NewActivityManagerIncentiveReferral() { ActivityId = 1 },
                    new NewActivityManagerIncentiveReferral() { ActivityId = 2 },
                    new NewActivityManagerIncentiveReferral() { ActivityId = 3 }
                }).Verifiable();


            _mockActivityDao.Setup(x => x.GetNewActivityManagerReferralsAfterActivityId(It.IsAny<long>())).ReturnsAsync(
                new List<NewActivityManagerIncentiveReferral>()
                {
                    new NewActivityManagerIncentiveReferral() { ActivityId = 1 },
                    new NewActivityManagerIncentiveReferral() { ActivityId = 2 },
                    new NewActivityManagerIncentiveReferral() { ActivityId = 3 }
                }).Verifiable();

            _mockActivityDao.Setup(x => x.GetNewMortgageSaleActivities(It.IsAny<DateTime?>(), It.IsAny<long?>())).ReturnsAsync(
                new List<NewLoanSaleActivity>()
                {
                    new NewLoanSaleActivity() { ActivityNbr = 1 },
                    new NewLoanSaleActivity() { ActivityNbr = 2 },
                    new NewLoanSaleActivity() { ActivityNbr = 3 }
                }).Verifiable();

            _mockActivityDao.Setup(x => x.GetNewVehicleSaleActivities(It.IsAny<DateTime?>(), It.IsAny<long?>())).ReturnsAsync(
                new List<NewLoanSaleActivity>()
                {
                    new NewLoanSaleActivity() { ActivityNbr = 1 },
                    new NewLoanSaleActivity() { ActivityNbr = 2 },
                    new NewLoanSaleActivity() { ActivityNbr = 3 }
                }).Verifiable();

            _mockActivityDao.Setup(x => x.GetNewDebtProtectedLoanSaleActivities(It.IsAny<DateTime?>(), It.IsAny<long?>())).ReturnsAsync(
                new List<NewLoanSaleActivity>()
                {
                    new NewLoanSaleActivity() { ActivityNbr = 1 },
                    new NewLoanSaleActivity() { ActivityNbr = 2 },
                    new NewLoanSaleActivity() { ActivityNbr = 3 }
                }).Verifiable();

            _mockActivityDao.Setup(x => x.GetEStatementDeliveryActivity(It.IsAny<DateTime?>())).ReturnsAsync(
             new List<EStatementDeliveryMethod>()
             {
                    new EStatementDeliveryMethod() { ActivityNumber = 1 },
                    new EStatementDeliveryMethod() { ActivityNumber = 2 },
                    new EStatementDeliveryMethod() { ActivityNumber = 3 }
             }).Verifiable();
        }

        [Test]
        public async Task GetNewCheckingAccountActivities_Both_Ok()
        {
            var results = await _activityService.GetNewCheckingAccountActivities("2020-04-15T11:00:00", 5, 100);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.True(results.Any(x => x.ActivityNbr == 1));
            Assert.True(results.Any(x => x.ActivityNbr == 2));
            Assert.True(results.Any(x => x.ActivityNbr == 3));

            _mockActivityDao.Verify(x =>
                x.GetNewCheckingActivities(
                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
                    It.Is<long>(actvnbr => actvnbr == 5), 100));

            _mockActivityDao.Verify(x => x.GetNewCheckingActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>()), Times.Once);
            _mockActivityDao.Verify(x => x.GetNewCheckingActivitiesAfterActivityNbr(It.IsAny<long>(), It.IsAny<int>()), Times.Never);
            _mockActivityDao.Verify(x => x.GetNewCheckingActivitiesNewerThanDate(It.IsAny<DateTime>(), It.IsAny<int>()), Times.Never);
        }

        [Test]
        public async Task GetNewCheckingAccountActivities_No_ActvNbr_Ok()
        {
            var results = await _activityService.GetNewCheckingAccountActivities("2020-04-15T11:00:00", null, 100);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.True(results.Any(x => x.ActivityNbr == 1));
            Assert.True(results.Any(x => x.ActivityNbr == 2));
            Assert.True(results.Any(x => x.ActivityNbr == 3));

            _mockActivityDao.Verify(x =>
                x.GetNewCheckingActivitiesNewerThanDate(
                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0), 100));

            _mockActivityDao.Verify(x => x.GetNewCheckingActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>()), Times.Never);
            _mockActivityDao.Verify(x => x.GetNewCheckingActivitiesAfterActivityNbr(It.IsAny<long>(), It.IsAny<int>()), Times.Never);
            _mockActivityDao.Verify(x => x.GetNewCheckingActivitiesNewerThanDate(It.IsAny<DateTime>(), It.IsAny<int>()), Times.Once);
        }

        [Test]
        public async Task GetNewCheckingAccountActivities_No_Date_Ok()
        {
            var results = await _activityService.GetNewCheckingAccountActivities(null, 5, 100);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.True(results.Any(x => x.ActivityNbr == 1));
            Assert.True(results.Any(x => x.ActivityNbr == 2));
            Assert.True(results.Any(x => x.ActivityNbr == 3));

            _mockActivityDao.Verify(x => x.GetNewCheckingActivitiesAfterActivityNbr(It.Is<long>(nbr => nbr == 5), 100));
        }

        [Test]
        public async Task GetNewCheckingAccountActivities_No_Params_Exception()
        {
            Assert.ThrowsAsync<Exception>(async () =>
                await _activityService.GetNewCheckingAccountActivities(null, null, 100));
        }

        [Test]
        public async Task GetNewCheckingAccountActivities_FailedToParse_BadDateTime()
        {
            Assert.ThrowsAsync<FailedToParseException>(async () =>
                await _activityService.GetNewCheckingAccountActivities("DateTimes are a Devs Best Friend", 1, 100));

            Assert.ThrowsAsync<FailedToParseException>(async () =>
                await _activityService.GetNewCheckingAccountActivities("DateTimes are a Devs Best Friend", null, 100));
        }

        [Test]
        public async Task GetNewCheckingAccountActivities_Exception()
        {
            _mockActivityDao.Setup(x => x.GetNewCheckingActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>())).Throws(new Exception("Oops"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityService.GetNewCheckingAccountActivities("2020-04-15T11:00:00", 10, 100));
        }

        [Test]
        public async Task GetNewAtmCheckCardActivities_Both_Ok()
        {
            var results = await _activityService.GetNewAtmCheckCardActivities("2020-04-15T11:00:00", 5, 100);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.True(results.Any(x => x.ActivityNbr == 1));
            Assert.True(results.Any(x => x.ActivityNbr == 2));
            Assert.True(results.Any(x => x.ActivityNbr == 3));

            _mockActivityDao.Verify(x =>
                x.GetNewAtmCheckCardActivities(
                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
                    It.Is<long>(actvnbr => actvnbr == 5), 100));

            _mockActivityDao.Verify(x => x.GetNewAtmCheckCardActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>()), Times.Once);
            _mockActivityDao.Verify(x => x.GetNewAtmCheckCardActivitiesAfterActivityNbr(It.IsAny<long>(), It.IsAny<int>()), Times.Never);
            _mockActivityDao.Verify(x => x.GetNewAtmCheckCardActivitiesNewerThanDate(It.IsAny<DateTime>(), It.IsAny<int>()), Times.Never);
        }

        [Test]
        public async Task GetNewAtmCheckCardActivities_No_ActvNbr_Ok()
        {
            var results = await _activityService.GetNewAtmCheckCardActivities("2020-04-15T11:00:00", null, 100);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.True(results.Any(x => x.ActivityNbr == 1));
            Assert.True(results.Any(x => x.ActivityNbr == 2));
            Assert.True(results.Any(x => x.ActivityNbr == 3));

            _mockActivityDao.Verify(x =>
                x.GetNewAtmCheckCardActivitiesNewerThanDate(
                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0), 100));

            _mockActivityDao.Verify(x => x.GetNewAtmCheckCardActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>()), Times.Never);
            _mockActivityDao.Verify(x => x.GetNewAtmCheckCardActivitiesAfterActivityNbr(It.IsAny<long>(), It.IsAny<int>()), Times.Never);
            _mockActivityDao.Verify(x => x.GetNewAtmCheckCardActivitiesNewerThanDate(It.IsAny<DateTime>(), It.IsAny<int>()), Times.Once);
        }

        [Test]
        public async Task GetNewAtmCheckCardActivities_No_Date_Ok()
        {
            var results = await _activityService.GetNewAtmCheckCardActivities(null, 5, 100);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.True(results.Any(x => x.ActivityNbr == 1));
            Assert.True(results.Any(x => x.ActivityNbr == 2));
            Assert.True(results.Any(x => x.ActivityNbr == 3));

            _mockActivityDao.Verify(x => x.GetNewAtmCheckCardActivitiesAfterActivityNbr(It.Is<long>(nbr => nbr == 5), 100));
        }

        [Test]
        public async Task GetNewAtmCheckCardActivities_No_Params_Exception()
        {
            Assert.ThrowsAsync<Exception>(async () =>
                await _activityService.GetNewAtmCheckCardActivities(null, null, 100));
        }

        [Test]
        public async Task GetNewAtmCheckCardActivities_FailedToParse_BadDateTime()
        {
            Assert.ThrowsAsync<FailedToParseException>(async () =>
                await _activityService.GetNewAtmCheckCardActivities("DateTimes are a Devs Best Friend", 1, 100));

            Assert.ThrowsAsync<FailedToParseException>(async () =>
                await _activityService.GetNewAtmCheckCardActivities("DateTimes are a Devs Best Friend", null, 100));
        }

        [Test]
        public async Task GetNewAtmCheckCardActivities_Exception()
        {
            _mockActivityDao.Setup(x => x.GetNewAtmCheckCardActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>())).Throws(new Exception("Oops"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityService.GetNewAtmCheckCardActivities("2020-04-15T11:00:00", 10, 100));
        }

        [Test]
        public async Task GetNewEDeliveryStatementSaleActivities_Ok()
        {
            var results = await _activityService.GetEStatementDeliveryActivity("2020-04-15T11:00:00");

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.True(results.Any(x => x.ActivityNumber == 1));
            Assert.True(results.Any(x => x.ActivityNumber == 2));
            Assert.True(results.Any(x => x.ActivityNumber == 3));

            _mockActivityDao.Verify(x =>
                x.GetEStatementDeliveryActivity(
                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0)
                    ));

            _mockActivityDao.Verify(x => x.GetEStatementDeliveryActivity(It.IsAny<DateTime>()), Times.Once);
        }

        [Test]
        public async Task GetNewEDeliveryStatementSaleActivities_Exception()
        {
            _mockActivityDao.Setup(x => x.GetEStatementDeliveryActivity(It.IsAny<DateTime>())).Throws(new Exception("Oops"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityService.GetEStatementDeliveryActivity("2020-04-15T11:00:00"));
        }

        [Test]
        public async Task GetNewActivityManagerIncentiveReferrals_Both_Ok()
        {
            var results = await _activityService.GetNewActivityManagerIncentiveReferrals("2020-04-15T11:00:00", 5);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.True(results.Any(x => x.ActivityId == 1));
            Assert.True(results.Any(x => x.ActivityId == 2));
            Assert.True(results.Any(x => x.ActivityId == 3));

            _mockActivityDao.Verify(x =>
                x.GetNewActivityManagerReferrals(
                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
                    It.Is<long>(actvnbr => actvnbr == 5)));

            _mockActivityDao.Verify(x => x.GetNewActivityManagerReferrals(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Once);
            _mockActivityDao.Verify(x => x.GetNewActivityManagerReferralsAfterActivityId(It.IsAny<long>()), Times.Never);
            _mockActivityDao.Verify(x => x.GetNewActivityManagerReferralsNewerThan(It.IsAny<DateTime>()), Times.Never);
        }

        [Test]
        public async Task GetNewActivityManagerIncentiveReferrals_No_ActvNbr_Ok()
        {
            var results = await _activityService.GetNewActivityManagerIncentiveReferrals("2020-04-15T11:00:00", null);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.True(results.Any(x => x.ActivityId == 1));
            Assert.True(results.Any(x => x.ActivityId == 2));
            Assert.True(results.Any(x => x.ActivityId == 3));

            _mockActivityDao.Verify(x =>
                x.GetNewActivityManagerReferralsNewerThan(
                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0)));

            _mockActivityDao.Verify(x => x.GetNewActivityManagerReferrals(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Never);
            _mockActivityDao.Verify(x => x.GetNewActivityManagerReferralsAfterActivityId(It.IsAny<long>()), Times.Never);
            _mockActivityDao.Verify(x => x.GetNewActivityManagerReferralsNewerThan(It.IsAny<DateTime>()), Times.Once);
        }

        [Test]
        public async Task GetNewActivityManagerIncentiveReferrals_No_Date_Ok()
        {
            var results = await _activityService.GetNewActivityManagerIncentiveReferrals(null, 5);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.True(results.Any(x => x.ActivityId == 1));
            Assert.True(results.Any(x => x.ActivityId == 2));
            Assert.True(results.Any(x => x.ActivityId == 3));

            _mockActivityDao.Verify(x =>
                x.GetNewActivityManagerReferralsAfterActivityId(
                    It.Is<long>(nbr => nbr == 5)));
        }

        [Test]
        public async Task GetNewActivityManagerIncentiveReferrals_No_Params_Exception()
        {
            Assert.ThrowsAsync<Exception>(async () =>
                await _activityService.GetNewActivityManagerIncentiveReferrals(null, null));
        }

        [Test]
        public async Task GetNewActivityManagerIncentiveReferrals_FailedToParse_BadDateTime()
        {
            Assert.ThrowsAsync<FailedToParseException>(async () =>
                await _activityService.GetNewActivityManagerIncentiveReferrals("DateTimes are a Devs Best Friend", 1));

            Assert.ThrowsAsync<FailedToParseException>(async () =>
                await _activityService.GetNewActivityManagerIncentiveReferrals("DateTimes are a Devs Best Friend", null));
        }

        [Test]
        public async Task GetNewActivityManagerIncentiveReferrals_Exception()
        {
            _mockActivityDao.Setup(x => x.GetNewActivityManagerReferrals(It.IsAny<DateTime>(), It.IsAny<long>())).Throws(new Exception("Oops"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityService.GetNewActivityManagerIncentiveReferrals("2020-04-15T11:00:00", 10));
        }

        [Test]
        public async Task GetNewMortgageSalesActivities_Ok()
        {
            var results = await _activityService.GetNewMortgageSaleActivities("2020-04-15T11:00:00", 5);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.True(results.Any(x => x.ActivityNbr == 1));
            Assert.True(results.Any(x => x.ActivityNbr == 2));
            Assert.True(results.Any(x => x.ActivityNbr == 3));

            _mockActivityDao.Verify(x =>
                x.GetNewMortgageSaleActivities(
                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
                    It.Is<long>(actvnbr => actvnbr == 5)));

            _mockActivityDao.Verify(x => x.GetNewMortgageSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Once);
        }

        [Test]
        public async Task GetNewMortgageSaleActivities_No_ActvNbr_Ok()
        {
            var results = await _activityService.GetNewMortgageSaleActivities("2020-04-15T11:00:00", null);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.True(results.Any(x => x.ActivityNbr == 1));
            Assert.True(results.Any(x => x.ActivityNbr == 2));
            Assert.True(results.Any(x => x.ActivityNbr == 3));

            _mockActivityDao.Verify(x => x.GetNewMortgageSaleActivities(It.IsAny<DateTime>(), It.Is<long?>(x => x == null)), Times.Once);
        }

        [Test]
        public async Task GetNewMortgageSaleActivities_No_Date_Ok()
        {
            var results = await _activityService.GetNewMortgageSaleActivities(null, 5);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.True(results.Any(x => x.ActivityNbr == 1));
            Assert.True(results.Any(x => x.ActivityNbr == 2));
            Assert.True(results.Any(x => x.ActivityNbr == 3));

            _mockActivityDao.Verify(x => x.GetNewMortgageSaleActivities(It.Is<DateTime?>(x => x.HasValue == false), It.IsAny<long>()), Times.Once);
        }

        [Test]
        public async Task GetNewMortgageSaleActivities_No_Params_Exception()
        {
            Assert.ThrowsAsync<Exception>(async () =>
                await _activityService.GetNewMortgageSaleActivities(null, null));
        }

        [Test]
        public async Task GetNewMortgageSaleActivities_FailedToParse_BadDateTime()
        {
            Assert.ThrowsAsync<FailedToParseException>(async () =>
                await _activityService.GetNewMortgageSaleActivities("DateTimes are a Devs Best Friend", 1));

            Assert.ThrowsAsync<FailedToParseException>(async () =>
                await _activityService.GetNewMortgageSaleActivities("DateTimes are a Devs Best Friend", null));
        }

        [Test]
        public async Task GetNewMortgageSaleActivities_Exception()
        {
            _mockActivityDao.Setup(x => x.GetNewMortgageSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>())).Throws(new Exception("Oops"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityService.GetNewMortgageSaleActivities("2020-04-15T11:00:00", 10));
        }

        [Test]
        public async Task GetNewMortgageSaleActivities_Both_Ok()
        {
            var results = await _activityService.GetNewMortgageSaleActivities("2020-04-15T11:00:00", 5);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.True(results.Any(x => x.ActivityNbr == 1));
            Assert.True(results.Any(x => x.ActivityNbr == 2));
            Assert.True(results.Any(x => x.ActivityNbr == 3));

            _mockActivityDao.Verify(x =>
                x.GetNewMortgageSaleActivities(
                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
                    It.Is<long>(actvnbr => actvnbr == 5)));

            _mockActivityDao.Verify(x => x.GetNewMortgageSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Once);
        }

        [Test]
        public async Task GetNewVehicleSaleActivities_Ok()
        {
            var results = await _activityService.GetNewVehicleSaleActivities("2020-04-15T11:00:00", 5);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.True(results.Any(x => x.ActivityNbr == 1));
            Assert.True(results.Any(x => x.ActivityNbr == 2));
            Assert.True(results.Any(x => x.ActivityNbr == 3));

            _mockActivityDao.Verify(x =>
                x.GetNewVehicleSaleActivities(
                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
                    It.Is<long>(actvnbr => actvnbr == 5)));

            _mockActivityDao.Verify(x => x.GetNewVehicleSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Once);
        }

        [Test]
        public async Task GetNewVehicleSaleActivities_No_ActvNbr_Ok()
        {
            var results = await _activityService.GetNewVehicleSaleActivities("2020-04-15T11:00:00", null);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.True(results.Any(x => x.ActivityNbr == 1));
            Assert.True(results.Any(x => x.ActivityNbr == 2));
            Assert.True(results.Any(x => x.ActivityNbr == 3));

            _mockActivityDao.Verify(x => x.GetNewVehicleSaleActivities(It.IsAny<DateTime>(), It.Is<long?>(x => x == null)), Times.Once);
        }

        [Test]
        public async Task GetNewVehicleSaleActivities_No_Date_Ok()
        {
            var results = await _activityService.GetNewVehicleSaleActivities(null, 5);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.True(results.Any(x => x.ActivityNbr == 1));
            Assert.True(results.Any(x => x.ActivityNbr == 2));
            Assert.True(results.Any(x => x.ActivityNbr == 3));

            _mockActivityDao.Verify(x => x.GetNewVehicleSaleActivities(It.Is<DateTime?>(x => x.HasValue == false), It.IsAny<long>()), Times.Once);
        }

        [Test]
        public async Task GetNewVehicleSaleActivities_No_Params_Exception()
        {
            Assert.ThrowsAsync<Exception>(async () =>
                await _activityService.GetNewVehicleSaleActivities(null, null));
        }

        [Test]
        public async Task GetNewVehicleSaleActivities_FailedToParse_BadDateTime()
        {
            Assert.ThrowsAsync<FailedToParseException>(async () =>
                await _activityService.GetNewVehicleSaleActivities("DateTimes are a Devs Best Friend", 1));

            Assert.ThrowsAsync<FailedToParseException>(async () =>
                await _activityService.GetNewVehicleSaleActivities("DateTimes are a Devs Best Friend", null));
        }

        [Test]
        public async Task GetNewVehicleSaleActivities_Exception()
        {
            _mockActivityDao.Setup(x => x.GetNewVehicleSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>())).Throws(new Exception("Oops"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityService.GetNewVehicleSaleActivities("2020-04-15T11:00:00", 10));
        }

        [Test]
        public async Task GetNewVehicleSaleActivities_Both_Ok()
        {
            var results = await _activityService.GetNewVehicleSaleActivities("2020-04-15T11:00:00", 5);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.True(results.Any(x => x.ActivityNbr == 1));
            Assert.True(results.Any(x => x.ActivityNbr == 2));
            Assert.True(results.Any(x => x.ActivityNbr == 3));

            _mockActivityDao.Verify(x =>
                x.GetNewVehicleSaleActivities(
                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
                    It.Is<long>(actvnbr => actvnbr == 5)));

            _mockActivityDao.Verify(x => x.GetNewVehicleSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Once);
        }

        [Test]
        public async Task GetNewDebtProtectedLoanSaleActivities_Ok()
        {
            var results = await _activityService.GetNewDebtProtectedLoanSaleActivities("2020-04-15T11:00:00", 5);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.True(results.Any(x => x.ActivityNbr == 1));
            Assert.True(results.Any(x => x.ActivityNbr == 2));
            Assert.True(results.Any(x => x.ActivityNbr == 3));

            _mockActivityDao.Verify(x =>
                x.GetNewDebtProtectedLoanSaleActivities(
                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
                    It.Is<long>(actvnbr => actvnbr == 5)));

            _mockActivityDao.Verify(x => x.GetNewDebtProtectedLoanSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Once);
        }

        [Test]
        public async Task GetNewDebtProtectedLoanSaleActivities_No_ActvNbr_Ok()
        {
            var results = await _activityService.GetNewDebtProtectedLoanSaleActivities("2020-04-15T11:00:00", null);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.True(results.Any(x => x.ActivityNbr == 1));
            Assert.True(results.Any(x => x.ActivityNbr == 2));
            Assert.True(results.Any(x => x.ActivityNbr == 3));

            _mockActivityDao.Verify(x => x.GetNewDebtProtectedLoanSaleActivities(It.IsAny<DateTime>(), It.Is<long?>(x => x == null)), Times.Once);
        }

        [Test]
        public async Task GetNewDebtProtectedLoanSaleActivities_No_Date_Ok()
        {
            var results = await _activityService.GetNewDebtProtectedLoanSaleActivities(null, 5);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.True(results.Any(x => x.ActivityNbr == 1));
            Assert.True(results.Any(x => x.ActivityNbr == 2));
            Assert.True(results.Any(x => x.ActivityNbr == 3));

            _mockActivityDao.Verify(x => x.GetNewDebtProtectedLoanSaleActivities(It.Is<DateTime?>(x => x.HasValue == false), It.IsAny<long>()), Times.Once);
        }

        [Test]
        public async Task GetNewDebtProtectedLoanSaleActivities_No_Params_Exception()
        {
            Assert.ThrowsAsync<Exception>(async () =>
                await _activityService.GetNewDebtProtectedLoanSaleActivities(null, null));
        }

        [Test]
        public async Task GetNewDebtProtectedLoanSaleActivities_FailedToParse_BadDateTime()
        {
            Assert.ThrowsAsync<FailedToParseException>(async () =>
                await _activityService.GetNewDebtProtectedLoanSaleActivities("DateTimes are a Devs Best Friend", 1));

            Assert.ThrowsAsync<FailedToParseException>(async () =>
                await _activityService.GetNewDebtProtectedLoanSaleActivities("DateTimes are a Devs Best Friend", null));
        }

        [Test]
        public async Task GetNewDebtProtectedLoanSaleActivities_Exception()
        {
            _mockActivityDao.Setup(x => x.GetNewDebtProtectedLoanSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>())).Throws(new Exception("Oops"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityService.GetNewDebtProtectedLoanSaleActivities("2020-04-15T11:00:00", 10));
        }

        [Test]
        public async Task GetNewDebtProtectedLoanSaleActivities_Both_Ok()
        {
            var results = await _activityService.GetNewDebtProtectedLoanSaleActivities("2020-04-15T11:00:00", 5);

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.True(results.Any(x => x.ActivityNbr == 1));
            Assert.True(results.Any(x => x.ActivityNbr == 2));
            Assert.True(results.Any(x => x.ActivityNbr == 3));

            _mockActivityDao.Verify(x =>
                x.GetNewDebtProtectedLoanSaleActivities(
                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
                    It.Is<long>(actvnbr => actvnbr == 5)));

            _mockActivityDao.Verify(x => x.GetNewDebtProtectedLoanSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Once);
        }

        [Test]
        public async Task QueryActivityManagerActivity_Ok()
        {
            var results = await _activityService.QueryActivityManagerActivity(new ActivityQueryRequest()
            {
                ActivityIds = new List<long>() { 1, 2, 3 }
            });

            Assert.NotNull(results);
            Assert.AreEqual(3, results.Count);
            Assert.True(results.Any(x => x.ActivityId == 1));
            Assert.True(results.Any(x => x.ActivityId == 2));
            Assert.True(results.Any(x => x.ActivityId == 3));

            _mockActivityDao.Verify(x =>
                x.QueryActivityManagerActivity(It.IsAny<ActivityQueryRequest>()));
        }

        [Test]
        public async Task QueryActivityManagerActivity_Exception()
        {
            _mockActivityDao.Setup(x => x.QueryActivityManagerActivity(It.IsAny<ActivityQueryRequest>())).ThrowsAsync(new Exception("Oops"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _activityService.QueryActivityManagerActivity(new ActivityQueryRequest()
                {
                    ActivityIds = new List<long>() { 1, 2, 3, 4, 5, 6, 7 }
                }));

            _mockActivityDao.Verify(x =>
                x.QueryActivityManagerActivity(It.IsAny<ActivityQueryRequest>()));
        }

        [Test]
        public async Task QueryActivityManagerActivity_DontHitCoreWhenEmpty()
        {
            _mockActivityDao.Setup(x => x.QueryActivityManagerActivity(It.IsAny<ActivityQueryRequest>())).ThrowsAsync(new Exception("Oops"));


            var result = await _activityService.QueryActivityManagerActivity(new ActivityQueryRequest()
            {
                ActivityIds = new List<long>()
            });

            Assert.NotNull(result);

            _mockActivityDao.Verify(x =>
                x.QueryActivityManagerActivity(It.IsAny<ActivityQueryRequest>()), Times.Never());
        }
        
        [Test]
        public async Task GetPersonActivityByPhoneNumber_OK()
        {
            var phoneNumber = Guid.NewGuid().ToString();
            _mockActivityDao
                .Setup(x => x.GetPersonActivityByPhoneNumber(It.IsAny<string>()))
                .ReturnsAsync(new List<PersonRecentActivity>
                {
                    new () { PersonNumber = DateTime.Now.Millisecond, HomePhone = phoneNumber }
                }).Verifiable();

            var result = await _activityService.GetPersonActivityByPhoneNumber(phoneNumber);

            Assert.NotNull(result);
            Assert.IsTrue(result.Success);
            Assert.AreEqual(phoneNumber, result.PersonRecentActivity?.HomePhone);
            _mockActivityDao.Verify(x => x.GetPersonActivityByPhoneNumber(It.IsAny<string>()), Times.Once);
        }
        
        [Test]
        public async Task GetPersonActivityByPhoneNumber_MultipleReturn()
        {
            var phoneNumber = Guid.NewGuid().ToString();
            _mockActivityDao
                .Setup(x => x.GetPersonActivityByPhoneNumber(It.IsAny<string>()))
                .ReturnsAsync(new List<PersonRecentActivity>
                {
                    new () { PersonNumber = DateTime.Now.Millisecond, HomePhone = phoneNumber },
                    new () { PersonNumber = DateTime.Now.Millisecond, HomePhone = phoneNumber }
                }).Verifiable();

            var result = await _activityService.GetPersonActivityByPhoneNumber(phoneNumber);

            Assert.NotNull(result);
            Assert.IsFalse(result.Success);
            Assert.IsNotNull(result.Message);
            Assert.IsNull(result.PersonRecentActivity);
            _mockActivityDao.Verify(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()), Times.Never);
        }
                
        [Test]
        public async Task GetPersonActivityByPhoneNumber_NoContent()
        {
            var phoneNumber = Guid.NewGuid().ToString();
            _mockActivityDao
                .Setup(x => x.GetPersonActivityByPhoneNumber(It.IsAny<string>()))
                .ReturnsAsync(new List<PersonRecentActivity>()).Verifiable();

            var result = await _activityService.GetPersonActivityByPhoneNumber(phoneNumber);

            Assert.NotNull(result);
            Assert.IsFalse(result.Success);
            Assert.IsNotNull(result.Message);
            Assert.IsNull(result.PersonRecentActivity);
            _mockActivityDao.Verify(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()), Times.Never);
        }

        [Test]
        public void GetPersonActivityByPhoneNumber_Exception()
        {
            _mockActivityDao
                .Setup(x => x.GetPersonActivityByPhoneNumber(It.IsAny<string>()))
                .ThrowsAsync(new Exception());

            Assert.ThrowsAsync<ServiceException>(async () =>
                await _activityService.GetPersonActivityByPhoneNumber(It.IsAny<string>()));
        }
        
        [Test]
        public async Task GetPersonActivityByTaxId_OK()
        {
            var personNumber = DateTime.Now.Millisecond;
            var taxId = Guid.NewGuid().ToString();
            var persons = new List<PersonTaxIdDataResponse>
            {
                new()
                {
                    PersonNumber = personNumber
                }
            };
            _mockTaxService.Setup(x => x.GetPersonsTaxIdData(It.IsAny<string>()))
                .ReturnsAsync(persons).Verifiable();
            _mockActivityDao
                .Setup(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()))
                .ReturnsAsync(new PersonRecentActivity
                {
                    PersonNumber = personNumber
                }).Verifiable();

            var result = await _activityService.GetPersonActivityByTaxId(taxId);

            Assert.NotNull(result);
            Assert.IsTrue(result.Success);
            Assert.NotNull(result.PersonRecentActivity);
            Assert.AreEqual(personNumber, result.PersonRecentActivity?.PersonNumber);
            _mockActivityDao.Verify(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()), Times.Once);
            _mockTaxService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Once);
        }
        
        [Test]
        public async Task GetPersonActivityByTaxId_MultipleReturn()
        {
            var personNumber = DateTime.Now.Millisecond;
            var taxId = Guid.NewGuid().ToString();
            var persons = new List<PersonTaxIdDataResponse>
            {
                new() { PersonNumber = personNumber },
                new() { PersonNumber = personNumber }
            };
            _mockTaxService.Setup(x => x.GetPersonsTaxIdData(It.IsAny<string>()))
                .ReturnsAsync(persons).Verifiable();
            _mockActivityDao
                .Setup(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()))
                .ReturnsAsync(new PersonRecentActivity
                {
                    PersonNumber = personNumber
                }).Verifiable();

            var result = await _activityService.GetPersonActivityByTaxId(taxId);

            Assert.NotNull(result);
            Assert.IsFalse(result.Success);
            Assert.IsNotNull(result.Message);
            Assert.IsNull(result.PersonRecentActivity);
            _mockTaxService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Once);
            _mockActivityDao.Verify(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()), Times.Never);
        }
        
        [Test]
        public async Task GetPersonActivityByTaxId_NoContent()
        {
            var personNumber = DateTime.Now.Millisecond;
            var taxId = Guid.NewGuid().ToString();
            var persons = new List<PersonTaxIdDataResponse>();
            _mockTaxService.Setup(x => x.GetPersonsTaxIdData(It.IsAny<string>()))
                .ReturnsAsync(persons).Verifiable();
            _mockActivityDao
                .Setup(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()))
                .ReturnsAsync(new PersonRecentActivity
                {
                    PersonNumber = personNumber
                }).Verifiable();

            var result = await _activityService.GetPersonActivityByTaxId(taxId);

            Assert.NotNull(result);
            Assert.IsFalse(result.Success);
            Assert.IsNotNull(result.Message);
            Assert.IsNull(result.PersonRecentActivity);
            _mockTaxService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Once);
            _mockActivityDao.Verify(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()), Times.Never);
        }

        [Test]
        public void GetPersonActivityByTaxId_Exception()
        {
            _mockTaxService
                .Setup(x => x.GetPersonsTaxIdData(It.IsAny<string>()))
                .ThrowsAsync(new Exception());

            Assert.ThrowsAsync<ServiceException>(async () =>
                await _activityService.GetPersonActivityByTaxId(It.IsAny<string>()));
        }
    }
}