using LCU.API.Internal.LoanRate.Services;
using LCU.API.Internal.LoanRate.Services.LoadTestingServices;
using LCU.Library.Internal.Exceptions;
using LCU.Library.Internal.LoanRateModels.Entities.LoadTestingEntities;
using LCU.Library.Internal.LoanRateModels.Requests.LoadTestRequest;

namespace LCU.API.Internal.LoanRateTests.ServiceTests.LoadTestingServices;

public class LoadTestRateCompletionServiceTest
{
    private readonly Mock<IRateProcessingInfoService> _mockRateProcessingInfoService;
    private readonly Mock<ILoadTestRunInfoService> _mockLoadTestRunInfoService;
    private readonly ILoadTestRateCompletionService _loadTestRateCompletionService;

    public LoadTestRateCompletionServiceTest()
    {
        _mockRateProcessingInfoService = new Mock<IRateProcessingInfoService>();
        _mockLoadTestRunInfoService = new Mock<ILoadTestRunInfoService>();
        _loadTestRateCompletionService = new LoadTestRateCompletionService(_mockRateProcessingInfoService.Object, 
                                                             _mockLoadTestRunInfoService.Object);
    }
    
    [Fact]
    public async void HandleLoadTestRateCompletion_Success()
    {
        var random = new Random();
        var requestCount = random.Next(1, 100);
        var requests = GenerateLoadTestRateCompletionRequests(random.Next(1, requestCount), requestCount);
        var rateProcessingInfos = requests.Select(x => x.RateProcessingInfo).ToList();
        var loadTestRunInfoGroups = rateProcessingInfos.GroupBy( p => p.LoadTestRunInfoId, p => p.RateProcessingInfoId);

        await _loadTestRateCompletionService.HandleLoadTestRateCompletion(requests);
        
        _mockRateProcessingInfoService.Verify(x => x.UpdateRangeAsync(It.IsAny<IEnumerable<RateProcessingInfo>>()), Times.Once);
        _mockLoadTestRunInfoService.Verify(x => x.IncreaseRateProcessingInfosCompleteCountAsync(It.IsAny<int>(), It.IsAny<int>()), Times.Exactly(loadTestRunInfoGroups.Count()));
    }
    
    [Fact]
    public void HandleLoadTestRateCompletion_Failure_ThrowsException()
    {
        var requests = GenerateLoadTestRateCompletionRequests(1, 2);
        
        _mockRateProcessingInfoService.Setup(x => x.UpdateRangeAsync(It.IsAny<IEnumerable<RateProcessingInfo>>())).ThrowsAsync(new Exception("Test")).Verifiable();

        Assert.ThrowsAsync<ServiceException>( async () => await _loadTestRateCompletionService.HandleLoadTestRateCompletion(requests));
        
        _mockRateProcessingInfoService.Verify(x => x.UpdateRangeAsync(It.IsAny<IEnumerable<RateProcessingInfo>>()), Times.Once);
        _mockLoadTestRunInfoService.Verify(x => x.IncreaseRateProcessingInfosCompleteCountAsync(It.IsAny<int>(), It.IsAny<int>()), Times.Never);
    }

    private List<LoadTestRateCompletionRequest> GenerateLoadTestRateCompletionRequests(int loadTestCount, int rateProcessingInfoCount)
    {
        var random = new Random();
        
        var loadTestIds = new List<int>();
        for (var i = 0; i < loadTestCount; i++)
        {
            loadTestIds.Add(random.Next(1, int.MaxValue));
        }

        var requests = new List<LoadTestRateCompletionRequest>();
        for (var i = 0; i < rateProcessingInfoCount; i++)
        {
            requests.Add(new LoadTestRateCompletionRequest
            {
                RateProcessingInfo = new RateProcessingInfo
                {
                    LoadTestRunInfoId = loadTestIds[random.Next(0, loadTestCount - 1)],
                    RateProcessingInfoId = random.Next(1, int.MaxValue)
                }
            });
        }

        return requests;
    }
}