using LCU.API.Internal.LoanRate.Services;
using LCU.Library.Internal.Exceptions;
using LCU.Library.Internal.LcuEvaluation.Services;
using LCU.Library.Internal.LcuEvaluationModels.Entities;
using LCU.Library.Internal.LcuEvaluationModels.Requests;
using LCU.Library.Internal.LoanRateModels.Entities;

namespace LCU.API.Internal.LoanRateTests.ServiceTests;

public class ComplexEvaluationDetailServiceTest
{
    private readonly Mock<IRateEvaluationService> _mockRateEvaluationService;
    private readonly Mock<IEvaluationDetailService> _mockEvaluationDetailService;
    private readonly IComplexEvaluationDetailService _service;

    public ComplexEvaluationDetailServiceTest()
    {
        _mockRateEvaluationService = new Mock<IRateEvaluationService>();
        _mockEvaluationDetailService = new Mock<IEvaluationDetailService>();
        _service = new ComplexEvaluationDetailService(_mockRateEvaluationService.Object,
                                                      _mockEvaluationDetailService.Object);
    }

    [Fact]
    public async void ComplexEvaluationDetail_UpdateComplexAsync_Success()
    {
        var evaluationDetail = new EvaluationDetail
        {
            EvaluationDetailId = DateTime.Now.Millisecond,
            Description = Guid.NewGuid().ToString()
        };
        
        var newEvaluationDetail = new EvaluationDetail
        {
            EvaluationDetailId = DateTime.Now.Millisecond,
            Description = Guid.NewGuid().ToString()
        };
        
        _mockEvaluationDetailService.Setup(x => x.UpdateComplexAsync(It.IsAny<EvaluationDetail>()))
                                                                        .ReturnsAsync(newEvaluationDetail).Verifiable();

        var result = await _service.UpdateComplexAsync(evaluationDetail);
        Assert.NotNull(result);
        Assert.Equal(result.Description, newEvaluationDetail.Description);
        _mockEvaluationDetailService.Verify(x => x.UpdateComplexAsync(It.IsAny<EvaluationDetail>()), Times.Once);
    }

    [Fact]
    public async void ComplexEvaluationDetail_UpdateComplexAsync_Success_NotFound()
    {
        EvaluationDetail? evaluationDetail = null;

        _mockEvaluationDetailService.Setup(x => x.UpdateComplexAsync(It.IsAny<EvaluationDetail>()))
                                                                .ReturnsAsync(evaluationDetail).Verifiable();

        var result = await _service.UpdateComplexAsync(evaluationDetail);
        Assert.Null(result);
        _mockEvaluationDetailService.Verify(x => x.UpdateComplexAsync(It.IsAny<EvaluationDetail>()), Times.Once);
    }

    [Fact]
    public void ComplexEvaluationDetail_UpdateComplexAsync_Failure_Exception()
    {
        var evaluationDetail = new EvaluationDetail();
        _mockEvaluationDetailService.Setup(x => x.UpdateComplexAsync(It.IsAny<EvaluationDetail>()))
            .Throws(new Exception("Test")).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () => await _service.UpdateComplexAsync(evaluationDetail));
        _mockEvaluationDetailService.Verify(x => x.UpdateComplexAsync(It.IsAny<EvaluationDetail>()), Times.Once);
    }

    [Fact]
    public async void ComplexEvaluationDetail_SaveComplexAsync_Success_NewEvaluationDetail()
    {
        var evaluationDetail = new EvaluationDetail
        {
            Description = Guid.NewGuid().ToString()
        };

        var request = new EvaluationDetailRequest
        {
            EvaluationDetail = evaluationDetail
        }; 
        
        var newEvaluationDetail = new EvaluationDetail
        {
            EvaluationDetailId = DateTime.Now.Millisecond + 1,
            Description = evaluationDetail.Description
        };

        _mockEvaluationDetailService.Setup(x => x.SaveComplexAsync(It.IsAny<EvaluationDetailRequest>()))
                                                                        .ReturnsAsync(newEvaluationDetail).Verifiable();

        var result = await _service.SaveComplexAsync(request);
        Assert.NotNull(result);
        Assert.Equal(request.EvaluationDetail.Description, newEvaluationDetail.Description);
        _mockEvaluationDetailService.Verify(x => x.SaveComplexAsync(It.IsAny<EvaluationDetailRequest>()), Times.Once);
    }

    [Fact]
    public async void ComplexEvaluationDetail_SaveComplexAsync_Success_ExistingEvaluationDetail()
    {
        var evaluationDetail = new EvaluationDetail
        {
            EvaluationDetailId = DateTime.Now.Millisecond,
            Description = Guid.NewGuid().ToString()
        };

        var rateEvaluations = new List<RateEvaluation>
        {
            new()
            {
                EvaluationDetailId = evaluationDetail.EvaluationDetailId,
                RateId = DateTime.Now.Millisecond + 5
            }
        };

        var request = new EvaluationDetailRequest
        {
            PreviousVersionEvaluationDetailId = evaluationDetail.EvaluationDetailId,
            EvaluationDetail = evaluationDetail
        }; 
        
        var newEvaluationDetail = new EvaluationDetail
        {
            EvaluationDetailId = DateTime.Now.Millisecond + 1,
            Description = evaluationDetail.Description
        };

        _mockEvaluationDetailService.Setup(x => x.SaveComplexAsync(It.IsAny<EvaluationDetailRequest>()))
            .ReturnsAsync(newEvaluationDetail).Verifiable();
        _mockRateEvaluationService.Setup(x => x.GetRangeByEvaluationDetailIdAsync(It.IsAny<int>()))
            .ReturnsAsync(rateEvaluations).Verifiable();
        _mockRateEvaluationService.Setup(x => x.SaveRangeAsync(rateEvaluations)).Verifiable();

        var result = await _service.SaveComplexAsync(request);
        Assert.NotNull(result);
        Assert.Equal(request.EvaluationDetail.Description, newEvaluationDetail.Description);
        _mockEvaluationDetailService.Verify(x => x.SaveComplexAsync(It.IsAny<EvaluationDetailRequest>()), Times.Once);
        _mockRateEvaluationService.Verify(x => x.GetRangeByEvaluationDetailIdAsync(It.IsAny<int>()), Times.Once);
        _mockRateEvaluationService.Verify(x => x.SaveRangeAsync(It.IsAny<List<RateEvaluation>>()), Times.Once);
    }
    
    [Fact]
    public async void ComplexEvaluationDetail_SaveComplexAsync_Success_NotFound()
    {
        var request = new EvaluationDetailRequest();
        EvaluationDetail? evaluationDetail = null;

        _mockEvaluationDetailService.Setup(x => x.SaveComplexAsync(It.IsAny<EvaluationDetailRequest>()))
                                                                .ReturnsAsync(evaluationDetail).Verifiable();

        var result = await _service.SaveComplexAsync(request);
        Assert.Null(result);
        _mockEvaluationDetailService.Verify(x => x.SaveComplexAsync(It.IsAny<EvaluationDetailRequest>()), Times.Once);
    }

    [Fact]
    public void ComplexEvaluationDetail_SaveComplexAsync_Failure_Exception()
    {
        var request = new EvaluationDetailRequest();
        _mockEvaluationDetailService.Setup(x => x.SaveComplexAsync(It.IsAny<EvaluationDetailRequest>()))
            .Throws(new Exception("Test")).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () => await _service.SaveComplexAsync(request));
        _mockEvaluationDetailService.Verify(x => x.SaveComplexAsync(It.IsAny<EvaluationDetailRequest>()), Times.Once);
    }
    
    [Fact]
    public async void ComplexEvaluationDetail_DeleteComplexAsync_Success()
    {
        var evaluationDetailId = DateTime.Now.Millisecond;
        
        _mockEvaluationDetailService.Setup(x => x.DeleteComplexAsync(It.IsAny<int>())).Verifiable();
        _mockRateEvaluationService.Setup(x => x.DeleteRangeByEvaluationDetailIdAsync(It.IsAny<int>())).Verifiable();

        await _service.DeleteComplexAsync(evaluationDetailId);
        _mockEvaluationDetailService.Verify(x => x.DeleteComplexAsync(It.IsAny<int>()), Times.Once);
        _mockRateEvaluationService.Verify(x => x.DeleteRangeByEvaluationDetailIdAsync(It.IsAny<int>()), Times.Once);
    }
    
    [Fact]
    public void ComplexEvaluationDetail_DeleteComplexAsync_Failure_Exception()
    {
        _mockEvaluationDetailService.Setup(x => x.DeleteComplexAsync(It.IsAny<int>()))
            .Throws(new Exception("Test")).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () => await _service.DeleteComplexAsync(It.IsAny<int>()));
        _mockEvaluationDetailService.Verify(x => x.DeleteComplexAsync(It.IsAny<int>()), Times.Once);
    }
}