using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using LCU.API.Internal.Operations.IncentiveApiLib.Repositories;
using LCU.API.Internal.Operations.IncentiveApi.Services;
using LCU.Library.Internal.IncentiveApiModels.Entities;
using LCU.Library.Internal.IncentiveApiModels.Enums;
using Moq;
using NUnit.Framework;

namespace Application.UnitTests.Services
{
    public class AuthorizationServiceTest
    {
        private IAuthorizationService _service;
        private IDepartmentRepository _departmentRepository;
        private IUserAssignmentRepository _userAssignmentRepository;

        [SetUp]
        public void Setup()
        {
            _departmentRepository = Mock.Of<IDepartmentRepository>();
            _userAssignmentRepository = Mock.Of<IUserAssignmentRepository>();
            _service = new AuthorizationService(_departmentRepository, _userAssignmentRepository);
        }

        [Test]
        public async Task AppUserCanMakeStateChange_UserIsAdmin_ReturnsTrue()
        {
            var inThePast = DateTime.Now.AddDays(-90);

            var user = new AppUser
            {
                Departments = new List<UserDepartment>()
                {
                    new UserDepartment()
                    {
                        DepartmentId = 1,
                        StartDate = inThePast,
                        EndDate = inThePast.AddDays(-30),
                        Role = Role.BM
                    },
                    new UserDepartment()
                    {
                        DepartmentId = 2,
                        StartDate = inThePast,
                        EndDate = null,
                        Role = Role.Admin
                    },
                    new UserDepartment()
                    {
                        DepartmentId = 3,
                        StartDate = inThePast,
                        EndDate = null,
                        Role = Role.Mortgage
                    }
                }
            };

            var result = await _service.AppUserCanMakeStateChange(user, It.IsAny<Activity>(), It.IsAny<ActivityState>(), It.IsAny<int>());

            Assert.IsTrue(result);
        }

        [Test]
        public async Task AppUserCanMakeStateChange_UserHasPermissionInTargetDepartment_ReturnsTrue()
        {
            var inThePast = DateTime.Now.AddDays(-90);
            var targetDepartmentId = 2;
            var activity = new Activity()
            {
                State = ActivityState.PendingTransfer,
                DepartmentId = 1,
            };

            var user = new AppUser
            {
                Departments = new List<UserDepartment>()
                {
                    new UserDepartment()
                    {
                        DepartmentId = 1,
                        StartDate = inThePast,
                        EndDate = inThePast.AddDays(-30),
                        Role = Role.Manager
                    },
                    new UserDepartment()
                    {
                        DepartmentId = 1,
                        StartDate = inThePast,
                        EndDate = null,
                        Role = Role.Mortgage
                    },
                    new UserDepartment()
                    {
                        DepartmentId = targetDepartmentId,
                        StartDate = inThePast,
                        EndDate = null,
                        Role = Role.Manager
                    }
                }
            };

            var result = await _service.AppUserCanMakeStateChange(user, activity, ActivityState.Accepted, targetDepartmentId);

            Assert.IsTrue(result);
        }

        [Test]
        public async Task AppUserCanMakeStateChange_UserDoesNotHavePermissionInTargetDepartment_ReturnsFalse()
        {
            var inThePast = DateTime.Now.AddDays(-90);
            var targetDepartmentId = 5;
            var activity = new Activity()
            {
                State = ActivityState.PendingTransfer,
                DepartmentId = 1,
            };

            var user = new AppUser
            {
                Departments = new List<UserDepartment>()
                {
                    new UserDepartment()
                    {
                        DepartmentId = 1,
                        StartDate = inThePast,
                        EndDate = inThePast.AddDays(-30),
                        Role = Role.Manager
                    },
                    new UserDepartment()
                    {
                        DepartmentId = 2,
                        StartDate = inThePast,
                        EndDate = null,
                        Role = Role.Mortgage
                    },
                    new UserDepartment()
                    {
                        DepartmentId = 3,
                        StartDate = inThePast,
                        EndDate = null,
                        Role = Role.Manager
                    }
                }
            };

            var result = await _service.AppUserCanMakeStateChange(user, activity, ActivityState.Accepted, targetDepartmentId);

            Assert.False(result);
        }

        [Test]
        public async Task AppUserCanMakeStateChange_UserHasAdditionalPermissions_ReturnsTrue()
        {
            var inThePast = DateTime.Now.AddDays(-90);
            var targetDepartmentId = 5;
            var activity = new Activity()
            {
                State = ActivityState.PendingTransfer,
                DepartmentId = 1,
            };

            var user = new AppUser
            {
                Departments = new List<UserDepartment>()
                {
                    new UserDepartment()
                    {
                        DepartmentId = 1,
                        StartDate = inThePast,
                        EndDate = null,
                        Role = Role.Mortgage
                    }
                },
                AdditionalPermissions = new List<UserPermission>() {
                    new UserPermission()
                    {
                        Permission =  Permission.SetActivityToAcceptedFromPendingTransfer
                    },
                    new UserPermission()
                    {
                        Permission = Permission.SetActivityToTransferredFromPendingTransfer
                    }
                }
            };

            var result = await _service.AppUserCanMakeStateChange(user, activity, ActivityState.Accepted, targetDepartmentId);

            Assert.IsTrue(result);
        }

        [Test]
        public async Task HierarchicalDepartmentPermissionTest_Direct()
        {
            var testDepartment = new Department()
            {
                Id = 5,
                DepartmentName = "TestName",
                RegionCode = Region.North.Code
            };
            var yesterday = DateTime.Now.AddDays(-1);
            var user = new AppUser
            {
                AdEmail = "user@landmarkcu.com", EmployeeId = "C0000",
                Departments = new List<UserDepartment>()
                {
                    new UserDepartment()
                    {
                        DepartmentId = 5,
                        Department = testDepartment,
                        StartDate = yesterday,
                        Role = Role.BOM
                    }
                }
            };

            Mock.Get(_departmentRepository).Setup(mock => mock.FindDepartmentsByRegionAsync(Region.North)).ReturnsAsync(
                new List<Department>()
                {
                    testDepartment
                });

            var result = await _service.ValidateHierarchicalDepartmentPermission(user, new List<Role>() { Role.BOM }, testDepartment.Id.Value);
            Assert.True(result);
            result = await _service.ValidateHierarchicalDepartmentPermission(user, new List<Role>() { Role.BOM }, 99);
            Assert.False(result);
        }

        [Test]
        public async Task HierarchicalDepartmentPermissionTest_Admin()
        {
            var testDepartment = new Department()
            {
                Id = 5,
                DepartmentName = "TestName"
            };
            var yesterday = DateTime.Now.AddDays(-1);
            var user = new AppUser
            {
                AdEmail = "user@landmarkcu.com", EmployeeId = "C0000",
                Departments = new List<UserDepartment>()
                {
                    new UserDepartment()
                    {
                        DepartmentId = 5,
                        Department = testDepartment,
                        StartDate = yesterday,
                        Role = Role.Admin
                    }
                }
            };

            var result = await _service.ValidateHierarchicalDepartmentPermission(user, new List<Role>(), testDepartment.Id.Value);
            Assert.True(result);
            result = await _service.ValidateHierarchicalDepartmentPermission(user, new List<Role>(), 99);
            Assert.True(result);
        }


        [Test]
        [TestCase(true, 1, true)]
        [TestCase(false, 1, false)]
        public async Task HierarchicalDepartmentPermissionTest_VariedActiveRoleForDepartment(bool isAdmin, int activeDeptId, bool expected)
        {
            var inThePast = DateTime.Now.AddDays(-90);

            var user = new AppUser
            {
                Departments = new List<UserDepartment>()
                {
                    new UserDepartment()
                    {
                        DepartmentId = 2,
                        StartDate = inThePast,
                        EndDate = inThePast.AddDays(-30),
                        Role = isAdmin ? Role.Admin : Role.ABM
                    },
                    new UserDepartment()
                    {
                        DepartmentId = activeDeptId,
                        StartDate = inThePast,
                        EndDate = null,
                        Role = isAdmin ? Role.Admin : Role.ManagementTraineePFO
                    }
                }
            };

            var result = await _service.ValidateHierarchicalDepartmentPermission(user, Role.DepartmentManagerRoles, activeDeptId);

            Assert.AreEqual(expected, result);
        }

        [Test]
        public async Task RegionalManagerTest()
        {
            var testDepartment = new Department()
            {
                Id = 5,
                DepartmentName = "TestName",
                RegionCode = Region.North.Code
            };
            var yesterday = DateTime.Now.AddDays(-1);
            var user = new AppUser
            {
                AdEmail = "user@landmarkcu.com", EmployeeId = "C0000",
                Departments = new List<UserDepartment>()
                {
                    new UserDepartment()
                    {
                        DepartmentId = 5,
                        Department = testDepartment,
                        StartDate = yesterday,
                        Role = Role.RegionalManager
                    }
                }
            };

            Mock.Get(_departmentRepository).Setup(mock => mock.FindDepartmentsByRegionAsync(Region.North)).ReturnsAsync(
                new List<Department>()
                {
                    testDepartment
                });

            var result = await _service.ValidateIsRegionalManager(user, testDepartment.Id.Value);
            Assert.True(result);
            result = await _service.ValidateIsRegionalManager(user, 99);
            Assert.False(result);
        }

        [Test]
        public async Task RegionalManager_NoRegion_Test()
        {
            var testDepartment = new Department()
            {
                Id = 5,
                DepartmentName = "TestName"
            };
            var yesterday = DateTime.Now.AddDays(-1);
            var user = new AppUser
            {
                AdEmail = "user@landmarkcu.com", EmployeeId = "C0000",
                Departments = new List<UserDepartment>()
                {
                    new UserDepartment()
                    {
                        DepartmentId = 5,
                        Department = testDepartment,
                        StartDate = yesterday,
                        Role = Role.RegionalManager
                    }
                }
            };

            Mock.Get(_departmentRepository).Setup(mock => mock.FindDepartmentsByRegionAsync(Region.North)).ReturnsAsync(
                new List<Department>()
                {
                    testDepartment
                });

            var result = await _service.ValidateIsRegionalManager(user, testDepartment.Id.Value);
            Assert.True(result);
            result = await _service.ValidateIsRegionalManager(user, 99);
            Assert.False(result);
        }

        // User is RM in a non-region department, but is RM of NORTH.
        [Test]
        public async Task RegionalManager_NoRegion_OfficialRM_Test()
        {
            var testDepartment = new Department()
            {
                Id = 5,
                DepartmentName = "TestName"
            };
            var testDepartmentNorth = new Department()
            {
                Id = 6,
                DepartmentName = "TestName",
                RegionCode = Region.North.Code
            };
            var yesterday = DateTime.Now.AddDays(-1);
            var user = new AppUser
            {
                AdEmail = "user@landmarkcu.com", EmployeeId = "C0000",
                Departments = new List<UserDepartment>()
                {
                    new UserDepartment()
                    {
                        DepartmentId = 5,
                        Department = testDepartment,
                        StartDate = yesterday,
                        Role = Role.RegionalManager
                    }
                }
            };

            Mock.Get(_userAssignmentRepository).Setup(mock => mock.IsUserAssigned(AssignmentType.RegionalManager, user))
                .ReturnsAsync(
                    new UserAssignment()
                    {
                        Key = Region.North.Code
                    });
            Mock.Get(_departmentRepository).Setup(mock => mock.FindDepartmentsByRegionAsync(Region.North)).ReturnsAsync(
                new List<Department>()
                {
                    testDepartmentNorth
                });

            var result = await _service.ValidateIsRegionalManager(user, testDepartmentNorth.Id.Value);
            Assert.True(result);
            result = await _service.ValidateIsRegionalManager(user, 99);
            Assert.False(result);
        }

        [Test]
        public async Task BusinessLineManagerTest()
        {
            var testDepartment = new Department()
            {
                Id = 5,
                DepartmentName = "TestName",
                BusinessLineCode = BusinessLine.Operations.Code
            };
            var yesterday = DateTime.Now.AddDays(-1);
            var user = new AppUser
            {
                AdEmail = "user@landmarkcu.com", EmployeeId = "C0000",
                Departments = new List<UserDepartment>()
                {
                    new UserDepartment()
                    {
                        DepartmentId = 5,
                        Department = testDepartment,
                        StartDate = yesterday,
                        Role = Role.BusinessLineManager
                    }
                }
            };

            Mock.Get(_departmentRepository)
                .Setup(mock => mock.FindDepartmentsByBusinessLineAsync(BusinessLine.Operations)).ReturnsAsync(
                    new List<Department>()
                    {
                        testDepartment
                    });

            var result = await _service.ValidateIsBusinessLineManager(user, testDepartment.Id.Value);
            Assert.True(result);
            result = await _service.ValidateIsBusinessLineManager(user, 99);
            Assert.False(result);
        }

        [Test]
        public async Task BusinessLineManager_NoBusinessLine_Test()
        {
            var testDepartment = new Department()
            {
                Id = 5,
                DepartmentName = "TestName"
            };
            var yesterday = DateTime.Now.AddDays(-1);
            var user = new AppUser
            {
                AdEmail = "user@landmarkcu.com", EmployeeId = "C0000",
                Departments = new List<UserDepartment>()
                {
                    new UserDepartment()
                    {
                        DepartmentId = 5,
                        Department = testDepartment,
                        StartDate = yesterday,
                        Role = Role.BusinessLineManager
                    }
                }
            };

            Mock.Get(_departmentRepository)
                .Setup(mock => mock.FindDepartmentsByBusinessLineAsync(BusinessLine.Operations)).ReturnsAsync(
                    new List<Department>()
                    {
                        testDepartment
                    });

            var result = await _service.ValidateIsBusinessLineManager(user, testDepartment.Id.Value);
            Assert.True(result);
            result = await _service.ValidateIsBusinessLineManager(user, 99);
            Assert.False(result);
        }
    }
}