using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using LCU.API.Internal.Operations.IncentiveApiLib.Persistence;
using LCU.API.Internal.Operations.IncentiveApiLib.Repositories;
using LCU.Library.Internal.IncentiveApiModels.Entities;
using LCU.Library.Internal.IncentiveApiModels.Enums;
using Microsoft.EntityFrameworkCore;
using Moq;
using NUnit.Framework;
using LCU.Library.Internal.IncentiveApiModels.Common;

namespace Application.UnitTests.Repository
{
    public class ActivityRepositoryTest
    {
        private ApplicationDbContext _context;
        private ActivityRepository _repository;
        private ActivityChangeRepository _repositoryActivityChange;

        [SetUp]
        public void Setup()
        {
            var mockDateTime = new DateTimeService();
            var mockCurrentUserService = Mock.Of<ICurrentUserService>();
            Mock.Get(mockCurrentUserService).Setup(s => s.GetCurrentUser()).Returns(new ApplicationUser
            {
                Email = "JohnTest@test.com",
            });
            var options = new DbContextOptionsBuilder<ApplicationDbContext>()
                .UseInMemoryDatabase(Guid.NewGuid().ToString())
                .EnableSensitiveDataLogging()
                .Options;
            _context = new ApplicationDbContext(options, mockCurrentUserService, mockDateTime);
            _repository = new ActivityRepository(_context);
            _repositoryActivityChange = new ActivityChangeRepository(_context);
        }

        [Test]
        public async Task Basic_Flow_Test()
        {
            var saved = await _repository.GetActivitiesAsync();
            Assert.NotNull(saved);
            Assert.IsEmpty(saved);

            await _repository.SaveActivityAsync(new Activity
            {
                EmployeeId = "1254",
                DepartmentId = 5,
                Product = Product.CheckCard,
                SourceId = "1",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    MemberName = "Tester 1",
                    AgreementNumber = "234",
                    SubjectPersonNbr = "34"
                }
            });
            await _context.SaveChangesAsync();

            saved = await _repository.GetActivitiesAsync();
            Assert.NotNull(saved);
            Assert.IsNotEmpty(saved);
            var first = saved.First();
            // Make sure our Auditable is working.
            Assert.NotNull(first.CreatedBy);
            Assert.NotNull(first.Created);
            Assert.NotNull(first.LastUpdatedBy);
            Assert.NotNull(first.LastUpdated);

            var savedActivity = await _repository.GetActivityById(saved.First().Id);
            Assert.AreSame(saved.First(), savedActivity);
        }

        [Test]
        public async Task Basic_RangeFlow_Test()
        {
            var saved = await _repository.GetActivitiesAsync();
            Assert.NotNull(saved);
            Assert.IsEmpty(saved);

            var activities = new List<Activity>
            {
                new Activity
                {
                    EmployeeId = "1254",
                    DepartmentId = 5,
                    Product = Product.CheckCard,
                    SourceId = "1",
                    State = ActivityState.Accepted,
                    Detail = new ActivityDetail
                    {
                        MemberName = "Tester 1",
                        AgreementNumber = "234",
                        SubjectPersonNbr = "34"
                    }
                },
                new Activity
                {
                    EmployeeId = "2134",
                    DepartmentId = 5,
                    Product = Product.CheckCard,
                    SourceId = "2",
                    State = ActivityState.Accepted,
                    Detail = new ActivityDetail
                    {
                        MemberName = "Tester 2",
                        AgreementNumber = "234",
                        SubjectPersonNbr = "34"
                    }
                }
            };
            await _repository.SaveActivityRangeAsync(activities);
            await _context.SaveChangesAsync();

            saved = await _repository.GetActivitiesAsync();
            Assert.NotNull(saved);
            Assert.IsNotEmpty(saved);
            Assert.AreEqual(2, saved.Count());
            var first = saved.First();
            // Make sure our Auditable is working.
            Assert.NotNull(first.CreatedBy);
            Assert.NotNull(first.Created);
            Assert.NotNull(first.LastUpdatedBy);
            Assert.NotNull(first.LastUpdated);

            var savedActivity = await _repository.GetActivityById(saved.First().Id);
            Assert.AreSame(saved.First(), savedActivity);
        }

        [Test]
        public async Task FindMonthlyPersonnelActivity_None()
        {
            var department = new Department
            {
                DepartmentName = "Dept1",
                Id = 55,
                State = DepartmentState.Active
            };
            var user = new AppUser
            {
                AdEmail = "tester@test.com",
                BaseRole = "Tester",
                EmployeeId = "11771",
                FullName = "Test McTester",
                HomeDepartment = "HOME",
                PersonId = 565,
                Departments = new List<UserDepartment>()
            };
            var assignment = new UserDepartment
            {
                Id = 99,
                Department = department,
                Employee = user,
                Role = Role.Admin,
                IsHome = true,
                StartDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1),
                EndDate = null
            };
            user.Departments.Add(assignment);

            var range = new MonthRange(2021, 1, 2021, 2);
            var found = await _repository.FindEmployeeActivityByMonthRange(user, range);
            Assert.NotNull(found);
            Assert.IsEmpty(found);
        }

        [Test]
        public async Task FindMonthlyPersonnelActivity_Basic()
        {
            var activity1 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "11771",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                SourceId = "1"
            };
            await _repository.SaveActivityAsync(activity1);
            var activity2 = new Activity
            {
                DepartmentId = 56,
                EmployeeId = "11771",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                SourceId = "2"
            };
            await _repository.SaveActivityAsync(activity2);
            var activity3 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "11772",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                SourceId = "3"
            };
            await _repository.SaveActivityAsync(activity3);
            var activity4 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "11772",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.AddMonths(2),
                SourceId = "4"
            };
            await _repository.SaveActivityAsync(activity4);

            await _context.SaveChangesAsync();

            var department = new Department
            {
                Id = 55,
                State = DepartmentState.Active,
                DepartmentName = "Test",
                BusinessLineCode = BusinessLine.Operations.Code
            };
            var user = new AppUser
            {
                AdEmail = "tester@test.com",
                BaseRole = "Tester",
                EmployeeId = "11771",
                FullName = "Test McTester",
                HomeDepartment = "HOME",
                PersonId = 11771,
                Departments = new List<UserDepartment>()
            };
            var assignment = new UserDepartment
            {
                Id = 99,
                Department = department,
                DepartmentId = 55,
                Employee = user,
                Role = Role.Admin,
                IsHome = true,
                StartDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1),
                EndDate = null
            };
            user.Departments.Add(assignment);

            var range = new MonthRange(
                DateTime.Today.Year,
                DateTime.Today.Month,
                DateTime.Today.Year,
                DateTime.Today.Month
            );

            var found = await _repository.FindEmployeeActivityByMonthRange(user, range);
            Assert.NotNull(found);
            Assert.IsNotEmpty(found);
            Assert.AreEqual(2, found.Count);
        }

        [Test]
        public async Task GetActivitiesAsync_Paginated_OK()
        {
            var activity1 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "1",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                SourceId = "1",
                State = ActivityState.Accepted,
                Created = DateTime.Today.Subtract(TimeSpan.FromDays(7))
            };
            await _repository.SaveActivityAsync(activity1);
            var activity2 = new Activity
            {
                DepartmentId = 56,
                EmployeeId = "2",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                SourceId = "2",
                State = ActivityState.Accepted,
                Created = DateTime.Today.Subtract(TimeSpan.FromDays(6))
            };
            await _repository.SaveActivityAsync(activity2);
            var activity3 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "3",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                SourceId = "3",
                State = ActivityState.Rejected,
                Created = DateTime.Today.Subtract(TimeSpan.FromDays(6))
            };
            await _repository.SaveActivityAsync(activity3);
            var activity4 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "4",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                SourceId = "4",
                State = ActivityState.Created,
                Created = DateTime.Today.Subtract(TimeSpan.FromDays(5))
            };
            await _repository.SaveActivityAsync(activity4);
            await _context.SaveChangesAsync();

            var found = await _repository.GetActivitiesAsync(1, 3);
            Assert.NotNull(found);
            Assert.IsNotEmpty(found.Items);
            Assert.AreEqual(3, found.Items.Count());
            Assert.AreEqual(4, found.Total);
            Assert.True(found.Items.Any(x => x.EmployeeId == "4"));
            Assert.False(found.Items.Any(x => x.EmployeeId == "1"));
            Assert.True(found.Items.Any(x => x.EmployeeId == "2"));
            Assert.True(found.Items.Any(x => x.EmployeeId == "3"));

            found = await _repository.GetActivitiesAsync(2, 3);
            Assert.AreEqual(1, found.Items.Count());
            Assert.AreEqual(4, found.Total);
            Assert.False(found.Items.Any(x => x.EmployeeId == "4"));
            Assert.True(found.Items.Any(x => x.EmployeeId == "1"));
            Assert.False(found.Items.Any(x => x.EmployeeId == "2"));
            Assert.False(found.Items.Any(x => x.EmployeeId == "3"));

            found = await _repository.GetActivitiesAsync(100, 3);
            Assert.AreEqual(4, found.Total);
            Assert.IsEmpty(found.Items);
        }

        [Test]
        public async Task GetActivitiesByActivityProductAsync_OK()
        {
            var activity1 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "1",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.AddMinutes(-3),
                SourceId = "1",
                State = ActivityState.Accepted,
                LastUpdated = new DateTime(2021, 1, 4)
            };
            await _repository.SaveActivityAsync(activity1);
            var activity2 = new Activity
            {
                DepartmentId = 56,
                EmployeeId = "2",
                Type = ActivityType.Sale,
                Product = Product.NewChecking,
                Accepted = DateTime.Today.AddMinutes(-2),
                SourceId = "2",
                State = ActivityState.Accepted,
                LastUpdated = new DateTime(2021, 1, 3)
            };
            await _repository.SaveActivityAsync(activity2);
            var activity3 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "3",
                Type = ActivityType.Sale,
                Product = Product.NewChecking,
                Accepted = DateTime.Today.AddMinutes(-1),
                SourceId = "3",
                State = ActivityState.Rejected,
                LastUpdated = new DateTime(2021, 1, 2)
            };
            await _repository.SaveActivityAsync(activity3);
            var activity4 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "4",
                Type = ActivityType.Sale,
                Product = Product.NewChecking,
                Accepted = DateTime.Today,
                SourceId = "4",
                State = ActivityState.Accepted,
                LastUpdated = new DateTime(2021, 1, 1)
            };
            await _repository.SaveActivityAsync(activity4);
            await _context.SaveChangesAsync();


            var filter = new ActivityFilter
            {
                Page = 1,
                Limit = 2,
                Product = new List<Product> { Product.CheckCard }
            };
            var found = await _repository.GetPagedFilteredActivities(filter);
            Assert.NotNull(found);
            Assert.IsNotEmpty(found.Items);
            Assert.AreEqual(1, found.Items.Count());
            Assert.AreEqual(1, found.Total);
            Assert.True(found.Items.Any(x => x.EmployeeId == "1"));
        }

        [Test]
        public async Task GetActivitiesByActivityTypeAsync_OK()
        {
            var activity1 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "1",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.AddMinutes(-3),
                SourceId = "1",
                State = ActivityState.Accepted,
                LastUpdated = new DateTime(2021, 1, 4)
            };
            await _repository.SaveActivityAsync(activity1);
            var activity2 = new Activity
            {
                DepartmentId = 56,
                EmployeeId = "2",
                Type = ActivityType.Referral,
                Product = Product.NewChecking,
                Accepted = DateTime.Today.AddMinutes(-2),
                SourceId = "2",
                State = ActivityState.Accepted,
                LastUpdated = new DateTime(2021, 1, 3)
            };
            await _repository.SaveActivityAsync(activity2);
            var activity3 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "3",
                Type = ActivityType.Referral,
                Product = Product.NewChecking,
                Accepted = DateTime.Today.AddMinutes(-1),
                SourceId = "3",
                State = ActivityState.Rejected,
                LastUpdated = new DateTime(2021, 1, 2)
            };
            await _repository.SaveActivityAsync(activity3);
            var activity4 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "4",
                Type = ActivityType.Referral,
                Product = Product.NewChecking,
                Accepted = DateTime.Today,
                SourceId = "4",
                State = ActivityState.Accepted,
                LastUpdated = new DateTime(2021, 1, 1)
            };
            await _repository.SaveActivityAsync(activity4);
            await _context.SaveChangesAsync();


            var filter = new ActivityFilter
            {
                Page = 1,
                Limit = 2,
                Type = new List<ActivityType> { ActivityType.Sale }
            };
            var found = await _repository.GetPagedFilteredActivities(filter);
            Assert.NotNull(found);
            Assert.IsNotEmpty(found.Items);
            Assert.AreEqual(1, found.Items.Count());
            Assert.AreEqual(1, found.Total);
            Assert.True(found.Items.Any(x => x.EmployeeId == "1"));
        }

        [Test]
        public async Task GetActivitiesByStateAsync_OK()
        {
            var activity1 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "1",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.AddMinutes(-3),
                SourceId = "1",
                State = ActivityState.Accepted,
                LastUpdated = new DateTime(2021, 1, 4)
            };
            await _repository.SaveActivityAsync(activity1);
            var activity2 = new Activity
            {
                DepartmentId = 56,
                EmployeeId = "2",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.AddMinutes(-2),
                SourceId = "2",
                State = ActivityState.Accepted,
                LastUpdated = new DateTime(2021, 1, 3)
            };
            await _repository.SaveActivityAsync(activity2);
            var activity3 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "3",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.AddMinutes(-1),
                SourceId = "3",
                State = ActivityState.Rejected,
                LastUpdated = new DateTime(2021, 1, 2)
            };
            await _repository.SaveActivityAsync(activity3);
            var activity4 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "4",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                SourceId = "4",
                State = ActivityState.Accepted,
                LastUpdated = new DateTime(2021, 1, 1)
            };
            await _repository.SaveActivityAsync(activity4);
            await _context.SaveChangesAsync();


            var filter = new ActivityFilter
            {
                Page = 1,
                Limit = 2,
                State = new List<ActivityState> { ActivityState.Accepted }
            };
            var found = await _repository.GetPagedFilteredActivities(filter);
            Assert.NotNull(found);
            Assert.IsNotEmpty(found.Items);
            Assert.AreEqual(2, found.Items.Count());
            Assert.AreEqual(3, found.Total);
            Assert.False(found.Items.Any(x => x.EmployeeId == "3"));
            Assert.True(found.Items.Any(x => x.EmployeeId == "4"));
            Assert.False(found.Items.Any(x => x.EmployeeId == "1")); // not on this page
            Assert.True(found.Items.Any(x => x.EmployeeId == "2"));

            filter.Page = 2;
            found = await _repository.GetPagedFilteredActivities(filter);
            Assert.AreEqual(1, found.Items.Count());
            Assert.AreEqual(3, found.Total);
            Assert.False(found.Items.Any(x => x.EmployeeId == "3"));
            Assert.False(found.Items.Any(x => x.EmployeeId == "2"));
            Assert.True(found.Items.Any(x => x.EmployeeId == "1"));
            Assert.False(found.Items.Any(x => x.EmployeeId == "4"));

            var filter2 = new ActivityFilter
            {
                Page = 1,
                Limit = 100,
                State = new List<ActivityState> { ActivityState.ManualReview }
            };
            found = await _repository.GetPagedFilteredActivities(filter2);
            Assert.AreEqual(0, found.Total);
            Assert.IsEmpty(found.Items);

            filter2.Page = 20;
            found = await _repository.GetPagedFilteredActivities(filter2);
            Assert.AreEqual(0, found.Total);
            Assert.IsEmpty(found.Items);
        }

        [Test]
        public async Task GetActivitiesByFilter_More()
        {
            var activity1 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "1",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.AddMinutes(-3),
                SourceId = "1",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    MemberName = "John Doe"
                }
            };
            await _repository.SaveActivityAsync(activity1);
            var activity2 = new Activity
            {
                DepartmentId = 56,
                EmployeeId = "2",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.AddMinutes(-2),
                SourceId = "2",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    SubjectPersonNbr = "1Jane3Doe"
                }
            };
            await _repository.SaveActivityAsync(activity2);
            var activity3 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "3",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.AddMinutes(-1),
                SourceId = "3",
                State = ActivityState.Rejected,
                Detail = new ActivityDetail
                {
                    AccountNumber = "1234"
                }
            };
            await _repository.SaveActivityAsync(activity3);
            var activity4 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "4",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                SourceId = "4",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    AccountNumber = "12DOE35"
                }
            };
            await _repository.SaveActivityAsync(activity4);
            await _context.SaveChangesAsync();

            var filter = new ActivityFilter
            {
                Page = 1,
                Limit = 2,
                Query = "DoE"
            };
            var found = await _repository.GetPagedFilteredActivities(filter);
            Assert.NotNull(found);
            Assert.IsNotEmpty(found.Items);
            Assert.AreEqual(2, found.Items.Count());
            Assert.AreEqual(3, found.Total);
            Assert.False(found.Items.Any(x => x.EmployeeId == "3"));
            Assert.True(found.Items.Any(x => x.EmployeeId == "4"));
            Assert.False(found.Items.Any(x => x.EmployeeId == "1")); // not on this page
            Assert.True(found.Items.Any(x => x.EmployeeId == "2"));

            filter.Page = 2;
            found = await _repository.GetPagedFilteredActivities(filter);
            Assert.AreEqual(1, found.Items.Count());
            Assert.AreEqual(3, found.Total);
            Assert.False(found.Items.Any(x => x.EmployeeId == "3"));
            Assert.False(found.Items.Any(x => x.EmployeeId == "2"));
            Assert.True(found.Items.Any(x => x.EmployeeId == "1"));
            Assert.False(found.Items.Any(x => x.EmployeeId == "4"));
        }

        [Test]
        public async Task GetActivitiesByFilter_Employee_Department()
        {
            var activity1 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "1",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.AddMinutes(-3),
                SourceId = "1",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    MemberName = "John Doe"
                }
            };
            await _repository.SaveActivityAsync(activity1);
            var activity2 = new Activity
            {
                DepartmentId = 56,
                EmployeeId = "2",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.AddMinutes(-2),
                SourceId = "2",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    SubjectPersonNbr = "1Jane3Doe"
                }
            };
            await _repository.SaveActivityAsync(activity2);
            var activity3 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "3",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.AddMinutes(-1),
                SourceId = "3",
                State = ActivityState.Rejected,
                Detail = new ActivityDetail
                {
                    AccountNumber = "1234"
                }
            };
            await _repository.SaveActivityAsync(activity3);
            var activity4 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "4",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                SourceId = "4",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    AccountNumber = "12DOE35"
                }
            };
            await _repository.SaveActivityAsync(activity4);
            await _context.SaveChangesAsync();

            var filter = new ActivityFilter
            {
                Page = 1,
                Limit = 2,
                DepartmentId = 55
            };
            var found = await _repository.GetPagedFilteredActivities(filter);
            Assert.NotNull(found);
            Assert.IsNotEmpty(found.Items);
            Assert.AreEqual(2, found.Items.Count());
            Assert.AreEqual(3, found.Total);
            Assert.True(found.Items.Any(x => x.EmployeeId == "3"));
            Assert.True(found.Items.Any(x => x.EmployeeId == "4"));
            Assert.False(found.Items.Any(x => x.EmployeeId == "1")); // not on this page
            Assert.False(found.Items.Any(x => x.EmployeeId == "2"));

            filter.EmployeeId = "4";
            found = await _repository.GetPagedFilteredActivities(filter);
            Assert.AreEqual(1, found.Items.Count());
            Assert.AreEqual(1, found.Total);
            Assert.False(found.Items.Any(x => x.EmployeeId == "3"));
            Assert.False(found.Items.Any(x => x.EmployeeId == "2"));
            Assert.False(found.Items.Any(x => x.EmployeeId == "1"));
            Assert.True(found.Items.Any(x => x.EmployeeId == "4"));

            filter.DepartmentId = 99;
            found = await _repository.GetPagedFilteredActivities(filter);
            Assert.AreEqual(0, found.Items.Count());
            Assert.AreEqual(0, found.Total);
        }

        [Test]
        public async Task GetActivitiesByFilter_LowDate_Accepted()
        {
            var activity1 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "1",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                SourceId = "1",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    MemberName = "John Doe"
                }
            };
            await _repository.SaveActivityAsync(activity1);
            var activity2 = new Activity
            {
                DepartmentId = 56,
                EmployeeId = "2",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.AddDays(-1),
                SourceId = "2",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    SubjectPersonNbr = "1Jane3Doe"
                }
            };
            await _repository.SaveActivityAsync(activity2);
            var activity3 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "3",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                SourceId = "3",
                State = ActivityState.Rejected,
                Detail = new ActivityDetail
                {
                    AccountNumber = "1234"
                }
            };
            await _repository.SaveActivityAsync(activity3);
            await _context.SaveChangesAsync();

            var filter = new ActivityFilter
            {
                Page = 1,
                Limit = 2,
                DateLow = DateTime.Today
            };
            var found = await _repository.GetPagedFilteredActivities(filter);
            Assert.NotNull(found);
            Assert.IsNotEmpty(found.Items);
            Assert.AreEqual(2, found.Items.Count());
            Assert.AreEqual(2, found.Total);
            Assert.True(found.Items.Any(x => x.Accepted == DateTime.Today));
            Assert.False(found.Items.Any(x => x.Accepted != DateTime.Today)); // not on this page
        }

        [Test]
        public async Task GetActivitiesByFilter_Sort()
        {
            // You can't set last updated. So you'll get these back in reverse order you saved them.
            var activity1 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "1",
                Type = ActivityType.Referral,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                SourceId = "1",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    MemberName = "John Doe"
                }
            };
            await _repository.SaveActivityAsync(activity1);
            var activity2 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "3",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                SourceId = "3",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    SubjectPersonNbr = "1Jane3Doe"
                }
            };
            await _repository.SaveActivityAsync(activity2);
            var activity3 = new Activity
            {
                DepartmentId = 56,
                EmployeeId = "4",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                SourceId = "4",
                State = ActivityState.Rejected,
                Detail = new ActivityDetail
                {
                    AccountNumber = "1234"
                }
            };
            await _repository.SaveActivityAsync(activity3);
            var activity4 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "2",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                SourceId = "2",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    AccountNumber = "12DOE35"
                }
            };
            await _repository.SaveActivityAsync(activity4);
            await _context.SaveChangesAsync();

            var filter = new ActivityFilter
            {
                Page = 1,
                Limit = 99,
                DepartmentId = 55,
                SortBy = "EmployeeId"
            };
            var found = await _repository.GetPagedFilteredActivities(filter);
            var expected = new[] { "1", "2", "3" };
            Assert.NotNull(found);
            Assert.IsNotEmpty(found.Items);
            Assert.AreEqual(3, found.Items.Count());
            Assert.AreEqual(3, found.Total);
            Assert.AreEqual(expected, found.Items.Select(x => x.EmployeeId).ToArray());

            filter.SortDescending = true;
            found = await _repository.GetPagedFilteredActivities(filter);
            expected = new[] { "3", "2", "1" };
            Assert.NotNull(found);
            Assert.IsNotEmpty(found.Items);
            Assert.AreEqual(3, found.Items.Count());
            Assert.AreEqual(3, found.Total);
            Assert.AreEqual(expected, found.Items.Select(x => x.EmployeeId).ToArray());

            filter.SortDescending = false;
            filter.SortBy = null;
            found = await _repository.GetPagedFilteredActivities(filter);
            expected = new[] { "1", "3", "2" };
            Assert.NotNull(found);
            Assert.IsNotEmpty(found.Items);
            Assert.AreEqual(3, found.Items.Count());
            Assert.AreEqual(3, found.Total);
            Assert.AreEqual(expected, found.Items.Select(x => x.EmployeeId).ToArray());
        }

        [Test]
        public async Task FindUnmatchedReferrals_Basic()
        {
            var activity1 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "1",
                Type = ActivityType.Referral,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.AddMinutes(-3),
                SourceId = "1",
                State = ActivityState.PendingReferral,
                Detail = new ActivityDetail
                {
                    MemberName = "John Doe"
                },
                MetaData = new List<ActivityMetaData> { new ActivityMetaData { MetaData = "1234567890", MetaDataType = MetaDataType.Phone } }
            };
            await _repository.SaveActivityAsync(activity1);
            var activity2 = new Activity
            {
                DepartmentId = 56,
                EmployeeId = "2",
                Type = ActivityType.Referral,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.AddMinutes(-2),
                SourceId = "2",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    SubjectPersonNbr = "1Jane3Doe"
                }
            };
            await _repository.SaveActivityAsync(activity2);
            var activity3 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "3",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.AddMinutes(-1),
                SourceId = "3",
                State = ActivityState.Rejected,
                Detail = new ActivityDetail
                {
                    AccountNumber = "1234"
                },
                MetaData = new List<ActivityMetaData> { new ActivityMetaData { MetaData = "1234567890", MetaDataType = MetaDataType.Phone } }
            };
            await _repository.SaveActivityAsync(activity3);
            var activity4 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "4",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                SourceId = "4",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    AccountNumber = "12DOE35"
                }
            };
            await _repository.SaveActivityAsync(activity4);
            await _context.SaveChangesAsync();

            var found = await _repository.FindUnmatchedReferrals();
            Assert.NotNull(found);
            Assert.IsNotEmpty(found);
            Assert.AreEqual(1, found.Count);
        }

        [Test]
        public async Task FindMatchedSaleForReferral_Basic()
        {
            var activity1 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "1",
                Type = ActivityType.Referral,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceId = "1",
                State = ActivityState.PendingReferral,
                Detail = new ActivityDetail
                {
                    MemberName = "John Doe",
                    SubjectPersonNbr = "12345",
                    SubjectOrgNbr = "123"
                }
            };
            await _repository.SaveActivityAsync(activity1);
            var activity2 = new Activity
            {
                DepartmentId = 56,
                EmployeeId = "2",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                SourceCreated = DateTime.Today,
                SourceId = "2",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    SubjectPersonNbr = "12345",
                    SubjectOrgNbr = "123"
                }
            };
            await _repository.SaveActivityAsync(activity2);
            var activity3 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "3",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                SourceCreated = DateTime.Today,
                Accepted = DateTime.Today,
                SourceId = "3",
                State = ActivityState.Rejected,
                Detail = new ActivityDetail
                {
                    AccountNumber = "1234565",
                    SubjectPersonNbr = "1223423",
                    SubjectOrgNbr = "122343"
                }
            };
            await _repository.SaveActivityAsync(activity3);
            var activity4 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "4",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                SourceCreated = DateTime.Today,
                SourceId = "4",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    AccountNumber = "12DOE35",
                    SubjectPersonNbr = "123234245",
                    SubjectOrgNbr = "122223"
                }
            };
            await _repository.SaveActivityAsync(activity4);
            await _context.SaveChangesAsync();

            var found = await _repository.FindUnmatchedSaleForReferral(activity1);
            Assert.NotNull(found);
            Assert.AreEqual(activity2, found);
        }

        [TestCase("1234567", MetaDataType.Phone)]
        [TestCase("user@mymail.com", MetaDataType.Email)]
        [Test]
        public async Task FindMatchedSaleForReferral_MatchOnMetaData_Basic(string metaDataValue, MetaDataType metaDataType)
        {
            var activity1 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "1",
                Type = ActivityType.Referral,
                Product = Product.FirstMortgageReferral,
                Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceId = "1",
                State = ActivityState.PendingReferral,
                Detail = new ActivityDetail
                {
                    MemberName = "John Doe",
                    SubjectPersonNbr = "", // null or empty personNbr and orgNbr trigger match on metadata
                    SubjectOrgNbr = ""
                },
                MetaData = new List<ActivityMetaData>
                {
                    new ActivityMetaData()
                    {
                        Id = 1,
                        MetaData = metaDataValue,
                        MetaDataType = metaDataType
                    }
                }
            };
            await _repository.SaveActivityAsync(activity1);
            var activity2 = new Activity
            {
                DepartmentId = 56,
                EmployeeId = "2",
                Type = ActivityType.Sale,
                Product = Product.FirstMortgageReferral,
                Accepted = DateTime.Today,
                SourceCreated = DateTime.Today,
                SourceId = "2",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    SubjectPersonNbr = "",
                    SubjectOrgNbr = ""
                },
                MetaData = new List<ActivityMetaData>
                {
                    new ActivityMetaData()
                    {
                        Id = 2,
                        MetaData = metaDataValue,
                        MetaDataType = metaDataType
                    }
                }
            };
            await _repository.SaveActivityAsync(activity2);
            var activity3 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "3",
                Type = ActivityType.Sale,
                Product = Product.FirstMortgageReferral,
                SourceCreated = DateTime.Today,
                Accepted = DateTime.Today,
                SourceId = "3",
                State = ActivityState.Rejected, // rejected state excludes activity from potentially matching
                Detail = new ActivityDetail
                {
                    AccountNumber = "1234565",
                    SubjectPersonNbr = null,
                    SubjectOrgNbr = null
                },
                MetaData = new List<ActivityMetaData>()
                {
                    new ActivityMetaData()
                    {
                        Id = 3,
                        MetaData = "user@user.com",
                        MetaDataType = MetaDataType.Email
                    }
                }
            };
            await _repository.SaveActivityAsync(activity3);
            var activity4 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "4",
                Type = ActivityType.Sale,
                Product = Product.FirstMortgageReferral,
                Accepted = DateTime.Today,
                SourceCreated = DateTime.Today,
                SourceId = "4",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    AccountNumber = "12DOE35",
                    SubjectPersonNbr = null,
                    SubjectOrgNbr = null
                },
                MetaData = new List<ActivityMetaData>() { }
            };
            await _repository.SaveActivityAsync(activity4);
            await _context.SaveChangesAsync();

            var found = await _repository.FindUnmatchedSaleForReferral(activity1);
            Assert.NotNull(found);
            Assert.AreEqual(activity2, found);
        }

        [Test]
        public async Task FindMatchedSaleForReferral_AllSalesAlreadyAssociatedToStateChange_NoReturn()
        {
            var activity1 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "1",
                Type = ActivityType.Referral,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceId = "1",
                State = ActivityState.PendingReferral,
                Detail = new ActivityDetail
                {
                    MemberName = "John Doe",
                    SubjectPersonNbr = "12345",
                    SubjectOrgNbr = "123"
                }
            };

            await _repository.SaveActivityAsync(activity1);

            var activity2 = new Activity
            {
                DepartmentId = 56,
                EmployeeId = "2",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                SourceCreated = DateTime.Today,
                SourceId = "2",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    SubjectPersonNbr = "12345",
                    SubjectOrgNbr = "123"
                }
            };
            await _repository.SaveActivityAsync(activity2);
            var change2 = new ActivityStateChange
            {
                ActivityId = 2,
                State = ActivityState.Accepted,
                ActivityMatchId = activity2.Id
            };
            await _repositoryActivityChange.SaveActivityStateChange(change2);
            var activity3 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "3",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                SourceCreated = DateTime.Today,
                Accepted = DateTime.Today,
                SourceId = "3",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    AccountNumber = "1234565",
                    SubjectPersonNbr = "1223423",
                    SubjectOrgNbr = "122343"
                }
            };
            await _repository.SaveActivityAsync(activity3);
            var change3 = new ActivityStateChange
            {
                ActivityId = 3,
                State = ActivityState.Accepted,
                ActivityMatchId = activity3.Id
            };
            await _repositoryActivityChange.SaveActivityStateChange(change3);
            var activity4 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "4",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                SourceCreated = DateTime.Today,
                SourceId = "4",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    AccountNumber = "12DOE35",
                    SubjectPersonNbr = "123234245",
                    SubjectOrgNbr = "122223"
                }
            };
            await _repository.SaveActivityAsync(activity4);
            var change4 = new ActivityStateChange
            {
                ActivityId = 4,
                State = ActivityState.Accepted,
                ActivityMatchId = activity4.Id
            };
            await _repositoryActivityChange.SaveActivityStateChange(change4);
            await _context.SaveChangesAsync();

            var found = await _repository.FindUnmatchedSaleForReferral(activity1);
            Assert.IsNull(found);
        }

        [Test]
        public async Task FindMatchedSaleForReferral_NoUnmatchedActivities_ReturnNull()
        {
            var activity1 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "1",
                Type = ActivityType.Referral,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceId = "1",
                State = ActivityState.PendingReferral,
                Detail = new ActivityDetail
                {
                    MemberName = "John Doe",
                    SubjectPersonNbr = "12345",
                    SubjectOrgNbr = "123"
                },
                MetaData = new List<ActivityMetaData>
                {
                    new ActivityMetaData { MetaData = "1234567890", MetaDataType = MetaDataType.Phone },
                    new ActivityMetaData { MetaData = "TestTesterson@testerson.com", MetaDataType = MetaDataType.Email }
                }
            };

            await _repository.SaveActivityAsync(activity1);
            await _context.SaveChangesAsync();

            var found = await _repository.FindUnmatchedSaleForReferral(activity1);
            Assert.IsNull(found);
        }

        [Test]
        public async Task FindMatchedSaleForReferral_SameDay_NotSameTime()
        {
            var referral = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "1",
                Type = ActivityType.Referral,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceId = "1",
                State = ActivityState.PendingReferral,
                Detail = new ActivityDetail
                {
                    MemberName = "John Doe",
                    SubjectPersonNbr = "12345",
                    SubjectOrgNbr = "123"
                }
            };

            var sale = new Activity
            {
                DepartmentId = 56,
                EmployeeId = "2",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today,
                SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceId = "2",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    SubjectPersonNbr = "12345",
                    SubjectOrgNbr = "123"
                }
            };

            // Just make sure that the referral can happen after the sale, but the same day.
            referral.SourceCreated = referral.SourceCreated.AddHours(12);
            sale.SourceCreated = sale.SourceCreated.AddHours(2);
            Assert.AreNotEqual(referral.SourceCreated, sale.SourceCreated);
            Assert.AreEqual(referral.SourceCreated.Date, sale.SourceCreated.Date);
            Assert.True(referral.SourceCreated > sale.SourceCreated);
            await _repository.SaveActivityAsync(referral);
            await _repository.SaveActivityAsync(sale);
            await _context.SaveChangesAsync();

            var found = await _repository.FindUnmatchedSaleForReferral(referral);
            Assert.NotNull(found);
            Assert.AreEqual(sale, found);
        }

        [Test]
        public async Task Duplicate_Detection_Basic_Sale_Product_Default()
        {
            var activity1 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "1",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceId = "1",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    MemberName = "John Doe",
                    SubjectPersonNbr = "12345",
                    SubjectOrgNbr = "123"
                }
            };
            await _repository.SaveActivityAsync(activity1);
            await _context.SaveChangesAsync();
            var activity2 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "1",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    MemberName = "John Doe",
                    SubjectPersonNbr = "12345",
                    SubjectOrgNbr = "123"
                }
            };

            // They are complete duplicates.
            var found = await _repository.FindDuplicateSaleAsync(activity2);
            Assert.NotNull(found);
            Assert.AreEqual(activity1, found);

            // Change only source ID
            Random r = new Random();
            activity2.SourceId = r.Next(10000, 50000) + "_SCID";
            activity2.Detail.SubjectPersonNbr = activity1.Detail.SubjectPersonNbr;
            activity2.Detail.SubjectOrgNbr = activity1.Detail.SubjectOrgNbr;
            found = await _repository.FindDuplicateSaleAsync(activity2);
            Assert.Null(found);

            // Change SubjectPersonNbr Only.
            activity2.SourceId = null;
            activity2.Detail.SubjectPersonNbr = "12234333";
            activity2.Detail.SubjectOrgNbr = activity1.Detail.SubjectOrgNbr;
            found = await _repository.FindDuplicateSaleAsync(activity2);
            Assert.Null(found);

            // Change SubjectOrgNbr Only.
            activity2.SourceId = null;
            activity2.Detail.SubjectPersonNbr = activity1.Detail.SubjectPersonNbr;
            activity2.Detail.SubjectOrgNbr = "3112333";
            found = await _repository.FindDuplicateSaleAsync(activity2);
            Assert.Null(found);
        }

        [Test]
        public async Task FindActivityForStateUpdate_Default()
        {
            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)),
                SourceId = "1",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    AccountNumber = "867530986",
                    MemberName = "ORLANDO TESTCUSTOMER10"
                }
            };
            await _repository.SaveActivityAsync(existingActivity);
            await _context.SaveChangesAsync();
            var updateStateActivity = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "11774",
                Type = ActivityType.Sale,
                Product = Product.GAPInsurance,
                Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                State = ActivityState.Rejected,
                Detail = new ActivityDetail
                {
                    AccountNumber = "867530986",
                    MemberName = "ORLANDO TESTCUSTOMER10"
                }
            };

            // They are complete duplicates.
            var found = await _repository.FindActivityForStateUpdate(updateStateActivity);
            Assert.NotNull(found);
            Assert.AreEqual(existingActivity, found);
        }

        [Test]
        public async Task FindActivityForDetailUpdate_Default()
        {
            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)),
                SourceId = "1",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    AccountNumber = "867530986",
                    MemberName = "ORLANDO TESTCUSTOMER10",
                    SubAccountNumber = "8675309"
                }
            };
            await _repository.SaveActivityAsync(existingActivity);
            await _context.SaveChangesAsync();
            var queryActivity = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "11774",
                Type = ActivityType.Sale,
                Product = Product.GAPInsurance,
                Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                State = ActivityState.Rejected,
                Detail = new ActivityDetail
                {
                    AccountNumber = "867530986",
                    MemberName = "ORLANDO TESTCUSTOMER10",
                    SubAccountNumber = "8675309"
                }
            };

            var found = await _repository.FindActivityForDetailUpdate(queryActivity);
            Assert.NotNull(found);
            Assert.AreEqual(existingActivity, found);
        }

        [Test]
        public async Task FindActivityForDetailUpdate_FallsBackToNotMatchOnSubAccountNumberAfterFindingNothing()
        {
            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)),
                SourceId = "1",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail
                {
                    AccountNumber = "867530986",
                    MemberName = "ORLANDO TESTCUSTOMER10"
                }
            };
            await _repository.SaveActivityAsync(existingActivity);
            await _context.SaveChangesAsync();
            var queryActivity = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "11774",
                Type = ActivityType.Sale,
                Product = Product.GAPInsurance,
                Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                State = ActivityState.Rejected,
                Detail = new ActivityDetail
                {
                    AccountNumber = "867530986",
                    MemberName = "ORLANDO TESTCUSTOMER10",
                    SubAccountNumber = "8675309"
                }
            };

            var found = await _repository.FindActivityForDetailUpdate(queryActivity);
            Assert.NotNull(found);
            Assert.AreEqual(existingActivity, found);
        }

        [Test]
        public async Task Duplicate_Detection_Basic_Referral_Product_Default()
        {
            var activity1 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "1",
                Type = ActivityType.Referral,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceId = "1",
                State = ActivityState.PendingReferral,
                Detail = new ActivityDetail
                {
                    MemberName = "John Doe",
                    SubjectPersonNbr = "12345",
                    SubjectOrgNbr = "123"
                }
            };
            await _repository.SaveActivityAsync(activity1);
            await _context.SaveChangesAsync();
            var activity2 = new Activity
            {
                DepartmentId = 55,
                EmployeeId = "1",
                Type = ActivityType.Referral,
                Product = Product.CheckCard,
                Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
                State = ActivityState.PendingReferral,
                Detail = new ActivityDetail
                {
                    MemberName = "John Doe",
                    SubjectPersonNbr = "12345",
                    SubjectOrgNbr = "123"
                }
            };

            // They are complete duplicates.
            var found = await _repository.FindDuplicateReferralAsync(activity2);
            Assert.NotNull(found);
            Assert.AreEqual(activity1, found);

            // Change only source ID, Referrals do not care
            Random r = new Random();
            activity2.SourceId = r.Next(10000, 50000) + "_SCID";
            activity2.Detail.SubjectPersonNbr = activity1.Detail.SubjectPersonNbr;
            activity2.Detail.SubjectOrgNbr = activity1.Detail.SubjectOrgNbr;
            found = await _repository.FindDuplicateReferralAsync(activity2);
            Assert.NotNull(found);
            Assert.AreEqual(activity1, found);

            // Change SubjectPersonNbr Only.
            activity2.SourceId = null;
            activity2.Detail.SubjectPersonNbr = "12234333";
            activity2.Detail.SubjectOrgNbr = activity1.Detail.SubjectOrgNbr;
            found = await _repository.FindDuplicateReferralAsync(activity2);
            Assert.Null(found);

            // Change SubjectOrgNbr Only.
            activity2.SourceId = null;
            activity2.Detail.SubjectPersonNbr = activity1.Detail.SubjectPersonNbr;
            activity2.Detail.SubjectOrgNbr = "3112333";
            found = await _repository.FindDuplicateReferralAsync(activity2);
            Assert.Null(found);
        }

        [Test]
        public async Task FindDepartmentActivityByMonthRange_Basic()
        {
            var activityInRange = new Activity
            {
                DepartmentId = 1,
                EmployeeId = "1",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = new DateTime(2021, 7, 3),
                SourceId = "1",
                State = ActivityState.Accepted
            };
            await _repository.SaveActivityAsync(activityInRange);
            var activityNotInRange = new Activity
            {
                DepartmentId = 1,
                EmployeeId = "2",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = new DateTime(2021, 6, 3),
                SourceId = "2",
                State = ActivityState.Accepted
            };
            await _repository.SaveActivityAsync(activityNotInRange);
            var activityForOtherDepartment = new Activity
            {
                DepartmentId = 2,
                EmployeeId = "3",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = new DateTime(2021, 7, 3),
                SourceId = "3",
                State = ActivityState.Accepted
            };
            await _repository.SaveActivityAsync(activityForOtherDepartment);
            await _context.SaveChangesAsync();

            var range = new MonthRange(2021, 7, 2021, 8);
            var found = await _repository.FindDepartmentActivityByMonthRange(1, range);

            Assert.AreEqual(1, found.Count());
            Assert.AreEqual("1", found.First().EmployeeId);
        }

        [Test]
        public async Task GetActivityIncludingPayouts_Basic()
        {
            var department = new Department()
            {
                DepartmentName = "Dept1",
                Id = 55,
                State = DepartmentState.Active
            };

            var user = new AppUser
            {
                AdEmail = "AbrahamTestAssociate1@test.com",
                EmployeeId = "11771",
                FullName = "Abraham TestAssociate1",
                Departments = new List<UserDepartment>
                {
                    new UserDepartment()
                    {
                        Id = 99,
                        Department = department,
                        Employee = null,
                        Role = Role.BM,
                        IsHome = true,
                        StartDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1),
                        EndDate = null
                    }
                }
            };

            var activityWithPayouts = new Activity
            {
                Id = 11,
                DepartmentId = 1,
                EmployeeId = "1",
                Type = ActivityType.Sale,
                Product = Product.CheckCard,
                Accepted = new DateTime(2021, 7, 3),
                SourceId = "1",
                State = ActivityState.Accepted,
                Detail = new ActivityDetail { Id = 22 },
                ActivityPayouts = new List<ActivityPayoutLineItem>
                {
                    new ActivityPayoutLineItem
                    {
                        ActivityId = 11,
                        PayoutLineItemId = 33,
                        PayoutLineItem = new PayoutLineItem { Id = 33, EmployeeId = "1", Role = Role.BM }
                    }
                }
            };

            await _repository.SaveActivityAsync(activityWithPayouts);
            await _context.SaveChangesAsync();

            var found = await _repository.GetActivityIncludingPayouts(11);

            Assert.NotNull(found);
            Assert.AreEqual(11, found.Id);
            Assert.AreEqual(22, found.Detail.Id);
            Assert.AreEqual(11, found.ActivityPayouts.First().ActivityId);
            Assert.AreEqual(33, found.ActivityPayouts.First().PayoutLineItemId);
            Assert.AreEqual(33, found.ActivityPayouts.First().PayoutLineItem.Id);
        }

        [Test]
        public async Task FindGapInsuranceEligible()
        {
            var sourceId = CreateId();
            var accepted = DateTime.UtcNow;

            var activities = new List<Activity>()
            {
                new() // Eligible
                {
                    EmployeeId = CreateId(),
                    SourceId = sourceId,
                    Accepted = accepted,
                    Detail = new ActivityDetail
                    {
                        IsGapInsuranceEligible = true
                    }
                },
                new() // Detail is null
                {
                    EmployeeId = CreateId(),
                    SourceId = sourceId,
                    Accepted = accepted
                },
                new() // Accepted is not in range
                {
                    EmployeeId = CreateId(),
                    SourceId = sourceId,
                    Accepted = accepted.AddMonths(-1),
                    Detail = new ActivityDetail
                    {
                        IsGapInsuranceEligible = true
                    }
                },
                new() // Is not GAP insurance eligible
                {
                    EmployeeId = CreateId(),
                    SourceId = sourceId,
                    Accepted= accepted,
                    Detail = new ActivityDetail
                    {
                        IsGapInsuranceEligible = false
                    }
                }
            };

            await _repository.SaveActivityRangeAsync(new List<Activity>(activities));
            await _context.SaveChangesAsync();
            var eligibles = await _repository.FindGapInsuranceEligible(new MonthRange(accepted, accepted));
            Assert.AreEqual(1, eligibles.Count);
        }

        [Test]
        public async Task PropertyChangesIsGapEligible_VehicleProduct()
        {
            var sourceId = CreateId();
            var accepted = DateTime.UtcNow;

            var activities = new List<Activity>()
            {
                new() // Eligible
                {
                    EmployeeId = CreateId(),
                    SourceId = sourceId,
                    Accepted = accepted,
                    Detail = new ActivityDetail
                    {
                        Id = 3,
                        IsGapInsuranceEligible = true
                    }
                },
                new() // Detail is null
                {
                    EmployeeId = CreateId(),
                    SourceId = sourceId,
                    Accepted = accepted
                },
                new() // Accepted is not in range
                {
                    EmployeeId = CreateId(),
                    SourceId = sourceId,
                    Accepted = accepted.AddMonths(-1),
                    Detail = new ActivityDetail
                    {
                        Id = 1,
                        IsGapInsuranceEligible = true
                    }
                },
                new() // Is not GAP insurance eligible
                {
                    EmployeeId = CreateId(),
                    SourceId = sourceId,
                    Accepted= accepted,
                    Detail = new ActivityDetail
                    {
                        Id = 2,
                        IsGapInsuranceEligible = false
                    }
                }
            };

            await _repository.SaveActivityRangeAsync(new List<Activity>(activities));
            await _context.SaveChangesAsync();
            var eligibles = await _repository.FindGapInsuranceEligible(new MonthRange(accepted, accepted));
            Assert.AreEqual(true, eligibles[0].Detail.IsGapInsuranceEligible);
            Assert.AreEqual(1, eligibles.Count);
        }

        [Test]
        public async Task FindLatestBySourceId()
        {
            var sourceId1 = CreateId();
            var sourceId2 = CreateId();
            var created = DateTime.UtcNow;

            var activities = new List<Activity>()
            {
                new() // Latest Source ID 1
                {
                    EmployeeId = CreateId(),
                    SourceId = sourceId1,
                    Created = created
                },
                new()
                {
                    EmployeeId = CreateId(),
                    SourceId = sourceId1,
                    Created = created.AddDays(-1)
                },
                new() // Latest Source ID 2
                {
                    EmployeeId = CreateId(),
                    SourceId = sourceId2,
                    Created = created
                },
                new()
                {
                    EmployeeId = CreateId(),
                    SourceId = sourceId2,
                    Created = created.AddDays(-1)
                }
            };


            await _repository.SaveActivityRangeAsync(new List<Activity>(activities));
            await _context.SaveChangesAsync();

            var latest = await _repository.FindLatestBySourceId(new List<string>
            {
                sourceId1,
                sourceId2
            });

            Assert.AreEqual(2, latest.Count);
            Assert.NotNull(latest.SingleOrDefault(activity => activity.EmployeeId == activities[0].EmployeeId));
            Assert.NotNull(latest.SingleOrDefault(activity => activity.EmployeeId == activities[2].EmployeeId));
            Assert.False((await _repository.FindLatestBySourceId(new List<string>())).Any());
        }

        [Test]
        public async Task FindById()
        {
            var activities = new List<Activity>()
            {
                new()
                {
                    EmployeeId = CreateId(),
                    SourceId = CreateId()
                },
                new()
                {
                    EmployeeId = CreateId(),
                    SourceId = CreateId()
                }
            };


            await _repository.SaveActivityRangeAsync(new List<Activity>(activities));
            await _context.SaveChangesAsync();

            var latest = await _repository.FindLatestBySourceId(new List<string>
            {
                activities[0].SourceId,
                activities[1].SourceId
            });

            Assert.AreEqual(2, latest.Count);
            var found = await _repository.FindById(latest.Select(activity => activity.Id).ToList());
            Assert.AreEqual(2, found.Count);
            Assert.NotNull(found.SingleOrDefault(activity => activity.Id == latest[0].Id));
            Assert.NotNull(found.SingleOrDefault(activity => activity.Id == latest[1].Id));
            Assert.False((await _repository.FindById(new List<int>())).Any());
        }

        private static string CreateId() => Guid.NewGuid().ToString("D");
    }
}