using LCU.API.Internal.Operations.IncentiveApi.Authorization;
using LCU.API.Internal.Operations.IncentiveApiLib.Persistence;
using LCU.API.Internal.Operations.IncentiveApiLib.Services;
using LCU.Library.Internal.IncentiveApiModels.Entities;
using Microsoft.AspNetCore.Authorization;
using Moq;
using NUnit.Framework;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace Application.UnitTests.Authorization
{
    public class WrappedPermissionAuthorizationHandler : PermissionAuthorizationHandler
    {
        public WrappedPermissionAuthorizationHandler(ICurrentUserService currentUserService, IUserService userService)
            : base(currentUserService, userService)
        {
        }

        public async Task WrappedHandleRequirementAsync(AuthorizationHandlerContext context, PermissionRequirement requirement)
        {
            await HandleRequirementAsync(context, requirement);
        }
    }

    public class PermissionAuthorizationHandlerTest
    {
        private WrappedPermissionAuthorizationHandler _handler;
        private Mock<ICurrentUserService> _mockCurrentUserService;
        private Mock<IUserService> _mockUserService;

        [SetUp]
        public void Setup()
        {
            _mockUserService = new Mock<IUserService>();
            _mockCurrentUserService = new Mock<ICurrentUserService>();
            _handler = new WrappedPermissionAuthorizationHandler(_mockCurrentUserService.Object,
                _mockUserService.Object);
        }

        [Test]
        public async Task HandleAsync_MatchingPermission_ContextHasSucceeded()
        {
            var appUser = new ApplicationUser { Email = "User@landmarkcu.com" };
            var user = new AppUser {
                Role = Role.OpsHelpDesk,
                Departments = new List<UserDepartment>()
                {
                    new UserDepartment()
                    {
                        DepartmentId = 55,
                        Role = Role.OpsHelpDesk
                    }
                }
            };
            _mockCurrentUserService.Setup(service => service.GetCurrentUser())
                .Returns(appUser);

            _mockUserService.Setup(service => service.UserHasAnyRequiredPermission(appUser.Email, It.IsAny<List<string>>()))
                .ReturnsAsync(true);

            var requirement = new PermissionRequirement("VIEW_DASHBOARD");
            var requirements = new List<IAuthorizationRequirement> { requirement };

            var _fakeContext = new AuthorizationHandlerContext(requirements, null, null);

            await _handler.WrappedHandleRequirementAsync(_fakeContext, requirement);

            Assert.True(_fakeContext.HasSucceeded);
        }

        [Test]
        public async Task HandleAsync_MatchingAdditionalPermission_ContextHasSucceeded()
        {
            var appUser = new ApplicationUser { Email = "User@landmarkcu.com" };
            var user = new AppUser {
                Role = Role.OpsHelpDesk,
                AdditionalPermissions = new List<UserPermission>()
                {
                    new UserPermission()
                    {
                        Permission = Permission.ViewDashboard
                    }
                }
            };
            _mockCurrentUserService.Setup(service => service.GetCurrentUser())
                .Returns(appUser);

            _mockUserService.Setup(service => service.UserHasAnyRequiredPermission(appUser.Email, It.IsAny<List<string>>()))
                .ReturnsAsync(true);

            var requirement = new PermissionRequirement("VIEW_DASHBOARD");
            var requirements = new List<IAuthorizationRequirement> { requirement };

            var _fakeContext = new AuthorizationHandlerContext(requirements, null, null);

            await _handler.WrappedHandleRequirementAsync(_fakeContext, requirement);

            Assert.True(_fakeContext.HasSucceeded);
        }

        [Test]
        public async Task HandleAsync_NoMatchingPermission_ContextHasFailed()
        {
            var appUser = new ApplicationUser { Email = "User@landmarkcu.com" };
            var user = new AppUser
            {
                Role = Role.OpsHelpDesk
            };
            _mockCurrentUserService.Setup(service => service.GetCurrentUser())
                .Returns(appUser);

            _mockUserService.Setup(service => service.GetUserByAdEmailAsync(appUser.Email))
                .ReturnsAsync(user);

            var requirement = new PermissionRequirement("NO_MATCH");
            var requirements = new List<IAuthorizationRequirement> { requirement };
            var _fakeContext = new AuthorizationHandlerContext(requirements, null, null);

            await _handler.WrappedHandleRequirementAsync(_fakeContext, requirement);

            Assert.True(_fakeContext.HasFailed);
        }

        [Test]
        public async Task HandleAsync_NoApplicationUserEmail_ContextHasFailed()
        {
            var appUser = new ApplicationUser();
            _mockCurrentUserService.Setup(service => service.GetCurrentUser())
                .Returns(appUser);
            var requirement = new PermissionRequirement("");
            var requirements = new List<IAuthorizationRequirement> { requirement };
            var _fakeContext = new AuthorizationHandlerContext(requirements, null, null);

            await _handler.WrappedHandleRequirementAsync(_fakeContext, requirement);

            Assert.True(_fakeContext.HasFailed);
        }

        [Test]
        public async Task HandleAsync_NoUserFound_ContextHasFailed()
        {
            var appUser = new ApplicationUser { Email = "User@landmarkcu.com" };
            _mockCurrentUserService.Setup(service => service.GetCurrentUser())
                .Returns(appUser);
            _mockUserService.Setup(service => service.GetUserByAdEmailAsync(appUser.Email))
                .ReturnsAsync((AppUser)null);
            var requirement = new PermissionRequirement("");
            var requirements = new List<IAuthorizationRequirement> { requirement };
            var _fakeContext = new AuthorizationHandlerContext(requirements, null, null);

            await _handler.WrappedHandleRequirementAsync(_fakeContext, requirement);

            Assert.True(_fakeContext.HasFailed);
        }

        [Test]
        public async Task HandleAsync_UserServiceException_ContextHasFailed()
        {
            var appUser = new ApplicationUser { Email = "User@landmarkcu.com" };
            _mockCurrentUserService.Setup(service => service.GetCurrentUser())
                .Returns(appUser);
            _mockUserService.Setup(service => service.GetUserByAdEmailAsync(appUser.Email))
                .ThrowsAsync(new System.Exception("err"));
            var requirement = new PermissionRequirement("");
            var requirements = new List<IAuthorizationRequirement> { requirement };
            var _fakeContext = new AuthorizationHandlerContext(requirements, null, null);

            await _handler.WrappedHandleRequirementAsync(_fakeContext, requirement);

            Assert.True(_fakeContext.HasFailed);
        }
    }
}