using FabApprovalWorkerService.Models;
using FabApprovalWorkerService.Services;

using Microsoft.Extensions.Logging;
using Microsoft.Identity.Client;

using Moq;

namespace FabApprovalWorkerServiceTests;
public class TrainingServiceTests {
    private Mock<ILogger<TrainingService>> _mockLogger;
    private Mock<IDalService> _mockDalService;
    private Mock<IUserService> _mockUserService;

    private TrainingService _trainingService;

    [SetUp]
    public void Setup() {
        _mockLogger = new Mock<ILogger<TrainingService>>();
        _mockDalService = new Mock<IDalService>();
        _mockUserService = new Mock<IUserService>();
    }

    [Test]
    public void TrainingServiceWithNullLoggerShouldThrowException() {
        Assert.Throws<ArgumentNullException>(() => new TrainingService(null, _mockDalService.Object, _mockUserService.Object));
    }

    [Test]
    public void TrainingServiceWithNullDalServiceShouldThrowException() {
        Assert.Throws<ArgumentNullException>(() => new TrainingService(_mockLogger.Object, null, _mockUserService.Object));
    }

    [Test]
    public void TrainingServiceWithNullUserServiceShouldThrowException() {
        Assert.Throws<ArgumentNullException>(() => new TrainingService(_mockLogger.Object, _mockDalService.Object, null));
    }

    [Test]
    public void DeleteDocAssignmentWithInvalidIdShouldThrowException() {
        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

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

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

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.DeleteDocAssignment(1));
    }

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

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        await _trainingService.DeleteDocAssignment(3);

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

    [Test]
    public void DeleteTrainingAssignmentWithInvalidIdShouldThrowException() {
        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

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

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

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.DeleteTrainingAssignmentsByTrainingId(1));
    }

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

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        await _trainingService.DeleteTrainingAssignmentsByTrainingId(3);

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

    [Test]
    public void GetTrainingAssignmentIdsForTrainingWithInvalidIdShouldThrowException() {
        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task () => {
            IEnumerable<int> ids = await _trainingService.GetTrainingAssignmentIdsForTraining(-1);
        });
    }

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

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.GetTrainingAssignmentIdsForTraining(1));
    }

    [Test]
    public async Task GetTrainingAssignmentIdsForTrainingShouldReturnExpectedIds() {
        IEnumerable<int> expectedIds = new List<int>() { 4, 7, 2 };

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

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        IEnumerable<int> actualIds = await _trainingService.GetTrainingAssignmentIdsForTraining(1);

        Assert.That(actualIds.Count(), Is.EqualTo(expectedIds.Count()));
    }

    [Test]
    public void GetTrainingIdsForEcnWithInvalidIdShouldThrowException() {
        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task () => {
            IEnumerable<int> ids = await _trainingService.GetTrainingIdsForECN(-1);
        });
    }

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

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.GetTrainingIdsForECN(1));
    }

    [Test]
    public async Task GetTrainingIdsForEcnsShouldReturnExpectedIds() {
        IEnumerable<int> expectedIds = new List<int>() { 4, 7, 2 };

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

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        IEnumerable<int> actualIds = await _trainingService.GetTrainingIdsForECN(1);

        Assert.That(actualIds.Count(), Is.EqualTo(expectedIds.Count()));
    }

    [Test]
    public void MarkTrainingAsCompleteWithInvalidIdShouldThrowException() {
        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

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

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

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.MarkTrainingAsComplete(1));
    }

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

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        await _trainingService.MarkTrainingAsComplete(1);

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

    [Test]
    public async Task GetActiveTrainingAssignmentsShouldReturnExpectedAssignments() {
        IEnumerable<TrainingAssignment> expectedAssignments = new List<TrainingAssignment>() {
            new TrainingAssignment() {
                ID = 1,
                TrainingID = 1,
                UserID = 1,
                DateAssigned = DateTime.Now
            },
            new TrainingAssignment() {
                ID = 2,
                TrainingID = 1,
                UserID = 2,
                DateAssigned = DateTime.Now
            },
            new TrainingAssignment() {
                ID = 3,
                TrainingID = 1,
                UserID = 3,
                DateAssigned = DateTime.Now
            }
        };

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

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        IEnumerable<TrainingAssignment> actualAssignments = await _trainingService.GetActiveTrainingAssignments();

        Assert.That(actualAssignments.Count() == expectedAssignments.Count());
    }

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

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.GetActiveTrainingAssignments());
    }

    [Test]
    public void UpdateTrainingAssignmentLastNotificationWithInvalidIdShouldThrowException() {
        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

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

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

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.UpdateTrainingAssignmentLastNotification(1));
    }

    [Test]
    public async Task UpdateTrainingAssignmentLastNotificationShouldExecuteSql() {
        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        await _trainingService.UpdateTrainingAssignmentLastNotification(1);

        _mockDalService.Verify(d => d.ExecuteAsync(It.IsAny<string>()), Times.Once());
    }

    [Test]
    public void GetEcnNumberByTrainingIdInvalidIdShouldThrowException() {
        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task () => await _trainingService.GetEcnNumberByTrainingId(0));
        Assert.ThrowsAsync<ArgumentException>(async Task () => await _trainingService.GetEcnNumberByTrainingId(-1));
    }

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

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.GetEcnNumberByTrainingId(9));
    }

    [Test]
    public void GetEcnNumberByTrainingIdEcnNumberNotFoundShouldThrowException() {
        IEnumerable<int> expectedIds = new List<int>();

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

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.GetEcnNumberByTrainingId(9));
    }

    [Test]
    public async Task GetEcnNumberByTrainingIdShouldReturnExpectedId() {
        IEnumerable<int> expectedIds = new List<int>() { 1 };

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

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        int actualId = await _trainingService.GetEcnNumberByTrainingId(9);

        Assert.That(expectedIds.First(), Is.EqualTo(actualId));
    }

    [Test]
    public void DeleteTrainingAssignmentByIdWithInvalidIdShouldThrowException() {
        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task () => await _trainingService.DeleteTrainingAssignmentById(0));
        Assert.ThrowsAsync<ArgumentException>(async Task () => await _trainingService.DeleteTrainingAssignmentById(-7));
    }

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

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.DeleteTrainingAssignmentById(9));
    }

    [Test]
    public async Task DeleteTrainingAssignmentByIdShouldExecuteSql() {
        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        await _trainingService.DeleteTrainingAssignmentById(9);

        _mockDalService.Verify(d => d.ExecuteAsync(It.IsAny<string>()), Times.Once());
    }

    [Test]
    public void GetTrainingAssignmentIdsByUserIdWithInvalidIdShouldThrowException() {
        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task () => await _trainingService.GetTrainingAssignmentIdsByUserId(0));
        Assert.ThrowsAsync<ArgumentException>(async Task () => await _trainingService.GetTrainingAssignmentIdsByUserId(-9));
    }

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

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.GetTrainingAssignmentIdsByUserId(9));
    }

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

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

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);

        IEnumerable<int> actualIds = await _trainingService.GetTrainingAssignmentIdsByUserId(9);

        Assert.That(expectedIds, Is.EquivalentTo(actualIds));
    }
}