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

namespace Application.UnitTests.Services
{
    public class UserAssignmentServiceTest
    {
        private UserAssignmentService _service;
        private Mock<IUserAssignmentRepository> _mockUserAssignmentRepository;
        private Mock<IUserService> _mockUserService;
        private Mock<IUnitOfWork> _mockUnitOfWork;

        [SetUp]
        public void Setup()
        {
            _mockUserAssignmentRepository = new Mock<IUserAssignmentRepository>();
            _mockUserService = new Mock<IUserService>();
            _mockUnitOfWork = new Mock<IUnitOfWork>();
            _service = new UserAssignmentService(_mockUserAssignmentRepository.Object, _mockUserService.Object,
                _mockUnitOfWork.Object);
        }

        [Test]
        public async Task GetAllUserAssignmentsAsync_OK()
        {
            var assignmentsFromRepo = new List<UserAssignment>
            {
                new UserAssignment { Id = 1 },
                new UserAssignment { Id = 2 }
            };
            _mockUserAssignmentRepository.Setup(repo => repo.GetAllUserAssignmentsAsync())
                .ReturnsAsync(assignmentsFromRepo);

            var result = await _service.GetAllUserAssignmentsAsync();

            Assert.NotNull(result);
            Assert.True(result.Any(x => x.Id == 1));
            Assert.True(result.Any(x => x.Id == 2));
        }

        [Test]
        public async Task SetRegionalManager_OK()
        {
            var assignment = new UserAssignmentRequest
            {
                EmployeeId = "123",
                Key = "NORTH",
                Type = AssignmentType.RegionalManager
            };
            var validUser = new AppUser
            {
                Assignments = new List<UserAssignment>(),
                Departments = new List<UserDepartment>()
                {
                    new UserDepartment()
                    {
                        Role = Role.RegionalManager
                    }
                }
            };
            _mockUserService.Setup(service => service.GetUserByEmployeeIdAsync(assignment.EmployeeId))
                .ReturnsAsync(validUser);

            var result = await _service.SetRegionalManager(assignment);
            Assert.NotNull(result);

            _mockUnitOfWork.Verify(mock => mock.CompleteAsync(), Times.Once);
        }

        [Test]
        public void SetRegionalManager_ThrowsNotFoundException()
        {
            var assignment = new UserAssignmentRequest
            {
                EmployeeId = "123"
            };
            _mockUserService.Setup(service => service.GetUserByEmployeeIdAsync(assignment.EmployeeId))
                .ReturnsAsync((AppUser)null);

            var exception = Assert.ThrowsAsync<NotFoundException>(async() =>
            {
                await _service.SetRegionalManager(assignment);
            });

            Assert.AreEqual("Employee Not Found", exception.Message);
        }

        [Test]
        public void SetRegionalManager_ThrowsBadUserAssignmentException()
        {
            var assignment = new UserAssignmentRequest
            {
                EmployeeId = "123"
            };
            var nonRegionalManager = new AppUser { Role = Role.Teller };
            _mockUserService.Setup(service => service.GetUserByEmployeeIdAsync(assignment.EmployeeId))
                .ReturnsAsync(nonRegionalManager);
            var exception = Assert.ThrowsAsync<BadUserAssignmentException>(async () =>
            {
                await _service.SetRegionalManager(assignment);
            });

            Assert.AreEqual("Employee must have the Regional Manager role", exception.Message);
        }

        [Test]
        public async Task SetRegionalManager_SetsUserToAssignment()
        {
            var assignment = new UserAssignmentRequest
            {
                EmployeeId = "123",
                Key = "NORTH",
                Type = AssignmentType.RegionalManager
            };
            var userFromRepo = new AppUser
            {
                EmployeeId = "123",
                AdEmail = "test@landmarkcu.com",
                PersonId = 456,
                Assignments = new List<UserAssignment>(),
                Departments = new List<UserDepartment>()
                {
                    new UserDepartment()
                    {
                        Role = Role.RegionalManager
                    }
                }
            };
            var existingAssignment = new UserAssignment
            {
                Id = 1,
                Key = "NORTH",
                Type = AssignmentType.RegionalManager,
                AppUser = new AppUser()
            };
            _mockUserService.Setup(service => service.GetUserByEmployeeIdAsync(assignment.EmployeeId))
                .ReturnsAsync(userFromRepo);
            _mockUserAssignmentRepository.Setup(service => service.FindExistingAssignmentAsync(assignment.Type.Value,
                assignment.Key))
                .ReturnsAsync(existingAssignment);

            var result = await _service.SetRegionalManager(assignment);
            Assert.NotNull(result);

            Assert.AreEqual(existingAssignment.AppUser.EmployeeId, userFromRepo.EmployeeId);
            Assert.AreEqual(existingAssignment.AppUser.AdEmail, userFromRepo.AdEmail);
            Assert.AreEqual(existingAssignment.AppUser.PersonId, userFromRepo.PersonId);
        }

        [Test]
        public async Task SetRegionalManager_AddsAssignmentToUser()
        {
            var assignment = new UserAssignmentRequest
            {
                EmployeeId = "123",
                Key = "NORTH",
                Type = AssignmentType.RegionalManager
            };
            var userFromRepo = new AppUser
            {
                Assignments = new List<UserAssignment>(),
                Departments = new List<UserDepartment>()
                {
                    new UserDepartment()
                    {
                        Role = Role.RegionalManager
                    }
                }
            };
            _mockUserService.Setup(service => service.GetUserByEmployeeIdAsync(assignment.EmployeeId))
                .ReturnsAsync(userFromRepo);

            var result = await _service.SetRegionalManager(assignment);
            Assert.NotNull(result);

            Assert.AreEqual(1, userFromRepo.Assignments.Count());
            Assert.AreEqual("NORTH", userFromRepo.Assignments.First().Key);
            Assert.AreEqual(AssignmentType.RegionalManager, userFromRepo.Assignments.First().Type);
            Assert.AreEqual(Role.RegionalManager, userFromRepo.Assignments.First().AppUser.Departments.First().Role);
        }

        [Test]
        public async Task GetUserAssignment_ReturnsAssignment()
        {
            var type = AssignmentType.RegionalManager;
            var key = "NORTH";
            var assignment = new UserAssignment {
                Id = 1,
                Key = key,
                Type = type,
                AppUser = new AppUser { EmployeeId = "C0000" }
            };
            _mockUserAssignmentRepository.Setup(mock => mock.FindExistingAssignmentAsync(type, key))
                .ReturnsAsync(assignment);

            var result = await _service.GetUserAssignment(type, key);

            Assert.AreEqual(AssignmentType.RegionalManager, result.Type);
            Assert.AreEqual("NORTH", result.Key);
            Assert.AreEqual(AssignmentType.RegionalManager, result.Type);
            Assert.AreEqual("C0000", result.AppUser.EmployeeId);

            _mockUserAssignmentRepository.Verify(mock => mock.FindExistingAssignmentAsync(type, key),
                Times.Once);
        }
    }
}