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.Common;
using LCU.Library.Internal.IncentiveApiModels.Entities;
using LCU.Library.Internal.IncentiveApiModels.Enums;
using LCU.Library.Internal.IncentiveApiModels.Requests;
using LCU.Library.Internal.IncentiveApiModels.Results;
using Microsoft.EntityFrameworkCore;
using Moq;
using NUnit.Framework;

namespace Application.UnitTests.Repository
{
    public class DepartmentRepositoryTest
    {
        private ApplicationDbContext _context;
        private DepartmentRepository _repository;
        private Mock<IDateTime> _mockDateTime;

        [SetUp]
        public void Setup()
        {
            _mockDateTime = new Mock<IDateTime>();
            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(true)
                .Options;
            _context = new ApplicationDbContext(options, mockCurrentUserService, _mockDateTime.Object);
            _repository = new DepartmentRepository(_context);
        }

        [Test]
        public async Task Basic_Flow_test()
        {
            var mockDate = new DateTime(2021, 8, 17, 1, 2, 3, 456);
            _mockDateTime.SetupGet(mock => mock.Now).Returns(mockDate);
            var saved = await _repository.GetAllDepartmentsAsync();
            Assert.NotNull(saved);
            Assert.IsEmpty(saved);

            var newDepartment = new Department
            {
                DayforceDepartmentName = "Test",
                DayForceGlCode = "1",
                DnaOrgNbr = "1",
                State = DepartmentState.Active,
                DepartmentName = "TestDept1",
                BusinessLineCode = BusinessLine.Operations.Code,
                RegionCode = Region.North.Code
            };

            var newId = await _repository.SaveDepartmentAsync(newDepartment);
            await _context.SaveChangesAsync();

            saved = await _repository.GetAllDepartmentsAsync();
            Assert.NotNull(saved);
            Assert.IsNotEmpty(saved);
            var first = saved.First();
            Assert.AreEqual(DepartmentState.Active, first.State);
            Assert.AreEqual("TestDept1", first.DepartmentName);
            Assert.AreEqual(BusinessLine.Operations.Code, first.BusinessLineCode);
            Assert.AreEqual(Region.North.Code, first.RegionCode);
            // Make sure our Auditable is working.
            Assert.True(first.Created.Equals(mockDate));
            Assert.AreEqual("JohnTest@test.com", first.CreatedBy);
            Assert.AreEqual(UserType.Associate, first.CreatedByType);
            Assert.True(first.LastUpdated.Equals(mockDate));
            Assert.AreEqual("JohnTest@test.com", first.LastUpdatedBy);
            Assert.AreEqual(UserType.Associate, first.LastUpdatedByType);
        }

        [Test]
        public async Task Find_Or_Create_Existing_Department_Existing()
        {
            var allDepartments = await _repository.GetAllDepartmentsAsync();
            Assert.NotNull(allDepartments);
            Assert.IsEmpty(allDepartments);

            var department = new Department()
            {
                DayforceDepartmentName = "Test",
                DayForceGlCode = "1",
                DnaOrgNbr = "1",
                State = DepartmentState.Active,
                DepartmentName = "Operations",
                BusinessLineCode = BusinessLine.Operations.Code
            };
            var rawData = new Dictionary<string, string>();
            rawData["EmploymentStatus_ShortName"] = "Active";
            rawData["Employee_DisplayName"] = "Doe, Test";
            rawData["EmployeeEmploymentStatus_EmployeeNumber"] = "11771";
            rawData["IdLibrary_LoginName"] = "testdoe@landmarkcu.com";
            rawData["OrgUnit_ShortName"] = "Test1 - OPERATIONS";
            rawData["Job_ShortName"] = "TELLER II";
            rawData["Employee_HireDate"] = "2019-09-23T00:00:00.0000000";
            rawData["OrgUnit_LedgerCode"] = "100";
            var employee = new ActiveEmployeeResult(rawData);
            var saved = await _repository.SaveDepartmentAsync(department);
            Assert.NotNull(saved);
            await _context.SaveChangesAsync();

            var found = await _repository.FindOrCreateDepartment(employee);
            await _context.SaveChangesAsync();
            Assert.NotNull(found);

            allDepartments = await _repository.GetAllDepartmentsAsync();
            Assert.NotNull(allDepartments);
            Assert.AreEqual(1, allDepartments.Count);
        }

        [Test]
        public async Task Find_Or_Create_Existing_Department_Create()
        {
            var allDepartments = await _repository.GetAllDepartmentsAsync();
            Assert.NotNull(allDepartments);
            Assert.IsEmpty(allDepartments);

            var department = new Department()
            {
                DayforceDepartmentName = "Test",
                DayForceGlCode = "1",
                DnaOrgNbr = "1",
                State = DepartmentState.Active,
                DepartmentName = "Big Department",
                BusinessLineCode = BusinessLine.Operations.Code
            };
            var rawData = new Dictionary<string, string>();
            rawData["EmploymentStatus_ShortName"] = "Active";
            rawData["Employee_DisplayName"] = "Doe, Test";
            rawData["EmployeeEmploymentStatus_EmployeeNumber"] = "11771";
            rawData["IdLibrary_LoginName"] = "testdoe@landmarkcu.com";
            rawData["OrgUnit_ShortName"] = "HEADQUARTERS - OPERATIONS";
            rawData["Job_ShortName"] = "TELLER II";
            rawData["Employee_HireDate"] = "2019-09-23T00:00:00.0000000";
            rawData["OrgUnit_LedgerCode"] = "101";
            var employee = new ActiveEmployeeResult(rawData);
            var saved = await _repository.SaveDepartmentAsync(department);
            Assert.NotNull(saved);
            await _context.SaveChangesAsync();

            // This should cause the department to be created.
            var found = await _repository.FindOrCreateDepartment(employee);
            Assert.AreEqual("101", found.DayForceGlCode);
            Assert.AreEqual("1101", found.DnaOrgNbr);
            await _context.SaveChangesAsync();
            Assert.NotNull(found);

            allDepartments = await _repository.GetAllDepartmentsAsync();
            Assert.NotNull(allDepartments);
            Assert.AreEqual(2, allDepartments.Count);
        }

        [TestCase("HEADQUARTERS - SECURITY & FRAUD", "SECURITY & FRAUD")]
        [TestCase("HEADQUARTERS - OPERATIONS", "OPERATIONS")]
        [TestCase("headquarters - operations", "operations")]
        [TestCase("GERMANTOWN - BRANCH", "GERMANTOWN")]
        [TestCase("GERMANTOWN", "GERMANTOWN")]
        [TestCase("NEW BERLIN - MORTGAGE ORIGINATION", "MORTGAGE ORIGINATION")]
        [TestCase("WAUKESHA - LIC", "LIC")]
        [TestCase(null, null)]
        [TestCase("  ", null)]
        public void DetermineDepartmentName(string rawName, string expectedResult)
        {
            Assert.AreEqual(DepartmentRepository.DetermineDepartmentName(rawName), expectedResult);
        }

        [Test]
        public async Task Find_Department_Assignments_Basic()
        {
            var department = new Department()
            {
                DayforceDepartmentName = "Test",
                DayForceGlCode = "1",
                DnaOrgNbr = "1",
                State = DepartmentState.Active,
                DepartmentName = "TestDept1",
                BusinessLineCode = BusinessLine.Operations.Code
            };
            var department2 = new Department()
            {
                DayforceDepartmentName = "Test",
                DayForceGlCode = "1",
                DnaOrgNbr = "1",
                State = DepartmentState.Active,
                DepartmentName = "TestDept2",
                BusinessLineCode = BusinessLine.Operations.Code
            };
            await _repository.SaveDepartmentAsync(department);
            await _repository.SaveDepartmentAsync(department2);

            await _context.SaveChangesAsync();

            var user1 = new AppUser()
            {
                Id = Guid.NewGuid(),
                Role = Role.Admin,
                FullName = "Test",
                AdEmail = "test1@test.com",
                BaseRole = "myrole",
                HomeDepartment = "Test Dept",
                EmployeeId = "123",
                PersonId = 1
            };
            var user2 = new AppUser()
            {
                Id = Guid.NewGuid(),
                Role = Role.Admin,
                FullName = "Test",
                AdEmail = "test2@test.com",
                BaseRole = "myrole",
                HomeDepartment = "Test Dept",
                EmployeeId = "456",
                PersonId = 1
            };
            var user3 = new AppUser()
            {
                Id = Guid.NewGuid(),
                Role = Role.Admin,
                FullName = "Test",
                AdEmail = "test3@test.com",
                BaseRole = "myrole",
                HomeDepartment = "Test Dept",
                EmployeeId = "789",
                PersonId = 1
            };
            await _context.AppUsers.AddAsync(user1);
            await _context.AppUsers.AddAsync(user2);
            await _context.AppUsers.AddAsync(user3);
            await _context.SaveChangesAsync();

            var inThePast = new DateTime(2010, 12, 1);
            var recent = new DateTime(2021, 10, 1);

            var assignment1 = new UserDepartment()
            {
                Department = department,
                Employee = user1,
                Note = "Default!",
                IsHome = true,
                StartDate = inThePast,
                Role = Role.BM
            };
            var assignment2 = new UserDepartment()
            {
                Department = department,
                Employee = user2,
                Note = "Default!",
                IsHome = true,
                StartDate = inThePast,
                Role = Role.BM
            };
            var assignment3 = new UserDepartment()
            {
                Department = department2,
                Employee = user2,
                Note = "Default!",
                IsHome = true,
                StartDate = inThePast,
                Role = Role.BM
            };
            _context.DepartmentAssignments.Add(assignment1);
            _context.DepartmentAssignments.Add(assignment2);
            _context.DepartmentAssignments.Add(assignment3);
            await _context.SaveChangesAsync();

            var query = new DepartmentPersonnelSearchRequest
            {
                DepartmentId = department.Id.Value,
                Year = recent.Year,
                Month = recent.Month
            };

            var found = await _repository.FindDepartmentAssignments(query);
            Assert.NotNull(found);
            Assert.AreEqual(2, found.Count);

            assignment1.Role = Role.MISSING_ROLE;
            await _context.SaveChangesAsync();
            found = await _repository.FindDepartmentAssignments(query);
            Assert.NotNull(found);
            Assert.AreEqual(1, found.Count);
        }

        [Test]
        public async Task Find_Department_Assignments_NonMatch_OpenEnded()
        {
            var department = new Department()
            {
                DayforceDepartmentName = "Test",
                DayForceGlCode = "1",
                DnaOrgNbr = "1",
                State = DepartmentState.Active,
                DepartmentName = "TestDept1",
                BusinessLineCode = BusinessLine.Operations.Code
            };
            await _repository.SaveDepartmentAsync(department);

            await _context.SaveChangesAsync();

            var user1 = new AppUser()
            {
                Id = Guid.NewGuid(),
                FullName = "Test",
                Role = Role.Admin,
                AdEmail = "test1@test.com",
                BaseRole = "myrole",
                HomeDepartment = "Test Dept",
                EmployeeId = "123",
                PersonId = 1
            };
            var user2 = new AppUser()
            {
                Id = Guid.NewGuid(),
                FullName = "Test",
                Role = Role.Admin,
                AdEmail = "test2@test.com",
                BaseRole = "myrole",
                HomeDepartment = "Test Dept",
                EmployeeId = "456",
                PersonId = 1
            };
            await _context.AppUsers.AddAsync(user1);
            await _context.AppUsers.AddAsync(user2);
            await _context.SaveChangesAsync();

            var inThePast = DateTime.Today.Subtract(TimeSpan.FromDays(3));

            var assignment1 = new UserDepartment()
            {
                Department = department,
                Employee = user1,
                Note = "Default!",
                IsHome = true,
                StartDate = inThePast,
                Role = Role.BM
            };
            var assignment2 = new UserDepartment()
            {
                Department = department,
                Employee = user2,
                Note = "Default!",
                IsHome = true,
                StartDate = inThePast,
                Role = Role.BM
            };
            _context.DepartmentAssignments.Add(assignment1);
            _context.DepartmentAssignments.Add(assignment2);
            await _context.SaveChangesAsync();

            var searchRequest = new DepartmentPersonnelSearchRequest
            {
                DepartmentId = department.Id.Value,
                Year = inThePast.Year,
                Month = inThePast.Month
            };
            var found = await _repository.FindDepartmentAssignments(searchRequest);
            Assert.NotNull(found);
            Assert.AreEqual(2, found.Count);

            var searchRequest2 = new DepartmentPersonnelSearchRequest
            {
                DepartmentId = department.Id.Value,
                Year = inThePast.Subtract(TimeSpan.FromDays(400)).Year,
                Month = inThePast.Month
            };
            found = await _repository.FindDepartmentAssignments(searchRequest2);
            Assert.NotNull(found);
            Assert.AreEqual(0, found.Count);

            var searchRequest3 = new DepartmentPersonnelSearchRequest
            {
                DepartmentId = department.Id.Value,
                Year = inThePast.Add(TimeSpan.FromDays(400)).Year,
                Month = inThePast.Month
            };
            found = await _repository.FindDepartmentAssignments(searchRequest3);
            Assert.NotNull(found);
            Assert.AreEqual(2, found.Count);
        }

        [Test]
        public async Task Find_Department_Assignments_NonMatch_CloseEnded()
        {
            var department = new Department()
            {
                DayforceDepartmentName = "Test",
                DayForceGlCode = "1",
                DnaOrgNbr = "1",
                State = DepartmentState.Active,
                DepartmentName = "TestDept1",
                BusinessLineCode = BusinessLine.Operations.Code
            };
            await _repository.SaveDepartmentAsync(department);

            await _context.SaveChangesAsync();

            var user1 = new AppUser()
            {
                Id = Guid.NewGuid(),
                FullName = "Test",
                Role = Role.Admin,
                AdEmail = "test1@test.com",
                BaseRole = "myrole",
                HomeDepartment = "Test Dept",
                EmployeeId = "123",
                PersonId = 1
            };
            var user2 = new AppUser()
            {
                Id = Guid.NewGuid(),
                FullName = "Test",
                Role = Role.Admin,
                AdEmail = "test2@test.com",
                BaseRole = "myrole",
                HomeDepartment = "Test Dept",
                EmployeeId = "456",
                PersonId = 1
            };
            await _context.AppUsers.AddAsync(user1);
            await _context.AppUsers.AddAsync(user2);
            await _context.SaveChangesAsync();

            var inThePast = DateTime.Today.Subtract(TimeSpan.FromDays(30));
            var inTheFuture = DateTime.Today.Add(TimeSpan.FromDays(30));

            var assignment1 = new UserDepartment()
            {
                Department = department,
                Employee = user1,
                Note = "Default!",
                IsHome = true,
                StartDate = inThePast,
                EndDate = inTheFuture,
                Role = Role.BM
            };
            var assignment2 = new UserDepartment()
            {
                Department = department,
                Employee = user2,
                Note = "Default!",
                IsHome = true,
                StartDate = inThePast,
                Role = Role.BM
            };
            _context.DepartmentAssignments.Add(assignment1);
            _context.DepartmentAssignments.Add(assignment2);
            await _context.SaveChangesAsync();

            var searchRequest = new DepartmentPersonnelSearchRequest
            {
                DepartmentId = department.Id.Value,
                Year = inThePast.Year,
                Month = inThePast.Month
            };
            var found = await _repository.FindDepartmentAssignments(searchRequest);
            Assert.NotNull(found);
            Assert.AreEqual(2, found.Count);

            var searchRequest2 = new DepartmentPersonnelSearchRequest
            {
                DepartmentId = department.Id.Value,
                Year = inThePast.Subtract(TimeSpan.FromDays(400)).Year,
                Month = inThePast.Month
            };
            found = await _repository.FindDepartmentAssignments(searchRequest2);
            Assert.NotNull(found);
            Assert.AreEqual(0, found.Count);

            var searchRequest3 = new DepartmentPersonnelSearchRequest
            {
                DepartmentId = department.Id.Value,
                Year = inThePast.Add(TimeSpan.FromDays(400)).Year,
                Month = inThePast.Month
            };
            found = await _repository.FindDepartmentAssignments(searchRequest3);
            Assert.NotNull(found);
            Assert.AreEqual(1, found.Count);
        }

        /// <summary>
        /// Tests searching for long periods
        /// </summary>
        /// <param name="assignStart">When the employee department assignment starts</param>
        /// <param name="assignEnd">When the employee department assignment ends</param>
        /// <param name="searchStart">when the search starts</param>
        /// <param name="searchEnd">when the search ends</param>
        /// <param name="included">should this assignment be found?</param>
        // Test Case 1, Ends before search starts
        [TestCase("01/01/2020", "12/31/2020", "01/01/2021", "12/31/2021", false)]
        // Test Case 2, Starts before search, ends during
        [TestCase("12/01/2020", "01/31/2021", "01/01/2021", "12/31/2021", true)]
        // Test Case 3, Starts during, ends during
        [TestCase("01/02/2021", "11/30/2021", "01/01/2021", "12/31/2021", true)]
        // Test Case 4, Starts during, ends after
        [TestCase("01/01/2021", "01/31/2022", "01/01/2021", "12/31/2021", true)]
        // Test Case 5, Starts after
        [TestCase("01/01/2022", "12/31/2022", "01/01/2021", "12/31/2021", false)]
        // Test Case 6, Starts before, no assignment end
        [TestCase("01/01/2021", "", "01/01/2021", "12/31/2021", true)]
        [TestCase("12/31/2020", "", "01/01/2021", "12/31/2021", true)]
        // Test Case 7, Starts during, no assignment end
        [TestCase("07/01/2021", "", "01/01/2021", "12/31/2021", true)]
        // Test Case 8, starts after, no assignment end, also check "on" which IS included...
        [TestCase("12/31/2021", "", "01/01/2021", "12/31/2021", true)]
        [TestCase("01/01/2022", "", "01/01/2021", "12/31/2021", false)]
        public async Task Find_Department_Assignments_ForMonthRange_Long(
            string assignStart,
            string assignEnd,
            string searchStart,
            string searchEnd,
            bool included
        )
        {
            var department = new Department()
            {
                DayforceDepartmentName = "Test",
                DayForceGlCode = "1",
                DnaOrgNbr = "1",
                State = DepartmentState.Active,
                DepartmentName = "TestDept1",
                BusinessLineCode = BusinessLine.Operations.Code
            };
            await _repository.SaveDepartmentAsync(department);
            await _context.SaveChangesAsync();

            var user1 = new AppUser()
            {
                Id = Guid.NewGuid(),
                FullName = "Test",
                Role = Role.Admin,
                AdEmail = "test1@test.com",
                BaseRole = "myrole",
                HomeDepartment = "Test Dept",
                EmployeeId = "123",
                PersonId = 1
            };
            await _context.AppUsers.AddAsync(user1);
            await _context.SaveChangesAsync();

            var assignment1 = new UserDepartment()
            {
                Department = department,
                Employee = user1,
                Note = "Default!",
                IsHome = true,
                StartDate = DateTime.Parse(assignStart),
                Role = Role.BM
            };
            if (!string.IsNullOrWhiteSpace(assignEnd))
            {
                assignment1.EndDate = DateTime.Parse(assignEnd);
            }

            _context.DepartmentAssignments.Add(assignment1);
            await _context.SaveChangesAsync();

            var start = DateTime.Parse(searchStart);
            var end = DateTime.Parse(searchEnd);
            var range = new MonthRange(
                start.Year,
                start.Month,
                end.Year,
                end.Month
            );
            var found = await _repository.FindDepartmentAssignmentsForRange(department.Id.Value, range);
            Assert.NotNull(found);
            if (included)
            {
                Assert.IsNotEmpty(found);
                Assert.AreEqual(1, found.Count);
            }
            else
            {
                Assert.IsEmpty(found);
            }
        }

        /// <summary>
        /// Tests searching for just single months
        /// </summary>
        /// <param name="assignStart">When the employee department assignment starts</param>
        /// <param name="assignEnd">When the employee department assignment ends</param>
        /// <param name="searchStart">when the search starts</param>
        /// <param name="searchEnd">when the search ends</param>
        /// <param name="included">should this assignment be found?</param>
        // Test Case 1, Ends before assignment starts
        [TestCase("05/01/2021", "05/31/2021", "06/01/2021", false)]
        // Test Case 2, Starts before assignment, ends during
        [TestCase("05/01/2021", "06/30/2021", "06/01/2021", true)]
        // Test Case 3, Starts during, ends during
        [TestCase("06/10/2021", "06/24/2021", "06/01/2021", true)]
        // Test Case 4, Starts during, ends after
        [TestCase("06/05/2021", "12/31/2021", "06/01/2021", true)]
        // Test Case 5, Starts after
        [TestCase("07/01/2021", "12/31/2021", "06/01/2021", false)]
        // Test Case 6, Starts before, no assignment end
        [TestCase("06/01/2021", "", "06/01/2021", true)]
        [TestCase("05/15/2021", "", "06/01/2021", true)]
        // Test Case 7, Starts during, no assignment end
        [TestCase("06/05/2021", "", "06/01/2021", true)]
        // Test Case 8, starts after, no assignment end, also check "on" which IS included...
        [TestCase("06/30/2021", "", "06/01/2021", true)]
        [TestCase("07/01/2021", "", "06/01/2021", false)]
        public async Task Find_Department_Assignments_ForMonthRange_Short(string assignStart, string assignEnd, string searchStart, bool included)
        {
            var department = new Department()
            {
                DayforceDepartmentName = "Test",
                DayForceGlCode = "1",
                DnaOrgNbr = "1",
                State = DepartmentState.Active,
                DepartmentName = "TestDept1",
                BusinessLineCode = BusinessLine.Operations.Code
            };
            await _repository.SaveDepartmentAsync(department);
            await _context.SaveChangesAsync();

            var user1 = new AppUser()
            {
                Id = Guid.NewGuid(),
                FullName = "Test",
                Role = Role.Admin,
                AdEmail = "test1@test.com",
                BaseRole = "myrole",
                HomeDepartment = "Test Dept",
                EmployeeId = "123",
                PersonId = 1
            };
            await _context.AppUsers.AddAsync(user1);
            await _context.SaveChangesAsync();

            var assignment1 = new UserDepartment()
            {
                Department = department,
                Employee = user1,
                Note = "Default!",
                IsHome = true,
                StartDate = DateTime.Parse(assignStart),
                Role = Role.BM
            };
            if (!string.IsNullOrWhiteSpace(assignEnd))
            {
                assignment1.EndDate = DateTime.Parse(assignEnd);
            }

            _context.DepartmentAssignments.Add(assignment1);
            await _context.SaveChangesAsync();

            var start = DateTime.Parse(searchStart);
            var range = new MonthRange(start.Year, start.Month);
            var found = await _repository.FindDepartmentAssignmentsForRange(department.Id.Value, range);
            Assert.NotNull(found);
            if (included)
            {
                Assert.IsNotEmpty(found);
                Assert.AreEqual(1, found.Count);
            }
            else
            {
                Assert.IsEmpty(found);
            }
        }

        public async Task Find_Department_Assignments_ForMonthRange_Multi()
        {
            var department = new Department()
            {
                DayforceDepartmentName = "Test",
                DayForceGlCode = "1",
                DnaOrgNbr = "1",
                State = DepartmentState.Active,
                DepartmentName = "TestDept1",
                BusinessLineCode = BusinessLine.Operations.Code
            };
            await _repository.SaveDepartmentAsync(department);
            await _context.SaveChangesAsync();

            var user1 = new AppUser()
            {
                Id = Guid.NewGuid(),
                AdEmail = "test1@test.com",
                EmployeeId = "123"
            };
            await _context.AppUsers.AddAsync(user1);
            await _context.SaveChangesAsync();

            var assignment1 = new UserDepartment()
            {
                Department = department,
                Employee = user1,
                Note = "Default!",
                IsHome = true,
                StartDate = DateTime.Parse("06/02/2021"),
                EndDate = DateTime.Parse("06/14/2021"),
                Role = Role.BM
            };

            var assignment2 = new UserDepartment()
            {
                Department = department,
                Employee = user1,
                Note = "Default!",
                IsHome = true,
                StartDate = DateTime.Parse("06/16/2021"),
                EndDate = DateTime.Parse("06/30/2021"),
                Role = Role.BM
            };

            _context.DepartmentAssignments.Add(assignment1);
            _context.DepartmentAssignments.Add(assignment2);
            await _context.SaveChangesAsync();

            var start = DateTime.Parse("06/01/2021");
            var range = new MonthRange(start.Year, start.Month);
            var found = await _repository.FindDepartmentAssignmentsForRange(department.Id.Value, range);
            Assert.NotNull(found);
            Assert.IsNotEmpty(found);
            Assert.AreEqual(1, found.Count);

            var search = new DepartmentPersonnelSearchRequest()
            {
                Month = start.Month,
                Year = start.Year,
                DepartmentId = department.Id.Value,
                IncludeAllPersonnel = true
            };
            var users = await _repository.FindDepartmentAssignments(search);
            Assert.NotNull(users);
            Assert.IsNotEmpty(users);
            Assert.AreEqual(1, users.Count);
        }

        [Test]
        public async Task Find_Department_Assignments_With_Sales_Goal_Permission()
        {
            var department = new Department()
            {
                DayforceDepartmentName = "Test",
                DayForceGlCode = "1",
                DnaOrgNbr = "1",
                State = DepartmentState.Active,
                DepartmentName = "TestDept1",
                BusinessLineCode = BusinessLine.Operations.Code
            };
            await _repository.SaveDepartmentAsync(department);

            await _context.SaveChangesAsync();

            var userWithNoSalesGoalsPermission = new AppUser()
            {
                Id = Guid.NewGuid(),
                FullName = "Test",
                Role = Role.Admin,
                AdEmail = "test1@test.com",
                BaseRole = "myrole",
                HomeDepartment = "Test Dept",
                EmployeeId = "123",
                PersonId = 1
            };

            var userWithSalesGoalsRolePermission = new AppUser()
            {
                Id = Guid.NewGuid(),
                FullName = "Test",
                Role = Role.Admin,
                AdEmail = "test2@test.com",
                BaseRole = "myrole",
                HomeDepartment = "Test Dept",
                EmployeeId = "456",
                PersonId = 2
            };

            var userWithSalesGoalsAdditionalPermission = new AppUser()
            {
                Id = Guid.NewGuid(),
                FullName = "Test",
                Role = Role.Admin,
                AdEmail = "test3@test.com",
                BaseRole = "myrole",
                HomeDepartment = "Test Dept",
                EmployeeId = "789",
                PersonId = 3,
                AdditionalPermissions = new List<UserPermission>
                {
                    new UserPermission
                    {
                        Permission = Permission.HaveSalesGoals
                    }
                }
            };

            await _context.AppUsers.AddAsync(userWithNoSalesGoalsPermission);
            await _context.AppUsers.AddAsync(userWithSalesGoalsRolePermission);
            await _context.AppUsers.AddAsync(userWithSalesGoalsAdditionalPermission);
            await _context.SaveChangesAsync();

            var inThePast = DateTime.Today.Subtract(TimeSpan.FromDays(3));

            var assignment1 = new UserDepartment()
            {
                Department = department,
                Employee = userWithNoSalesGoalsPermission,
                Note = "Default!",
                IsHome = true,
                StartDate = inThePast,
                Role = Role.Teller
            };
            var assignment2 = new UserDepartment()
            {
                Department = department,
                Employee = userWithSalesGoalsRolePermission,
                Note = "Default!",
                IsHome = true,
                StartDate = inThePast,
                Role = Role.BM
            };
            var assignment3 = new UserDepartment()
            {
                Department = department,
                Employee = userWithSalesGoalsAdditionalPermission,
                Note = "Default!",
                IsHome = true,
                StartDate = inThePast,
                Role = Role.Teller
            };
            _context.DepartmentAssignments.Add(assignment1);
            _context.DepartmentAssignments.Add(assignment2);
            _context.DepartmentAssignments.Add(assignment3);
            await _context.SaveChangesAsync();

            var searchRequest3 = new DepartmentPersonnelSearchRequest
            {
                DepartmentId = department.Id.Value,
                Year = inThePast.Year,
                Month = inThePast.Month
            };

            var found = await _repository.FindDepartmentAssignments(searchRequest3);
            Assert.NotNull(found);
            Assert.True(found.Exists(x => x.PersonId == 2));
            Assert.True(found.Exists(x => x.PersonId == 3));
        }

        [Test]
        public async Task Find_User_Home_Department_OK()
        {
            var department = new Department()
            {
                DayforceDepartmentName = "Test",
                DayForceGlCode = "1",
                DnaOrgNbr = "1",
                State = DepartmentState.Active,
                DepartmentName = "TestDept1",
                BusinessLineCode = BusinessLine.Operations.Code
            };
            var department2 = new Department()
            {
                DayforceDepartmentName = "Test",
                DayForceGlCode = "1",
                DnaOrgNbr = "1",
                State = DepartmentState.Active,
                DepartmentName = "TestDept2",
                BusinessLineCode = BusinessLine.Operations.Code
            };
            await _repository.SaveDepartmentAsync(department);
            await _repository.SaveDepartmentAsync(department2);

            await _context.SaveChangesAsync();

            var user1 = new AppUser()
            {
                Id = Guid.NewGuid(),
                FullName = "Test",
                Role = Role.Admin,
                AdEmail = "test1@test.com",
                BaseRole = "myrole",
                HomeDepartment = "Test Dept",
                EmployeeId = "123",
                PersonId = 1
            };
            var user2 = new AppUser()
            {
                Id = Guid.NewGuid(),
                FullName = "Test",
                Role = Role.Admin,
                AdEmail = "test2@test.com",
                BaseRole = "myrole",
                HomeDepartment = "Test Dept",
                EmployeeId = "456",
                PersonId = 1
            };
            var user3 = new AppUser()
            {
                Id = Guid.NewGuid(),
                FullName = "Test",
                Role = Role.Admin,
                AdEmail = "test3@test.com",
                BaseRole = "myrole",
                HomeDepartment = "Test Dept",
                EmployeeId = "789",
                PersonId = 1
            };
            var user4 = new AppUser()
            {
                Id = Guid.NewGuid(),
                FullName = "Test",
                Role = Role.Admin,
                AdEmail = "test3@test.com",
                BaseRole = "myrole",
                HomeDepartment = "Test Dept",
                EmployeeId = "101",
                PersonId = 1
            };
            await _context.AppUsers.AddAsync(user1);
            await _context.AppUsers.AddAsync(user2);
            await _context.AppUsers.AddAsync(user3);
            await _context.AppUsers.AddAsync(user4);
            await _context.SaveChangesAsync();

            var inThePast = DateTime.Today.Subtract(TimeSpan.FromDays(3));

            var assignment1 = new UserDepartment()
            {
                Role = Role.Admin,
                Department = department,
                Employee = user1,
                Note = "Default!",
                IsHome = true,
                StartDate = inThePast
            };
            var assignment2 = new UserDepartment()
            {
                Role = Role.Admin,
                Department = department,
                Employee = user2,
                Note = "Default!",
                IsHome = true,
                StartDate = inThePast
            };
            var assignment5 = new UserDepartment()
            {
                Role = Role.Admin,
                Department = department2,
                Employee = user2,
                Note = "Default!",
                IsHome = true,
                StartDate = inThePast
            };
            var assignment3 = new UserDepartment()
            {
                Role = Role.Admin,
                Department = department2,
                Employee = user3,
                Note = "Default!",
                IsHome = true,
                StartDate = inThePast
            };
            var assignment4 = new UserDepartment()
            {
                Role = Role.Admin,
                Department = department,
                Employee = user3,
                Note = "Default!",
                IsHome = false,
                StartDate = inThePast
            };
            var assignment6 = new UserDepartment()
            {
                Role = Role.Admin,
                Department = department,
                Employee = user4,
                Note = "Default!",
                IsHome = true,
                StartDate = inThePast,
                EndDate = inThePast
            };
            var assignment7 = new UserDepartment()
            {
                Role = Role.Admin,
                Department = department2,
                Employee = user4,
                Note = "Default!",
                IsHome = true,
                StartDate = inThePast,
                EndDate = null
            };
            _context.DepartmentAssignments.Add(assignment1);
            _context.DepartmentAssignments.Add(assignment2);
            _context.DepartmentAssignments.Add(assignment3);
            _context.DepartmentAssignments.Add(assignment4);
            _context.DepartmentAssignments.Add(assignment5);
            _context.DepartmentAssignments.Add(assignment6);
            _context.DepartmentAssignments.Add(assignment7);
            await _context.SaveChangesAsync();

            //Ok
            var res = await _repository.FindUserHomeDepartment(user3);
            Assert.AreEqual(res, department2);

            res = await _repository.FindUserHomeDepartment(user1);
            Assert.AreEqual(res, department);

            //Non-existing user
            res = await _repository.FindUserHomeDepartment(new AppUser()
            {
                AdEmail = "notfound@test.com",
                BaseRole = "newrole",
                HomeDepartment = "Other Dept",
                EmployeeId = "56565",
                PersonId = 100
            });
            Assert.Null(res);

            //User with multiple non-current home departments
            res = await _repository.FindUserHomeDepartment(user2);
            Assert.Null(res);

            //User with multiple home departments, one current, one non-current
            res = await _repository.FindUserHomeDepartment(user4);
            Assert.AreEqual(res, department2);
        }

        [Test]
        public async Task FindDepartmentByBranchName_OK()
        {
            var department = new Department()
            {
                DayforceDepartmentName = "Test",
                DayForceGlCode = "1",
                DnaOrgNbr = "1",
                State = DepartmentState.Active,
                DepartmentName = "MEQUON",
                BusinessLineCode = BusinessLine.Operations.Code
            };
            var department2 = new Department()
            {
                DayforceDepartmentName = "Test",
                DayForceGlCode = "1",
                DnaOrgNbr = "1",
                State = DepartmentState.Active,
                DepartmentName = "WAUKESHA MAIN",
                BusinessLineCode = BusinessLine.Operations.Code
            };
            await _repository.SaveDepartmentAsync(department);
            await _repository.SaveDepartmentAsync(department2);
            await _context.SaveChangesAsync();

            var res = await _repository.FindDepartmentByBranchName("Mequon");
            Assert.AreEqual(department, res);

            res = await _repository.FindDepartmentByBranchName("Waukesha main");
            Assert.AreEqual(department2, res);

            res = await _repository.FindDepartmentByBranchName("Mars base 1");
            Assert.Null(res);
        }

        [Test]
        public async Task FindCurrentDepartmentAssignments_OK()
        {
            var user1 = new AppUser
            {
                Id = Guid.NewGuid(),
                AdEmail = "user1@landmarkcu.com", EmployeeId = "C0001", PersonId = 1, BaseRole = "Role", FullName = "Test", HomeDepartment = "Test",
                Role = Role.Admin
            };
            var user2 = new AppUser
            {
                Id = Guid.NewGuid(),
                AdEmail = "user2@landmarkcu.com", EmployeeId = "C0002", PersonId = 2, BaseRole = "Role", FullName = "Test", HomeDepartment = "Test",
                Role = Role.Admin
            };
            var yesterday = DateTime.Now.AddDays(-1);

            var testDepartment = (new Department()
            {
                BusinessLineCode = BusinessLine.Operations.Code,
                DayforceDepartmentName = "Test",
                DayForceGlCode = "1",
                DnaOrgNbr = "1",
                DepartmentName = "TestName",
                Assignments = new List<UserDepartment>
                {
                    new UserDepartment { Role = Role.Admin, Id = 11, StartDate = yesterday, Employee = user1 },
                    new UserDepartment { Role = Role.Admin, Id = 12, StartDate = yesterday, Employee = user2 }
                }
            });

            await _repository.SaveDepartmentAsync(testDepartment);
            await _context.SaveChangesAsync();

            var result = await _repository.FindCurrentDepartmentAssignments(1);

            Assert.AreEqual(2, result.Count);
            Assert.AreEqual(11, result.ElementAt(0).Id);
            Assert.AreEqual("C0001", result.ElementAt(0).Employee.EmployeeId);
            Assert.AreEqual(12, result.ElementAt(1).Id);
            Assert.AreEqual("C0002", result.ElementAt(1).Employee.EmployeeId);
        }

        [Test]
        public async Task FindCurrentDepartmentAssignments_EndDatePassed()
        {
            var user1 = new AppUser
            {
                Id = Guid.NewGuid(),
                AdEmail = "user1@landmarkcu.com", EmployeeId = "C0001", PersonId = 1, BaseRole = "Role", FullName = "Test", HomeDepartment = "Test",
                Role = Role.Admin
            };
            var user2 = new AppUser
            {
                Id = Guid.NewGuid(),
                AdEmail = "user2@landmarkcu.com", EmployeeId = "C0002", PersonId = 2, BaseRole = "Role", FullName = "Test", HomeDepartment = "Test",
                Role = Role.Admin
            };
            var yesterday = DateTime.Now.AddDays(-1);
            var lastMonth = DateTime.Now.AddMonths(-1);

            var testDepartment = (new Department()
            {
                BusinessLineCode = BusinessLine.Operations.Code,
                DayforceDepartmentName = "Test",
                DayForceGlCode = "1",
                DnaOrgNbr = "1",
                DepartmentName = "TestName",
                Assignments = new List<UserDepartment>
                {
                    new UserDepartment { Role = Role.Admin, Id = 11, StartDate = lastMonth, EndDate = lastMonth, Employee = user1 },
                    new UserDepartment { Role = Role.Admin, Id = 12, StartDate = yesterday, Employee = user2 }
                }
            });

            await _repository.SaveDepartmentAsync(testDepartment);
            await _context.SaveChangesAsync();

            var result = await _repository.FindCurrentDepartmentAssignments(1);

            Assert.AreEqual(1, result.Count);
            Assert.AreEqual(12, result.ElementAt(0).Id);
            Assert.AreEqual("C0002", result.ElementAt(0).Employee.EmployeeId);
        }
    }
}