using System.Globalization;
using System.Reflection;
using LCU.API.Internal.LoanRate.Services;
using LCU.API.Internal.LoanRate.Services.LoadTestingServices;
using LCU.API.Internal.LoanRate.Services.QueueServices;
using LCU.Library.Internal.Exceptions;
using LCU.Library.Internal.LoanRateModels.Entities.LoadTestingEntities;
using LCU.Library.Internal.LoanRateModels.Enums;
using LCU.Library.Internal.LoanRateModels.Enums.LoadTestingEnums;
using LCU.Library.Internal.LoanRateModels.Requests;
using LCU.Library.Internal.LoanRateModels.Requests.LoadTestRequest;
using Newtonsoft.Json;

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

public class LoadTestInitiationServiceTest
{
    private readonly Mock<ILoadTestRunInfoService> _mockLoadTestRunInfoService;
    private readonly Mock<IRateProcessingInfoService> _mockRateProcessingInfoService;
    private readonly Mock<IQueueLoadTestProcessRateService> _mockQueueLoadTestProcessRateService;
    private readonly ILoadTestInitiationService _loadTestInitiationService;

    public LoadTestInitiationServiceTest()
    {
        _mockLoadTestRunInfoService = new Mock<ILoadTestRunInfoService>();
        _mockRateProcessingInfoService = new Mock<IRateProcessingInfoService>();
        _mockQueueLoadTestProcessRateService = new Mock<IQueueLoadTestProcessRateService>();
        _loadTestInitiationService = new LoadTestInitiationService(_mockLoadTestRunInfoService.Object,
                                                                   _mockRateProcessingInfoService.Object,
                                                                   _mockQueueLoadTestProcessRateService.Object);
    }

    [Fact]
    public async void HandleLoadTestInitiation_Success()
    {
        var propertyCount = new Random().Next(1, 100);
        var request = GenerateLoadTestInitiateRequest(propertyCount);
        var loadTestRunInfo = new LoadTestRunInfo { LoadTestRunInfoId = DateTime.Now.Millisecond };
        var rateProcessingInfos = GenerateRateProcessingInfos(request, loadTestRunInfo.LoadTestRunInfoId).ToList();
        
        _mockLoadTestRunInfoService.Setup(x => x.SaveAsync(It.IsAny<LoadTestRunInfo>())).ReturnsAsync(loadTestRunInfo).Verifiable();
        _mockRateProcessingInfoService.Setup(x => x.SaveRangeAsync(It.Is<List<RateProcessingInfo>>( 
                                        list => list.All( 
                                                    rateProcessingInfo => rateProcessingInfo.LoadTestRunInfoId == loadTestRunInfo.LoadTestRunInfoId
                                                    && !string.IsNullOrWhiteSpace(rateProcessingInfo.Payload)
                                                    && rateProcessingInfo.RateProcessingStatusType == RateProcessingStatusTypes.Processing)
                                                && list.Count == propertyCount))).Verifiable();
        _mockRateProcessingInfoService.Setup(x => x.GetByLoadTestRunInfoId(loadTestRunInfo.LoadTestRunInfoId)).ReturnsAsync(rateProcessingInfos).Verifiable();
        _mockQueueLoadTestProcessRateService.Setup(x => x.QueueLoadTestProcessRateRequest(It.Is<LoadTestProcessRateRequest>( loadTestRequest => 
                                        loadTestRequest.RateProcessingInfo.LoadTestRunInfoId == loadTestRunInfo.LoadTestRunInfoId ))).Verifiable();

        await _loadTestInitiationService.HandleLoadTestInitiation(request);
        
        _mockLoadTestRunInfoService.Verify(x => x.SaveAsync(It.IsAny<LoadTestRunInfo>()), Times.Once);
        _mockRateProcessingInfoService.Verify(x => x.SaveRangeAsync(It.IsAny<List<RateProcessingInfo>>()), Times.Once);
        _mockRateProcessingInfoService.Verify(x => x.GetByLoadTestRunInfoId(It.IsAny<int>()), Times.Once);
        _mockQueueLoadTestProcessRateService.Verify(x => x.QueueLoadTestProcessRateRequest(It.IsAny<LoadTestProcessRateRequest>()), Times.Exactly(rateProcessingInfos.Count));
    }
    
    [Fact]
    public void HandleLoadTestInitiation_Failure_ThrowsException()
    {
        var propertyCount = new Random().Next(1, 100);
        var request = GenerateLoadTestInitiateRequest(propertyCount);
        
        _mockLoadTestRunInfoService.Setup(x => x.SaveAsync(It.IsAny<LoadTestRunInfo>())).ThrowsAsync(new Exception("Test")).Verifiable();
        
        Assert.ThrowsAsync<ServiceException>( async () => await _loadTestInitiationService.HandleLoadTestInitiation(request));
        
        _mockLoadTestRunInfoService.Verify(x => x.SaveAsync(It.IsAny<LoadTestRunInfo>()), Times.Once);
        _mockRateProcessingInfoService.Verify(x => x.SaveRangeAsync(It.IsAny<List<RateProcessingInfo>>()), Times.Never);
        _mockRateProcessingInfoService.Verify(x => x.GetByLoadTestRunInfoId(It.IsAny<int>()), Times.Never);
        _mockQueueLoadTestProcessRateService.Verify(x => x.QueueLoadTestProcessRateRequest(It.IsAny<LoadTestProcessRateRequest>()), Times.Never);
    }

    private LoadTestInitiateRequest GenerateLoadTestInitiateRequest(int propertyListLength = 1)
    {
        var values = Enum.GetValues(typeof(RateTypes));
        var random = new Random();
        var rateType = (RateTypes)(values.GetValue(random.Next(values.Length)) ?? RateTypes.DirectAuto);

        var propertyList = new Dictionary<string, List<string>>();
        var properties = typeof(RateRequest).GetProperties();
        var availableProperties = properties.Except(new List<PropertyInfo> {properties.First(x => x.Name == nameof(RateRequest.RateType))}).ToList();
        for (var i = 0; i < propertyListLength; i++)
        {
            var key = availableProperties[random.Next(availableProperties.Count)];
            string value;
            if (key.PropertyType == typeof(DateTime))
            {
                value = new DateTime().AddDays(random.Next(1000)).ToString(CultureInfo.InvariantCulture);
            }
            else if (new List<Type> {typeof(int), typeof(decimal), typeof(long)}.Contains(key.PropertyType))
            {
                value = random.Next(100).ToString();
            }
            else
            {
                value = Guid.NewGuid().ToString();
            }

            if (!propertyList.ContainsKey(key.Name))
            {
                propertyList.Add(key.Name, new List<string> { value } );
            }
            else
            {
                propertyList[key.Name].Add(value);
            }
        }

        return new LoadTestInitiateRequest
        {
            RateType = rateType,
            PropertyList = propertyList
        };
    }

    private static IEnumerable<RateProcessingInfo> GenerateRateProcessingInfos(LoadTestInitiateRequest request, int loadTestRunInfoId)
    => request.PropertyList.Select(
            combination => new RateProcessingInfo
            {
                LoadTestRunInfoId = loadTestRunInfoId, 
                RateProcessingStatusType = RateProcessingStatusTypes.Processing, 
                Payload = JsonConvert.SerializeObject(combination)
            }).ToList();
}