using LCU.Library.Internal.Exceptions;
using LCU.Library.Internal.LoanRateModels.Entities;
using LCU.API.Internal.LoanRateLib.Repositories;
using LCU.API.Internal.LoanRate.Services;
using LCU.Library.Internal.LcuEvaluationModels.Enums;

namespace LCU.API.Internal.LoanRateTests.ServiceTests;

public class RateServiceTest
{
    private readonly Mock<IRateRepository> _mockRateRepository;
    private readonly Mock<IRateSheetService> _mockRateSheetService;
    private readonly Mock<ILoadTestRunInfoService> _mockLoadTestRunInfoService;
    private readonly Mock<IUnitOfWork> _mockUnitOfWork;
    private readonly IRateService _service;

    public RateServiceTest()
    {
        _mockRateRepository = new Mock<IRateRepository>();
        _mockRateSheetService = new Mock<IRateSheetService>();
        _mockLoadTestRunInfoService = new Mock<ILoadTestRunInfoService>();
        _mockUnitOfWork = new Mock<IUnitOfWork>();
        _service = new RateService(_mockUnitOfWork.Object, 
                                   _mockRateRepository.Object,
                                   _mockRateSheetService.Object,
                                   _mockLoadTestRunInfoService.Object);
    }

    [Fact]
    public async void Rate_GetAsync_Success()
    {
        var rates = new List<Rate>
        {
            new() { RateId = 1 },
            new() { RateId = 2 },
            new() { RateId = 3 }
        };

        _mockRateRepository.Setup(x => x.FindAsync())
            .ReturnsAsync(rates).Verifiable();

        var result = (await _service.GetAsync()).ToList();
        Assert.NotNull(result);
        Assert.Equal(rates.First().RateId, result.First().RateId);
        Assert.Equal(rates.Count, result.Count);
        _mockRateRepository.Verify();
    }

    [Fact]
    public async void Rate_GetAsync_Success_NotFound()
    {
        List<Rate>? rates = null;

        _mockRateRepository.Setup(x => x.FindAsync())
            .ReturnsAsync(rates).Verifiable();

        var result = await _service.GetAsync();
        Assert.NotNull(result);
        Assert.Empty(result);
        _mockRateRepository.Verify();
    }

    [Fact]
    public void Rate_GetAsync_Failure_Exception()
    {
        _mockRateRepository.Setup(x => x.FindAsync())
            .Throws(new Exception("Test")).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () => await _service.GetAsync());

        _mockRateRepository.Verify(x => x.FindAsync(), Times.Once);
    }

    [Fact]
    public async void Rate_GetByIdAsync_Success()
    {
        var rateId = 1;
        var rate = new Rate
        {
            RateId = rateId
        };

        _mockRateRepository.Setup(x => x.FindByIdAsync(rateId))
            .ReturnsAsync(rate).Verifiable();

        var result = await _service.GetByIdAsync(rateId);
        Assert.NotNull(result);
        Assert.Equal(rate.RateId, result.RateId);
        _mockRateRepository.Verify();
    }

    [Fact]
    public async void Rate_GetByIdAsync_Success_NotFound()
    {
        var rateId = 1;
        Rate? rate = null;

        _mockRateRepository.Setup(x => x.FindByIdAsync(rateId))
            .ReturnsAsync(rate).Verifiable();

        var result = await _service.GetByIdAsync(rateId);
        Assert.Null(result);
        _mockRateRepository.Verify();
    }

    [Fact]
    public void Rate_GetByIdAsync_Failure_Exception()
    {
        _mockRateRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>()))
            .Throws(new Exception("Test")).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () =>
                            await _service.GetByIdAsync(It.IsAny<int>()));

        _mockRateRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
    }

    [Fact]
    public async void Rate_GetByDateAsync_Success()
    {
        var rateId = 1;
        var rates = new List<Rate>{
            new Rate
            {
                RateId = rateId
            }
        };
        var date = Convert.ToDateTime("1/1/2023");
        _mockRateRepository.Setup(x => x.FindByDateAsync(date))
            .ReturnsAsync(rates).Verifiable();

        var results = await _service.GetByDateAsync(date);
        Assert.NotNull(results);
        Assert.NotEmpty(results);
        var result = results.FirstOrDefault();
        Assert.NotNull(result);
        Assert.Equal(rateId, result.RateId);
        _mockRateRepository.Verify();
    }

    [Fact]
    public async void Rate_GetByDateAsync_Success_NotFound()
    {
        List<Rate>? rate = null;
        var date = Convert.ToDateTime("1/1/2023");
        _mockRateRepository.Setup(x => x.FindByDateAsync(date))
            .ReturnsAsync(rate).Verifiable();

        var results = await _service.GetByDateAsync(date);
        Assert.NotNull(results);
        Assert.Empty(results);
        _mockRateRepository.Verify();
    }

    [Fact]
    public void Rate_GetByDateAsync_Failure_Exception()
    {
        _mockRateRepository.Setup(x => x.FindByDateAsync(It.IsAny<DateTime>()))
            .Throws(new Exception("Test")).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () =>
                            await _service.GetByDateAsync(It.IsAny<DateTime>()));

        _mockRateRepository.Verify(x => x.FindByDateAsync(It.IsAny<DateTime>()), Times.Once);
    }
    
    [Fact]
    public async void Rate_GetRateHistoryAsync_Success()
    {
        var rate = new Rate
        {
            RateId = 1,
            Column = "A",
            Row = "2",
            RateSheetId = 1
        };
        var rateHistory = new List<Rate>
        {
            new()
            {
                Column = rate.Column,
                Row = rate.Row,
                RateSheetId = rate.RateSheetId
            },
            new()
            {
                Column = rate.Column,
                Row = rate.Row,
                RateSheetId = rate.RateSheetId
            },
            new()
            {
                Column = rate.Column,
                Row = rate.Row,
                RateSheetId = rate.RateSheetId
            }
        };
        _mockRateRepository.Setup(x => x.FindRateHistoryAsync(rate))
            .ReturnsAsync(rateHistory).Verifiable();

        var results = (await _service.GetRateHistory(rate))?.ToList();
        Assert.NotNull(results);
        Assert.NotEmpty(results);
        
        var result = results.FirstOrDefault();
        Assert.NotNull(result);
        Assert.Equal(rate.RateSheetId, result.RateSheetId);
        _mockRateRepository.Verify();
    }

    [Fact]
    public async void Rate_GetRateHistoryAsync_Success_NotFound()
    {
        Rate? rate = null;
        List<Rate>? rateHistory = null;
        _mockRateRepository.Setup(x => x.FindRateHistoryAsync(rate))
            .ReturnsAsync(rateHistory).Verifiable();

        var results = await _service.GetRateHistory(rate);
        Assert.NotNull(results);
        Assert.Empty(results);
        _mockRateRepository.Verify();
    }

    [Fact]
    public void Rate_GetRateHistoryAsync_Failure_Exception()
    {
        _mockRateRepository.Setup(x => x.FindRateHistoryAsync(It.IsAny<Rate>()))
            .Throws(new Exception("Test")).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () =>
            await _service.GetRateHistory(It.IsAny<Rate>()));

        _mockRateRepository.Verify(x => x.FindRateHistoryAsync(It.IsAny<Rate>()), Times.Once);
    }
    
    [Fact]
    public async void Rate_GetRangeByIdAsync_Success()
    {
        var rates = new List<Rate>
        {
            new() { RateId = 1 },
            new() { RateId = 2 },
            new() { RateId = 3 }
        };
        var ids = rates.Select(x => x.RateId).ToList();

        _mockRateRepository.Setup(x => x.FindRangeByIdAsync(ids))
            .ReturnsAsync(rates).Verifiable();

        var results = (await _service.GetRangeByIdAsync(ids)).ToList();
        Assert.NotNull(results);
        Assert.Equal(rates.First().RateId, results.First().RateId);
        Assert.Equal(rates.Count, results.Count);
        _mockRateRepository.Verify();
    }

    [Fact]
    public async void Rate_GetRangeByIdAsync_Success_NotFound()
    {
        List<Rate>? rates = null;
        var ids = new List<int>
        {
            1,2,3
        };

        _mockRateRepository.Setup(x => x.FindRangeByIdAsync(ids))
            .ReturnsAsync(rates).Verifiable();

        var result = await _service.GetRangeByIdAsync(ids);
        Assert.NotNull(result);
        Assert.Empty(result);
        _mockRateRepository.Verify();
    }

    [Fact]
    public void Rate_GetRangeByIdAsync_Failure_Exception()
    {
        _mockRateRepository.Setup(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()))
            .Throws(new Exception("Test")).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () => await _service.GetRangeByIdAsync(It.IsAny<List<int>>()));

        _mockRateRepository.Verify(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()), Times.Once);
    }

    [Fact]
    public async void Rate_GetByDateEvaluationIdAndEvaluationTypeAsync_Success()
    {
        var rateId = 1;
        var rateSheetId = 1;
        var date = Convert.ToDateTime("1/1/2023");
        var rates = new List<Rate>{
            new Rate
            {
                RateId = rateId,
                RateSheetId = rateSheetId,
                RateStartDate = date
            }
        };
        var evaluationIds = new List<int> { 10 };
        var evaluationType = EvaluationTypes.Rule;
        _mockRateRepository.Setup(x => x.FindByDateEvaluationIdsAndEvaluationTypeAsync(date, evaluationIds, evaluationType))
            .ReturnsAsync(rates).Verifiable();

        var results = await _service.GetByDateEvaluationIdAndEvaluationTypeAsync(date, evaluationIds, evaluationType);
        Assert.NotNull(results);
        Assert.NotEmpty(results);
        var result = results.FirstOrDefault();
        Assert.NotNull(result);
        Assert.Equal(rateId, result.RateId);
        _mockRateRepository.Verify();
    }

    [Fact]
    public async void Rate_GetByDateEvaluationIdAndEvaluationTypeAsync_Success_NotFound()
    {
        var date = Convert.ToDateTime("1/1/2023");
        List<Rate>? rates = null;
        var evaluationIds = new List<int> { 10 };
        var evaluationType = EvaluationTypes.Rule;
        _mockRateRepository.Setup(x => x.FindByDateEvaluationIdsAndEvaluationTypeAsync(date, evaluationIds, evaluationType))
            .ReturnsAsync(rates).Verifiable();

        var result = await _service.GetByDateEvaluationIdAndEvaluationTypeAsync(date, evaluationIds, evaluationType);
        Assert.NotNull(result);
        Assert.Empty(result);
        _mockRateRepository.Verify();
    }

    [Fact]
    public void Rate_GetByDateEvaluationIdAndEvaluationTypeAsync_Failure_Exception()
    {
        _mockRateRepository.Setup(x => x.FindByDateEvaluationIdsAndEvaluationTypeAsync(It.IsAny<DateTime>(), It.IsAny<List<int>>(), It.IsAny<EvaluationTypes>()))
            .Throws(new Exception("Test")).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () =>
                            await _service.GetByDateEvaluationIdAndEvaluationTypeAsync(It.IsAny<DateTime>(), It.IsAny<List<int>>(), It.IsAny<EvaluationTypes>()));

        _mockRateRepository.Verify(x => x.FindByDateEvaluationIdsAndEvaluationTypeAsync(It.IsAny<DateTime>(), It.IsAny<List<int>>(), It.IsAny<EvaluationTypes>()), Times.Once);
    }

    [Fact]
    public async void Rate_SaveAsync_Success()
    {
        var rate = new Rate
        {
            Value = 4.59m
        };
        var RateReturned = new Rate
        {
            RateId = 1,
            Value = 4.9m
        };

        _mockRateRepository.Setup(x => x.AddAsync(rate))
            .ReturnsAsync(RateReturned).Verifiable();

        var result = await _service.SaveAsync(rate);
        Assert.NotNull(result);
        Assert.Equal(RateReturned.RateId, result.RateId);
        Assert.Equal(RateReturned.Value, result.Value);

        _mockRateRepository.Verify(x => x.AddAsync(It.IsAny<Rate>()), Times.Once);
        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
    }

    [Fact]
    public void Rate_SaveAsync_Failure_ReturnedNull()
    {
        var rate = new Rate
        {
            Value = 4.59m
        };
        Rate? rateReturned = null;

        _mockRateRepository.Setup(x => x.AddAsync(rate))
            .ReturnsAsync(rateReturned).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () => await _service.SaveAsync(rate));

        _mockRateRepository.Verify(x => x.AddAsync(It.IsAny<Rate>()), Times.Once);
        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
    }

    [Fact]
    public void Rate_SaveAsync_Failure_Exception()
    {
        _mockRateRepository.Setup(x => x.AddAsync(It.IsAny<Rate>()))
            .Throws(new Exception("Test")).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () =>
            await _service.SaveAsync(It.IsAny<Rate>()));

        _mockRateRepository.Verify(x => x.AddAsync(It.IsAny<Rate>()), Times.Once);
        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
    }

    [Fact]
    public async void Rate_SaveRangeAsync_Success()
    {
        var rates = new List<Rate>
        {
            new() { Value = 4.59m },
            new() { Value = 4.9m },
            new() { Value = 4m }
        };

        _mockRateRepository.Setup(x => x.AddRangeAsync(rates)).Verifiable();

        await _service.SaveRangeAsync(rates);
        _mockRateRepository.Verify(x =>
            x.AddRangeAsync(It.IsAny<IEnumerable<Rate>>()), Times.Once);
        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
    }

    [Fact]
    public void Rate_SaveRangeAsync_Failure_Exception()
    {
        _mockRateRepository.Setup(x => x.AddRangeAsync(It.IsAny<IEnumerable<Rate>>()))
            .Throws(new Exception("Test")).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () =>
            await _service.SaveRangeAsync(It.IsAny<IEnumerable<Rate>>()));

        _mockRateRepository.Verify(x =>
                            x.AddRangeAsync(It.IsAny<IEnumerable<Rate>>()), Times.Once);
        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
    }

    [Fact]
    public async void Rate_UpdateAsync_Success()
    {
        var rate = new Rate
        {
            RateId = 1,
            Value = 4.59m
        };

        _mockRateRepository.Setup(x => x.FindByIdAsync(rate.RateId))
            .ReturnsAsync(rate).Verifiable();

        var result = await _service.UpdateAsync(rate);
        Assert.NotNull(result);
        Assert.Equal(rate.RateId, result.RateId);
        Assert.Equal(rate.Value, result.Value);
        _mockRateRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once());
        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
    }

    [Fact]
    public void Rate_UpdateAsync_Failure_ReturnedNull()
    {
        var rate = new Rate
        {
            Value = 4.59m
        };
        Rate? rateReturned = null;

        _mockRateRepository.Setup(x => x.FindByIdAsync(rate.RateId))
            .ReturnsAsync(rateReturned).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () => await _service.UpdateAsync(rate));

        _mockRateRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
    }

    [Fact]
    public void Rate_UpdateAsync_Failure_Exception()
    {
        _mockRateRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>()))
            .ThrowsAsync(new Exception("Test")).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () =>
            await _service.UpdateAsync(It.IsAny<Rate>()));

        _mockRateRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Never);
        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
    }

    [Fact]
    public async void Rate_UpdateRangeAsync_Success()
    {
        var rates = new List<Rate>
        {
            new()
            {
                RateId = 1,
                Value = 4.59m
            },
            new()
            {
                RateId = 2,
                Value = 4.9m
            },
            new()
            {
                RateId = 3,
                Value = 4m
            }
        };

        _mockRateRepository.Setup(x => x.UpdateRange(rates)).Verifiable();

        await _service.UpdateRangeAsync(rates);

        _mockRateRepository.Verify(x => x.UpdateRange(It.IsAny<List<Rate>>()), Times.Once());
        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
    }

    [Fact]
    public void Rate_UpdateRangeAsync_Failure_Exception()
    {
        _mockRateRepository.Setup(x => x.UpdateRange(It.IsAny<List<Rate>>()))
            .Throws(new Exception("Test")).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () =>
            await _service.UpdateRangeAsync(It.IsAny<List<Rate>>()));

        _mockRateRepository.Verify(x => x.UpdateRange(It.IsAny<List<Rate>>()), Times.Never);
        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
    }

    [Fact]
    public async void Rate_DeleteAsync_Success()
    {
        var rateId = 1;

        var rate = new Rate
        {
            RateId = rateId,
            Value = 4.59m
        };

        _mockRateRepository.Setup(x => x.FindByIdAsync(rateId))
            .ReturnsAsync(rate).Verifiable();
        _mockRateRepository.Setup(x => x.Remove(rate)).Verifiable();

        await _service.DeleteAsync(rateId);

        _mockRateRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once());
        _mockRateRepository.Verify(x => x.Remove(It.IsAny<Rate>()), Times.Once());
        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
    }

    [Fact]
    public void Rate_DeleteAsync_Failure_ReturnedNull()
    {
        var rateId = 1;
        Rate? rate = null;

        _mockRateRepository.Setup(x => x.FindByIdAsync(rateId))
            .ReturnsAsync(rate).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () => await _service.DeleteAsync(rateId));

        _mockRateRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once());
        _mockRateRepository.Verify(x => x.Remove(It.IsAny<Rate>()), Times.Never);
        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
    }

    [Fact]
    public void Rate_DeleteAsync_Failure_Exception()
    {
        _mockRateRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>()))
            .Throws(new Exception("Test")).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () =>
            await _service.DeleteAsync(It.IsAny<int>()));

        _mockRateRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
        _mockRateRepository.Verify(x => x.Remove(It.IsAny<Rate>()), Times.Never);
        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
    }

    [Fact]
    public async void Rate_DeleteRangeAsync_Success()
    {
        var rateIds = new List<int>
        {
            1,
            2,
            3
        };
        var rates = new List<Rate>
        {
            new()
            {
                RateId = rateIds[0],
                Value = 4.59m
            },
            new()
            {
                RateId = rateIds[1],
                Value = 4.9m
            },
            new()
            {
                RateId = rateIds[2],
                Value = 4m
            }
        };

        _mockRateRepository.Setup(x => x.FindRangeByIdAsync(rateIds)).ReturnsAsync(rates).Verifiable();
        _mockRateRepository.Setup(x => x.RemoveRange(rates)).Verifiable();

        await _service.DeleteRangeAsync(rateIds);

        _mockRateRepository.Verify(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()), Times.Once());
        _mockRateRepository.Verify(x => x.RemoveRange(It.IsAny<List<Rate>>()), Times.Once());
        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
    }

    [Fact]
    public void Rate_DeleteRangeAsync_Failure_ReturnedNull()
    {
        var rateIds = new List<int>
        {
            1,
            2,
            3
        };
        List<Rate>? rates = null;

        _mockRateRepository.Setup(x => x.FindRangeByIdAsync(rateIds))
            .ReturnsAsync(rates).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () => await _service.DeleteRangeAsync(rateIds));

        _mockRateRepository.Verify(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()), Times.Once());
        _mockRateRepository.Verify(x => x.RemoveRange(It.IsAny<List<Rate>>()), Times.Never);
        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
    }

    [Fact]
    public void Rate_DeleteRangeAsync_Failure_Exception()
    {
        _mockRateRepository.Setup(x => x.RemoveRange(It.IsAny<List<Rate>>()))
            .Throws(new Exception("Test")).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () =>
            await _service.DeleteRangeAsync(It.IsAny<List<int>>()));

        _mockRateRepository.Verify(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()), Times.Once());
        _mockRateRepository.Verify(x => x.RemoveRange(It.IsAny<List<Rate>>()), Times.Never);
        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
    }
}