using FabApprovalWorkerService.Models;
using FabApprovalWorkerService.Services;

using Microsoft.Extensions.Logging;

using Moq;

namespace FabApprovalWorkerServiceTests;

internal class UserServiceTests {
    private static readonly ILogger<UserService> MOCK_LOGGER = Mock.Of<ILogger<UserService>>();

    private static readonly IEnumerable<User> MOCK_USERS = new List<User>() {
        new User() {
            UserID = 1,
            LoginID = "fred",
            FirstName = "fred",
            LastName = "flintstone",
            Email = "fred.flintstone@email.com",
            IsAdmin = true,
            OOO = true,
            CanViewITAR = true,
            IsManager = false
        },
        new User() {
            UserID = 1,
            LoginID = "barney",
            FirstName = "barney",
            LastName = "rubble",
            Email = "barney.rubble@email.com",
            IsAdmin = false,
            OOO = true,
            CanViewITAR = true,
            IsManager = false
        }
    };

    private static readonly IEnumerable<OOOTemp> MOCK_OOO_TEMPS = new List<OOOTemp>() {
        new OOOTemp() {
            ID = 1,
            OOOUserID = 1,
            OOOExpirationDate = DateTime.Now,
            OOOStartDate = DateTime.Now,
        },
        new OOOTemp() {
            ID = 2,
            OOOUserID = 2,
            OOOExpirationDate = DateTime.Now,
            OOOStartDate = DateTime.Now,
        }
    };

    Mock<IDalService> _mockDalService;

    public UserService _userService;

    [SetUp]
    public void Setup() {
        _mockDalService = new Mock<IDalService>();
    }

    [Test]
    public void UserServiceWithNullLoggerShouldThrowException() {
        _mockDalService = new Mock<IDalService>();

        Assert.Throws<ArgumentNullException>(() => new UserService(null, _mockDalService.Object));
    }

    [Test]
    public void UserServiceWithNullDalServiceShouldThrowException() {
        Assert.Throws<ArgumentNullException>(() => new UserService(MOCK_LOGGER, null));
    }

    [Test]
    public void GetAllExpiredOOOUsersDbErrorShouldThrowException() {
        _mockDalService.Setup(d => d.QueryAsync<User>(It.IsAny<string>())).ThrowsAsync(new Exception("whoops!"));

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        Assert.ThrowsAsync<Exception>(async Task() => await _userService.GetAllExpiredOOOUsersAsync());
    }
    
    [Test]
    public async Task GetAllExpiredOOOUsersShouldReturnMockUsers() {
        _mockDalService.Setup(d => d.QueryAsync<User>(It.IsAny<string>())).Returns(Task.FromResult(MOCK_USERS));

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        List<User> users = await _userService.GetAllExpiredOOOUsersAsync();

        Assert.True(users.Count() == 2);
    }

    [Test]
    public void GetAllPendingOOOUsersDbErrorShouldThrowException() {
        _mockDalService.Setup(d => d.QueryAsync<OOOTemp>(It.IsAny<string>())).ThrowsAsync(new Exception("whoops!"));

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _userService.GetAllPendingOOOUsersAsync());
    }
    
    [Test]
    public async Task GetAllPendingOOOUsersShouldReturnMockOOOTemps() {
        _mockDalService.Setup(d => d.QueryAsync<OOOTemp>(It.IsAny<string>())).Returns(Task.FromResult(MOCK_OOO_TEMPS));

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        List<OOOTemp> oooTemps = await _userService.GetAllPendingOOOUsersAsync();

        Assert.True(oooTemps.Count() == 2);
    }

    [Test]
    public void IsUserAlreadyOOOWithInvalidUserIdShouldThrowException() {
        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task () => await _userService.IsUserAlreadyOOO(0));
    }

    [Test]
    public async Task IsUserAlreadyOOOWithNoUsersShouldReturnFalse() {
        IEnumerable<User> emptyUsers = new List<User>();

        _mockDalService.Setup(d => d.QueryAsync<User>(It.IsAny<string>())).Returns(Task.FromResult(emptyUsers));

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        bool actual = await _userService.IsUserAlreadyOOO(2);

        Assert.False(actual);
    }

    [Test]
    public async Task IsUserAlreadyOOOWithSomeUsersShouldReturnTrue() {
        IEnumerable<User> emptyUsers = new List<User>();

        _mockDalService.Setup(d => d.QueryAsync<User>(It.IsAny<string>())).Returns(Task.FromResult(MOCK_USERS));

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        bool actual = await _userService.IsUserAlreadyOOO(2);

        Assert.True(actual);
    }

    [Test]
    public async Task IsDelegatorAlreadyDelegatedToWithInvalidUserIdShouldReturnFalse() {
        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        Assert.False(await _userService.IsDelegatorAlreadyDelegatedTo(0));
    }

    [Test]
    public void IsDelegatorAlreadyDelegatedToDbErrorShouldThrowException() {
        _mockDalService.Setup(d => d.QueryAsync<User>(It.IsAny<string>())).ThrowsAsync(new Exception("whoops!"));

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        Assert.ThrowsAsync<Exception>(async Task() => await _userService.IsDelegatorAlreadyDelegatedTo(2));
    }

    [Test]
    public async Task IsDelegatorAlreadyDelegatedToWithNoUsersShouldReturnFalse() {
        IEnumerable<User> emptyUsers = new List<User>();

        _mockDalService.Setup(d => d.QueryAsync<User>(It.IsAny<string>())).Returns(Task.FromResult(emptyUsers));

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        bool actual = await _userService.IsDelegatorAlreadyDelegatedTo(2);

        Assert.False(actual);
    }

    [Test]
    public async Task IsDelegatorAlreadyDelegatedToWithSomeUsersShouldReturnTrue() {
        IEnumerable<User> emptyUsers = new List<User>();

        _mockDalService.Setup(d => d.QueryAsync<User>(It.IsAny<string>())).Returns(Task.FromResult(MOCK_USERS));

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        bool actual = await _userService.IsDelegatorAlreadyDelegatedTo(2);

        Assert.True(actual);
    }

    [Test]
    public void InsertDelegatedRolesWithInvalidUserIdShouldThrowException() {
        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task () => await _userService.InsertDelegatedRoles(0));
    }

    [Test]
    public async Task InsertDelegatedRolesWithValidUserIdShouldReturnTrue() {
        IEnumerable<UserSubRole> userSubRoles = new List<UserSubRole>() { 
            new UserSubRole() {
                UserSubRoleID = 1,
                UserID = 1,
                SubRoleID = 1
            },
            new UserSubRole() {
                UserSubRoleID = 2,
                UserID = 2,
                SubRoleID = 2
            }
        };

        _mockDalService.Setup(d => d.QueryAsync<UserSubRole>(It.IsAny<string>())).Returns(Task.FromResult(userSubRoles));
        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(1));

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        bool actual = await _userService.InsertDelegatedRoles(2);

        _mockDalService.Verify(d => d.ExecuteAsync(It.IsAny<string>()));

        Assert.True(actual);
    }

    [Test]
    public async Task RemoveDelegatedRolesWithInvalidUserIdShouldThrowException() {
        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task () => await _userService.RemoveDelegatedRoles(0));
    }

    [Test]
    public async Task RemoveDelegatedRolesWithValidUserIdShouldReturnTrue() {
        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(1));

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        bool actual = await _userService.RemoveDelegatedRoles(2);

        _mockDalService.Verify(d => d.ExecuteAsync(It.IsAny<string>()));

        Assert.True(actual);
    }

    [Test]
    public async Task DelegateUserSubRolesWithInvalidUserIdShouldThrowException() {
        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task () => await _userService.DelegateUserSubRoles(0, 2));
    }

    [Test]
    public async Task DelegateUserSubRolesWithInvalidDelegateIdShouldThrowException() {
        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task () => await _userService.DelegateUserSubRoles(2, 0));
    }

    [Test]
    public async Task DelegateUserSubRolesWithValidUserIdShouldReturnTrue() {
        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(1));

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        bool actual = await _userService.DelegateUserSubRoles(2, 2);

        Assert.True(actual);
    }

    [Test]
    public async Task RemoveDelegatedUserSubRolesWithInvalidUserShouldThrowException() {
        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task () => await _userService.RemoveDelegatedUserSubRoles(0, 2));
    }

    [Test]
    public async Task RemoveDelegatedUserSubRolesWithValidParamsShouldReturnTrue() {
        IEnumerable<int> roleIds = new List<int>() {1, 2};

        _mockDalService.Setup(d => d.QueryAsync<int>(It.IsAny<string>())).Returns(Task.FromResult(roleIds));
        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(1));

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        Assert.True(await _userService.RemoveDelegatedUserSubRoles(1, 2));
    }

    [Test]
    public async Task DelegateApprovalsForUserWithInvalidUserIdShouldThrowException() {
        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task () => await _userService.DelegateApprovalsForUser(0, 2));
    }

    [Test]
    public async Task DelegateApprovalsForUserWithInvalidDelegateIdShouldThrowException() {
        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task () => await _userService.DelegateApprovalsForUser(2, 0));
    }

    [Test]
    public async Task DelegateApprovalsForUserWithValidUserIdShouldReturnTrue() {
        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(1));

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        bool actual = await _userService.DelegateApprovalsForUser(2, 2);

        Assert.True(actual);
    }

    [Test]
    public async Task RemoveDelegatedApprovalsForUserWithInvalidUserIdShouldThrowException() {
        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task () => await _userService.RemoveDelegatedApprovalsForUser(0, 2));
    }

    [Test]
    public async Task RemoveDelegatedApprovalsForUserWithValidUserIdShouldReturnTrue() {
        IEnumerable<int> roleIds = new List<int>() { 1, 2 };

        _mockDalService.Setup(d => d.QueryAsync<int>(It.IsAny<string>())).Returns(Task.FromResult(roleIds));
        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(1));

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        Assert.True(await _userService.RemoveDelegatedApprovalsForUser(1, 2));
    }

    [Test]
    public void FlagUserAsOOOWithNullOOOTempShouldThrowException() {
        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        Assert.ThrowsAsync<ArgumentNullException>(async Task () => await _userService.FlagUserAsOOO(null));
    }

    [Test]
    public async Task FlagUserAsOOOWithValidOOOTempShouldReturnTrue() {
        OOOTemp oooTemp = new OOOTemp() { 
            ID = 1,
            OOOUserID = 1,
            OOOStartDate = DateTime.Now,
            OOOExpirationDate = DateTime.Now
        };

        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(1));

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        bool actual = await _userService.FlagUserAsOOO(oooTemp);

        Assert.True(actual);
    }

    [Test]
    public async Task FlagUserAsOOOWithInvalidUserIdShouldReturnFalse() {
        OOOTemp oooTemp = new OOOTemp() {
            ID = 1,
            OOOUserID = 1,
            OOOStartDate = DateTime.Now,
            OOOExpirationDate = DateTime.Now
        };

        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(0));

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        bool actual = await _userService.FlagUserAsOOO(oooTemp);

        Assert.False(actual);
    }

    [Test]
    public void RemoveOOOFlagForUserWithInvalidIdShouldThrowException() {
        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task () => await _userService.RemoveOOOFlagForUser(0));
    }

    [Test]
    public async Task RemoveOOOFlagForUserWithValidIdShouldReturnTrue() {
        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(1));

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        Assert.True(await _userService.RemoveOOOFlagForUser(1));
    }

    [Test]
    public void SetOOOTempProcessedWithNullOOOTempShouldThrowException() {
        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        Assert.ThrowsAsync<ArgumentNullException>(async Task () => await _userService.SetOOOTempProcessed(null));
    }

    [Test]
    public async Task SetOOOTempProcessedWithValidOOOTempShouldReturnTrue() {
        OOOTemp oooTemp = new OOOTemp() {
            ID = 1,
            OOOUserID = 1,
            OOOStartDate = DateTime.Now,
            OOOExpirationDate = DateTime.Now
        };

        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(1));

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        bool actual = await _userService.SetOOOTempProcessed(oooTemp);

        Assert.True(actual);
    }

    [Test]
    public async Task SetOOOTempProcessedWithInvalidIdShouldReturnFalse() {
        OOOTemp oooTemp = new OOOTemp() {
            ID = 1,
            OOOUserID = 1,
            OOOStartDate = DateTime.Now,
            OOOExpirationDate = DateTime.Now
        };

        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(0));

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        bool actual = await _userService.SetOOOTempProcessed(oooTemp);

        Assert.False(actual);
    }

    [Test]
    public void GetUserEmailWithInvalidUserIdShouldThrowException() {
        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task() => await _userService.GetUserEmail(-1));
    }

    [Test]
    public void GetUserEmailWithDbErrorShouldThrowException() {
        _mockDalService.Setup(d => d.QueryAsync<string>(It.IsAny<string>())).Throws(new Exception());

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        Assert.ThrowsAsync<Exception>(async Task() => await _userService.GetUserEmail(3));
    }

    [Test]
    public async Task GetUserEmailShouldReturnExpectedEmail() {
        IEnumerable<string> emailsFromDb = new List<string>() { "user@email.com" };

        _mockDalService.Setup(d => d.QueryAsync<string>(It.IsAny<string>())).Returns(Task.FromResult(emailsFromDb));

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        string actualEmail = await _userService.GetUserEmail(5);

        Assert.That(actualEmail, Is.EqualTo(emailsFromDb.First()));
    }

    [Test]
    public void GetUserByIdWithInvalidIdShouldThrowException() {
        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task () => await _userService.GetUserById(-4));

        Assert.ThrowsAsync<ArgumentException>(async Task () => await _userService.GetUserById(0));
    }

    [Test]
    public void GetUserByIdDbErrorShouldThrowException() {
        _mockDalService.Setup(d => d.QueryAsync<User>(It.IsAny<string>())).Throws(new Exception());

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _userService.GetUserById(5));
    }

    [Test]
    public void GetUserByIdNoUserFoundShouldThrowException() {
        IEnumerable<User> emptyUsers = new List<User>();

        _mockDalService.Setup(d => d.QueryAsync<User>(It.IsAny<string>())).Returns(Task.FromResult(emptyUsers));

        Assert.ThrowsAsync<Exception>(async Task() => await _userService.GetUserById(5));
    }

    [Test]
    public async Task GetUserByIdShouldReturnExpectedUser() {
        IEnumerable<User> expectedUsers = new List<User>() { 
            new User() {
                UserID = 1,
                LoginID = "id",
                FirstName = "firstName",
                LastName = "lastName",
                Email = "email",
                IsAdmin = false,
                OOO = false,
                CanViewITAR = true,
                IsManager = false
            }
        };

        _mockDalService.Setup(d => d.QueryAsync<User>(It.IsAny<string>())).Returns(Task.FromResult(expectedUsers));

        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);

        User actualUser = await _userService.GetUserById(4);

        Assert.That(expectedUsers.First(), Is.EqualTo(actualUser));
    }
}