using LCU.Library.Internal.LoanRateModels.Entities;
using LCU.Library.Internal.LcuEvaluation.Services;
using LCU.Library.Internal.Exceptions;
using LCU.Api.Internal.FileOperationsLib.Models.ExcelModels.Requests;
using LCU.API.Internal.LoanRate.Services.LoanRateOperationServices;
using LCU.API.Internal.LoanRate.Services;
using LCU.API.Internal.LoanRate.Services.MicroApiServices;
using LCU.Api.Internal.FileOperationsLib.Models.ExcelModels.Responses;
using LCU.Library.Internal.LcuEvaluationModels.Entities;
using LCU.Library.Internal.LoanRateModels.Enums;
using LCU.Library.Internal.LoanRateModels.Requests;
using LCU.Library.Internal.TypeExtensions.EnumExtensions;

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

public class RateUploaderServiceTest
{
    private readonly RateUploaderService _rateUploaderService;
    private readonly Mock<IRateService> _mockRateService;
    private readonly Mock<IRateSheetService> _mockRateSheetService;
    private readonly Mock<IEvaluationDetailService> _mockEvaluationDetailService;
    private readonly Mock<IRateEvaluationService> _mockRateEvaluationService;
    private readonly Mock<IRateUploadInfoService> _mockRateUploadInfoService;
    private readonly Mock<IFileOperationsApiService> _mockFileOperationsApiService;

    public RateUploaderServiceTest()
    {
        _mockRateService = new Mock<IRateService>();
        _mockRateSheetService = new Mock<IRateSheetService>();
        _mockFileOperationsApiService = new Mock<IFileOperationsApiService>();
        _mockEvaluationDetailService = new Mock<IEvaluationDetailService>();
        _mockRateEvaluationService = new Mock<IRateEvaluationService>();
        _mockRateUploadInfoService = new Mock<IRateUploadInfoService>();
        _rateUploaderService = new RateUploaderService(_mockRateService.Object,
                                                       _mockRateSheetService.Object, 
                                                       _mockEvaluationDetailService.Object, 
                                                       _mockRateEvaluationService.Object,
                                                       _mockRateUploadInfoService.Object,
                                                       _mockFileOperationsApiService.Object);
    }

    public ExcelDataResponse FakeExcelDataResponse()
    {
        return new ExcelDataResponse
        {
            WorkBook = new WorkBook
            {
                SheetResponses = new List<SheetResponse>
                {
                    new SheetResponse(RateTypes.DirectAuto.GetNameFromValue())
                    {
                        CellResponses = new List<CellResponse>
                        {
                            new CellResponse
                            {
                                ColumnName = "A",
                                Row = 10,
                                Value = "2.2",
                                Formula = ""
                            },
                            new CellResponse
                            {
                                ColumnName = "B",
                                Row = 11,
                                Value = "2.3",
                                Formula = ""
                            },
                            new CellResponse
                            {
                                ColumnName = "C",
                                Row = 12,
                                Value = "2.4",
                                Formula = ""
                            },
                            new CellResponse
                            {
                                ColumnName = "D",
                                Row = 13,
                                Value = "2.5",
                                Formula = ""
                            }
                        }
                    }
                }
            }
        };
    }

    public List<Rate> FakeRates()
    {
        return new List<Rate>
        {
            new Rate
            {
                RateId = 1,
                Column = "A",
                Row = "10",
                RateSheetId = 1,
                Value = 2.1M,
                RateStartDate = Convert.ToDateTime("1-1-2023"),
                RateEvaluations = new List<RateEvaluation>
                {
                    new RateEvaluation
                    {
                        RateEvaluationId = 1,
                        RateId = 1,
                        EvaluationDetailId = 1
                    }
                }
            },
            new Rate
            {
                RateId = 2,
                Column = "B",
                Row = "11",
                RateSheetId = 1,
                Value = 0.0M,
                RateStartDate = Convert.ToDateTime("1-1-2023"),
                RateEvaluations = new List<RateEvaluation>
                {
                     new RateEvaluation
                    {
                        RateEvaluationId = 2,
                        RateId = 2,
                        EvaluationDetailId = 2
                    }
                }
            }
        };
    }

    public List<Rate> FakeRatesToUpdate()
    {
        return new List<Rate>()
        {
             new Rate
            {
                RateId = 1,
                Column = "A",
                Row = "10",
                RateSheetId = 1,
                Value = 2.2M,
                RateStartDate = Convert.ToDateTime("1-1-2023"),
                RateEvaluations = new List<RateEvaluation>
                {
                    new RateEvaluation
                    {
                        RateEvaluationId = 1,
                        RateId = 1,
                        EvaluationDetailId = 1
                    }
                }
            },
            new Rate
            {
                RateId = 2,
                Column = "B",
                Row = "11",
                RateSheetId = 1,
                Value = 2.3M,
                RateStartDate = Convert.ToDateTime("1-1-2023"),
                RateEvaluations = new List<RateEvaluation>
                {
                     new RateEvaluation
                    {
                        RateEvaluationId = 2,
                        RateId = 2,
                        EvaluationDetailId = 2
                    }
                }
            }
        };
    }

    public List<Rate> FakeRatesToCreate()
    {
        return new List<Rate>
        {
           new Rate
            {
                RateId = 0,
                Column = "C",
                Row = "12",
                RateSheetId = 1,
                Value = 2.4M,
                RateStartDate = Convert.ToDateTime("1-1-2023")
            },
            new Rate
            {
                RateId = 0,
                Column = "D",
                Row = "13",
                RateSheetId = 1,
                Value = 2.5M,
                RateStartDate = Convert.ToDateTime("1-1-2023")
            }
        };
    }

    private List<RateSheet> FakeRateSheets()
    {
        var rateTypes = Enum.GetValues(typeof(RateTypes)).Cast<RateTypes>().ToList();
        return rateTypes.Select((t, i) => new RateSheet { RateSheetId = i + 1, RateType = t }).ToList();
    }

    private RateUploadInfo FakeRateUploadInfo()
        => new ()
        {
            EffectiveDate = DateTime.Now
        };

    [Fact]
    public async Task RateUploader_UploadRates_RateExcelPath_Success()
    {
        var effectiveDate = DateTime.Now;
        var request = new RateUploadRequest
        {
            FileName = "Test",
            FileContent = "Test",
            EffectiveDate = effectiveDate
        };

        var excelDataResponse = new ExcelDataResponse
        {
            WorkBook = new WorkBook
            {
                SheetResponses = new List<SheetResponse>
                {
                    new SheetResponse(RateTypes.DirectBoat.GetNameFromValue())
                    {
                        CellResponses = new List<CellResponse>
                        {
                            new CellResponse
                            {
                                ColumnName = "A",
                                Row = 10,
                                Value = "2.2",
                                Formula = ""
                            },
                            new CellResponse
                            {
                                ColumnName = "B",
                                Row = 11,
                                Value = "2.3",
                                Formula = ""
                            }
                        }
                    }
                }
            }
        };

        var rates = FakeRates();
        var rateSheets = FakeRateSheets();
        var ratesToCreate = FakeRatesToCreate();
        var previousRateUploadInfo = FakeRateUploadInfo();

        _mockRateService.Setup(x => x.GetByDateAsync(It.IsAny<DateTime>())).ReturnsAsync(rates);
        _mockRateSheetService.Setup(x => x.GetAsync()).ReturnsAsync(rateSheets);
        _mockFileOperationsApiService.Setup(x => x.DirectExtractExcelWorkBookData(It.IsAny<ExcelDataRequest>())).ReturnsAsync(excelDataResponse).Verifiable();
        
        _mockRateUploadInfoService.Setup(x => x.SaveAsync( It.Is<RateUploadInfo>(rateUploadInfo => rateUploadInfo.Rates.Count == ratesToCreate.Count)));
        _mockRateUploadInfoService.Setup(x => x.GetLatestVersionOnDate(effectiveDate)).ReturnsAsync(previousRateUploadInfo).Verifiable();

        await _rateUploaderService.UploadRates(request);

        _mockRateService.Verify(x => x.GetByDateAsync(It.IsAny<DateTime>()), Times.Once);
        _mockFileOperationsApiService.Verify(x => x.DirectExtractExcelWorkBookData(It.IsAny<ExcelDataRequest>()), Times.Once);        
        _mockRateUploadInfoService.Verify(x => x.SaveAsync(It.IsAny<RateUploadInfo>()), Times.Once);
    }

    [Fact]
    public void RateUploader_UploadRates_RateExcelPath_RateServiceGetByDate_ThrowsException()
    {
        var request = new RateUploadRequest
        {
            FileContent = "Test",
            FileName = "Test",
            EffectiveDate = DateTime.Now
        };
        
        var excelDataResponse = FakeExcelDataResponse();
        var ratesToUpdate = FakeRatesToUpdate();
        var ratesToCreate = FakeRatesToCreate();

        _mockRateService.Setup(x => x.GetByDateAsync(It.IsAny<DateTime>())).Throws(new Exception("Test")).Verifiable();
        _mockFileOperationsApiService.Setup(x => x.DirectExtractExcelWorkBookData(It.IsAny<ExcelDataRequest>())).ReturnsAsync(excelDataResponse).Verifiable();
        _mockRateUploadInfoService.Setup(x => x.SaveAsync( It.Is<RateUploadInfo>(rateUploadInfo => rateUploadInfo.Rates.Count == ratesToCreate.Count)));
        _mockRateService.Setup(x => x.UpdateRangeAsync(ratesToUpdate)).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () => await _rateUploaderService.UploadRates(request));        
        _mockRateService.Verify(x => x.GetByDateAsync(It.IsAny<DateTime>()), Times.Once);
        _mockFileOperationsApiService.Verify(x => x.DirectExtractExcelWorkBookData(It.IsAny<ExcelDataRequest>()), Times.Never);
        _mockRateUploadInfoService.Verify(x => x.SaveAsync(It.IsAny<RateUploadInfo>()), Times.Never);
        _mockRateService.Verify(x => x.UpdateRangeAsync(It.Is<List<Rate>>(rates => rates.Count() == 2)), Times.Never);
    }

    [Fact]
    public void RateUploader_UploadRates_RateExcelPath_FileOperations_ThrowsException()
    {
        var request = new RateUploadRequest
        {
            FileName = "Test",
            FileContent = "Test",
            EffectiveDate = DateTime.Now
        };

        var rates = FakeRates();
        var rateSheets = FakeRateSheets();
        var ratesToUpdate = FakeRatesToUpdate();
        var ratesToCreate = FakeRatesToCreate();

        _mockRateService.Setup(x => x.GetByDateAsync(It.IsAny<DateTime>())).ReturnsAsync(rates);
        _mockRateSheetService.Setup(x => x.GetAsync()).ReturnsAsync(rateSheets);
        _mockFileOperationsApiService.Setup(x => x.DirectExtractExcelWorkBookData(It.IsAny<ExcelDataRequest>())).Throws(new Exception("Test")).Verifiable();       
        _mockRateUploadInfoService.Setup(x => x.SaveAsync( It.Is<RateUploadInfo>(rateUploadInfo => rateUploadInfo.Rates.Count == ratesToCreate.Count)));
        _mockRateService.Setup(x => x.UpdateRangeAsync(ratesToUpdate)).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () => await _rateUploaderService.UploadRates(request));

        _mockRateService.Verify(x => x.GetByDateAsync(It.IsAny<DateTime>()), Times.Once);
        _mockFileOperationsApiService.Verify(x => x.DirectExtractExcelWorkBookData(It.IsAny<ExcelDataRequest>()), Times.Once);
        
        _mockRateUploadInfoService.Verify(x => x.SaveAsync(It.IsAny<RateUploadInfo>()), Times.Never);
        _mockRateService.Verify(x => x.UpdateRangeAsync(It.Is<List<Rate>>(rates => rates.Count() == 2)), Times.Never);
    }    

    [Fact]
    public async Task RateUploader_UploadRates_ExcelDataRequest_Success()
    {
        var effectiveDate = DateTime.Now;
        var fileContent = "Test";
        var request = new RateUploadExcelDataRequest
        {
            EffectiveDate = effectiveDate,
            ExcelDataRequest = new ExcelDataRequest
            {
                FileContent = fileContent,
                SheetRequests = new List<SheetRequest>
                {
                    new()
                    {
                        SheetName = RateTypes.DirectBoat.GetNameFromValue(),
                        Rows = new List<int> { 10, 11, 12, 13 },
                        Columns = new List<string> { "A", "B", "C", "D" }
                    }
                }
            }
        };

        var excelDataResponse = FakeExcelDataResponse();
        var rates = FakeRates();
        var rateSheets = FakeRateSheets();
        var previousRateUploadInfo = FakeRateUploadInfo();

        _mockFileOperationsApiService.Setup(x => x.DirectExtractExcelWorkBookData(request.ExcelDataRequest)).ReturnsAsync(excelDataResponse).Verifiable();
        _mockRateSheetService.Setup(x => x.GetAsync()).ReturnsAsync(rateSheets);
        _mockRateService.Setup(x => x.GetByDateAsync(It.IsAny<DateTime>())).ReturnsAsync(rates);
        _mockRateUploadInfoService.Setup(x => x.SaveAsync(It.IsAny<RateUploadInfo>())).Verifiable();
        _mockRateUploadInfoService.Setup(x => x.GetLatestVersionOnDate(effectiveDate)).ReturnsAsync(previousRateUploadInfo).Verifiable();

        await _rateUploaderService.UploadRates(request);

        _mockFileOperationsApiService.Verify(x => x.DirectExtractExcelWorkBookData(It.IsAny<ExcelDataRequest>()), Times.Once);
        _mockRateService.Verify(x => x.GetByDateAsync(It.IsAny<DateTime>()), Times.Once);
        _mockRateUploadInfoService.Verify(x => x.SaveAsync(It.IsAny<RateUploadInfo>()), Times.Once);
    }

    [Fact]
    public void RateUploader_UploadRates_ExcelDataRequest_FileOperations_ThrowsException()
    {
        var fileContent = "Test";
        var request = new RateUploadExcelDataRequest
        {
            EffectiveDate = DateTime.Now,
            ExcelDataRequest = new ExcelDataRequest
            {
                FileContent = fileContent,
                SheetRequests = new List<SheetRequest>
                {
                    new()
                    {
                        SheetName = "Test",
                        Rows = new List<int> { 10, 11, 12, 13 },
                        Columns = new List<string> { "A", "B", "C", "D" }
                    }
                }
            }
        };

        var rates = FakeRates();
        var ratesToCreate = FakeRatesToCreate();

        _mockFileOperationsApiService.Setup(x => x.DirectExtractExcelWorkBookData(request.ExcelDataRequest)).Throws(new Exception("Test")).Verifiable();
        _mockRateService.Setup(x => x.GetByDateAsync(It.IsAny<DateTime>())).ReturnsAsync(rates);
        _mockRateUploadInfoService.Setup(x => x.SaveAsync( It.Is<RateUploadInfo>(rateUploadInfo => rateUploadInfo.Rates.Count == ratesToCreate.Count)));

        Assert.ThrowsAsync<ServiceException>(async () => await _rateUploaderService.UploadRates(request));

        _mockFileOperationsApiService.Verify(x => x.DirectExtractExcelWorkBookData(It.IsAny<ExcelDataRequest>()), Times.Once);
        _mockRateService.Verify(x => x.GetByDateAsync(It.IsAny<DateTime>()), Times.Never);
        _mockRateUploadInfoService.Verify(x => x.SaveAsync(It.IsAny<RateUploadInfo>()), Times.Never);
    }

    [Fact]
    public void RateUploader_UploadRates_ExcelDataRequest_RateServiceGetByDate_ThrowsException()
    {
        var fileContent = "Test";
        var request = new RateUploadExcelDataRequest
        {
            EffectiveDate = DateTime.Now,
            ExcelDataRequest = new ExcelDataRequest
            {
                FileContent = fileContent,
                SheetRequests = new List<SheetRequest>
                {
                    new()
                    {
                        SheetName = "Test",
                        Rows = new List<int> { 10, 11, 12, 13 },
                        Columns = new List<string> { "A", "B", "C", "D" }
                    }
                }
            }
        };

        var excelDataResponse = FakeExcelDataResponse();
        var ratesToCreate = FakeRatesToCreate();

        _mockFileOperationsApiService.Setup(x => x.DirectExtractExcelWorkBookData(request.ExcelDataRequest)).ReturnsAsync(excelDataResponse).Verifiable();
        _mockRateService.Setup(x => x.GetByDateAsync(It.IsAny<DateTime>())).Throws(new Exception("Test")).Verifiable();
        _mockRateUploadInfoService.Setup(x => x.SaveAsync( It.Is<RateUploadInfo>(rateUploadInfo => rateUploadInfo.Rates.Count == ratesToCreate.Count)));

        Assert.ThrowsAsync<ServiceException>(async () => await _rateUploaderService.UploadRates(request));

        _mockFileOperationsApiService.Verify(x => x.DirectExtractExcelWorkBookData(It.IsAny<ExcelDataRequest>()), Times.Once);
        _mockRateService.Verify(x => x.GetByDateAsync(It.IsAny<DateTime>()), Times.Once);
        _mockRateUploadInfoService.Verify(x => x.SaveAsync(It.IsAny<RateUploadInfo>()), Times.Never);
    }

    [Fact]
    public void RateUploader_BuildExcelDataRequest_Succcess()
    {
        var rateExcelContent = "Test";
        var rates = FakeRates();
        var rateSheets = FakeRateSheets();
        var excelDataRequest = _rateUploaderService.BuildExcelDataRequest(rateExcelContent, rates, rateSheets);

        Assert.NotNull(excelDataRequest);
        Assert.NotNull(excelDataRequest.SheetRequests);
        Assert.Single(excelDataRequest.SheetRequests);
        var sheetRequest = excelDataRequest.SheetRequests.FirstOrDefault();
        Assert.NotNull(sheetRequest);
        Assert.NotNull(sheetRequest.Rows);
        Assert.Equal(2, sheetRequest.Rows.Count);
        Assert.NotNull(sheetRequest.Columns);
        Assert.Equal(2, sheetRequest.Columns.Count);
        Assert.Equal(rateExcelContent, excelDataRequest.FileContent);
    }

    [Fact]
    public async Task RateUploader_WorkThroughExcelDataResponseAndUpdateRates_Success()
    {
        var excelDataResponse = FakeExcelDataResponse();
        var rates = FakeRates();
        var rateSheets = FakeRateSheets();
        var ratesToCreate = FakeRatesToCreate();
        var rateUploadInfo = FakeRateUploadInfo();
        rateUploadInfo.Rates = ratesToCreate;

        _mockRateUploadInfoService.Setup(x => x.SaveAsync(It.IsAny<RateUploadInfo>())).Verifiable();

        await _rateUploaderService.WorkThroughExcelDataResponseAndUpdateRates(excelDataResponse, rateUploadInfo, rates, rateSheets, DateTime.Now);

        _mockRateUploadInfoService.Verify(x => x.SaveAsync(It.IsAny<RateUploadInfo>()), Times.Once);
    }

    [Fact]
    public async Task RateUploader_WorkThroughExcelDataResponseAndUpdateRates_NullWorkbook_Done()
    {
        var excelDataResponse = new ExcelDataResponse
        {
            WorkBook = null
        };
        var rates = FakeRates();
        var rateSheets = FakeRateSheets();
        var rateUploadInfo = FakeRateUploadInfo();

        await _rateUploaderService.WorkThroughExcelDataResponseAndUpdateRates(excelDataResponse, rateUploadInfo, rates, rateSheets, DateTime.Now);

        _mockRateUploadInfoService.Verify(x => x.SaveAsync(It.IsAny<RateUploadInfo>()), Times.Never);
        _mockRateService.Verify(x => x.UpdateRangeAsync(It.IsAny<List<Rate>>()), Times.Never);
    }

    [Fact]
    public async Task RateUploader_WorkThroughExcelDataResponseAndUpdateRates_NullSheetResponses_Done()
    {
        var excelDataResponse = new ExcelDataResponse
        {
            WorkBook = new WorkBook
            {
                SheetResponses = null
            }
        };
        var rates = FakeRates();
        var rateSheets = FakeRateSheets();
        var rateUploadInfo = FakeRateUploadInfo();

        await _rateUploaderService.WorkThroughExcelDataResponseAndUpdateRates(excelDataResponse, rateUploadInfo, rates, rateSheets, DateTime.Now);

        _mockRateUploadInfoService.Verify(x => x.SaveAsync(It.IsAny<RateUploadInfo>()), Times.Never);
        _mockRateService.Verify(x => x.UpdateRangeAsync(It.IsAny<List<Rate>>()), Times.Never);
    }

    [Fact]
    public void RateUploader_WorkThroughExcelDataResponseAndUpdateRates_NonDecimalCellValue_ServiceException()
    {
        var excelDataResponse = new ExcelDataResponse
        {
            WorkBook = new WorkBook
            {
                SheetResponses = new List<SheetResponse>
                {
                    new SheetResponse("Test")
                    {
                        CellResponses = new List<CellResponse>
                        {
                            new CellResponse
                            {
                                ColumnName = "A",
                                Row = 10,
                                Value = "2.2",
                                Formula = ""
                            },
                            new CellResponse
                            {
                                ColumnName = "B",
                                Row = 11,
                                Value = "2.3",
                                Formula = ""
                            },
                            new CellResponse
                            {
                                ColumnName = "C",
                                Row = 12,
                                Value = "TEST",
                                Formula = ""
                            },
                            new CellResponse
                            {
                                ColumnName = "D",
                                Row = 13,
                                Value = "2.5",
                                Formula = ""
                            }
                        }
                    }
                }
            }
        };
        var rates = FakeRates();
        var rateSheets  = FakeRateSheets();
        var rateUploadInfo = FakeRateUploadInfo();

        Assert.ThrowsAsync<ServiceException>(
            async () => await _rateUploaderService.WorkThroughExcelDataResponseAndUpdateRates(excelDataResponse, rateUploadInfo, rates, rateSheets, DateTime.Now));
        _mockRateUploadInfoService.Verify(x => x.SaveAsync(It.IsAny<RateUploadInfo>()), Times.Never);
        _mockRateService.Verify(x => x.UpdateRangeAsync(It.IsAny<List<Rate>>()), Times.Never);
    }
    
    [Fact]
    public async Task RateUploader_InitiateRatesEvaluations_Success()
    {
        var rateSheets = FakeRateSheets();
        var requests = new List<InitiateRatesEvaluationsRequest>
        {
            new()
            {
                SheetName = rateSheets[0].SheetName,
                EvaluationDetailId = DateTime.Now.Millisecond,
                RowsOrColumns = new List<string> { Guid.NewGuid().ToString() }
            },
            new()
            {
                SheetName = rateSheets[1].SheetName,
                EvaluationDetailId = DateTime.Now.Millisecond,
                RowsOrColumns = new List<string> { Guid.NewGuid().ToString() }
            },
            new()
            {
                SheetName = rateSheets[2].SheetName,
                EvaluationDetailId = DateTime.Now.Millisecond,
                RowsOrColumns = new List<string> { Guid.NewGuid().ToString() }
            }
        };

        var rules = new List<EvaluationDetail>
        {
            new() { EvaluationDetailId = requests[0].EvaluationDetailId },
            new() { EvaluationDetailId = requests[1].EvaluationDetailId },
            new() { EvaluationDetailId = requests[2].EvaluationDetailId }
        };

        var rates = new List<Rate>
        {
            new()
            {
                RateSheetId = rateSheets[0].RateSheetId, 
                Column = requests[0].RowsOrColumns[0],
                RateEvaluations = new List<RateEvaluation>()
            },
            new()
            {
                RateSheetId = rateSheets[0].RateSheetId, 
                Column = requests[0].RowsOrColumns[0],
                RateEvaluations = new List<RateEvaluation>()
            },
            new()
            {
                RateSheetId = rateSheets[0].RateSheetId, 
                Row = requests[0].RowsOrColumns[0],
                RateEvaluations = new List<RateEvaluation>()
            },
            new()
            {
                RateSheetId = rateSheets[1].RateSheetId,
                Column = requests[1].RowsOrColumns[0],
                RateEvaluations = new List<RateEvaluation>()
            },
            new()
            {
                RateSheetId = rateSheets[1].RateSheetId,
                Column = requests[1].RowsOrColumns[0],
                RateEvaluations = new List<RateEvaluation>()
            },
            new()
            {
                RateSheetId = rateSheets[2].RateSheetId,
                Column = requests[2].RowsOrColumns[0],
                RateEvaluations = new List<RateEvaluation>()
            }
        };

        var tab1 = rates.Where(rate => rate.RateSheetId == rateSheets[0].RateSheetId);
        var tab2 = rates.Where(rate => rate.RateSheetId == rateSheets[1].RateSheetId);
        var tab3 = rates.Where(rate => rate.RateSheetId == rateSheets[2].RateSheetId);
        
        _mockRateSheetService.SetupSequence(x => x.GetRatesByRateTypeAsync(It.IsAny<RateTypes>())).ReturnsAsync(tab1)
                                                                                                  .ReturnsAsync(tab2)
                                                                                                  .ReturnsAsync(tab3);
        _mockEvaluationDetailService.SetupSequence(x => x.GetByIdAsync(It.IsAny<int>())).ReturnsAsync(rules[0])
                                                                                        .ReturnsAsync(rules[1])
                                                                                        .ReturnsAsync(rules[2]);

        var result = (await _rateUploaderService.InitiateRatesEvaluations(requests)).ToList();
        Assert.NotNull(result);
        Assert.NotEmpty(result);
        Assert.Equal(3, result.Count(x => x.Success));

        _mockRateSheetService.Verify(x => x.GetRatesByRateTypeAsync(It.IsAny<RateTypes>()), Times.Exactly(3));
        _mockEvaluationDetailService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Exactly(3));
        _mockRateEvaluationService.Verify(x => x.SaveRangeAsync(It.Is<List<RateEvaluation>>( savedRates => savedRates.Count == 5 )), Times.Once);
    }
    
        [Fact]
    public async Task RateUploader_InitiateRatesEvaluations_NotFound_Success()
    {
        var rateSheets = FakeRateSheets();
        var requests = new List<InitiateRatesEvaluationsRequest>
        {
            new()
            {
                SheetName = rateSheets[0].SheetName,
                EvaluationDetailId = DateTime.Now.Millisecond,
                RowsOrColumns = new List<string> { Guid.NewGuid().ToString() }
            },
            new()
            {
                SheetName = rateSheets[1].SheetName,
                EvaluationDetailId = DateTime.Now.Millisecond,
                RowsOrColumns = new List<string> { Guid.NewGuid().ToString() }
            },
            new()
            {
                SheetName = rateSheets[2].SheetName,
                EvaluationDetailId = DateTime.Now.Millisecond,
                RowsOrColumns = new List<string> { Guid.NewGuid().ToString() }
            }
        };

        var rules = new List<EvaluationDetail>
        {
            new() { EvaluationDetailId = requests[0].EvaluationDetailId },
            null,
            new() { EvaluationDetailId = requests[2].EvaluationDetailId }
        };

        var rates = new List<Rate>
        {
            new()
            {
                RateSheetId = rateSheets[0].RateSheetId, 
                Column = requests[0].RowsOrColumns[0],
                RateEvaluations = new List<RateEvaluation>()
            },
            new()
            {
                RateSheetId = rateSheets[0].RateSheetId, 
                Column = requests[0].RowsOrColumns[0],
                RateEvaluations = new List<RateEvaluation>()
            },
            new()
            {
                RateSheetId = rateSheets[0].RateSheetId, 
                Column = requests[0].RowsOrColumns[0],
                RateEvaluations = new List<RateEvaluation>()
            },
            new()
            {
                RateSheetId = rateSheets[1].RateSheetId,
                Column = requests[1].RowsOrColumns[0],
                RateEvaluations = new List<RateEvaluation>()
            },
            new()
            {
                RateSheetId = rateSheets[1].RateSheetId,
                Column = requests[1].RowsOrColumns[0],
                RateEvaluations = new List<RateEvaluation>()
            },
            new()
            {
                RateSheetId = rateSheets[2].RateSheetId,
                Column = requests[2].RowsOrColumns[0],
                RateEvaluations = new List<RateEvaluation>()
            }
        };

        var tab1 = rates.Where(rate => rate.RateSheetId == rateSheets[0].RateSheetId);
        var tab2 = rates.Where(rate => rate.RateSheetId == rateSheets[1].RateSheetId);
        var tab3 = rates.Where(rate => rate.RateSheetId == rateSheets[2].RateSheetId);

        _mockRateSheetService.Setup(x => x.GetAsync()).ReturnsAsync(rateSheets);
        _mockRateSheetService.SetupSequence(x => x.GetRatesByRateTypeAsync(It.IsAny<RateTypes>())).ReturnsAsync(tab1)
                                                                                                  .ReturnsAsync(tab2)
                                                                                                  .ReturnsAsync(tab3);
        _mockEvaluationDetailService.SetupSequence(x => x.GetByIdAsync(It.IsAny<int>())).ReturnsAsync(rules[0])
                                                                                        .ReturnsAsync(rules[1])
                                                                                        .ReturnsAsync(rules[2]);

        var result = (await _rateUploaderService.InitiateRatesEvaluations(requests)).ToList();
        Assert.NotNull(result);
        Assert.NotEmpty(result);
        Assert.Equal(3, result.Count(x => x.Success));

        _mockRateSheetService.Verify(x => x.GetRatesByRateTypeAsync(It.IsAny<RateTypes>()), Times.Exactly(3));
        _mockEvaluationDetailService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Exactly(3));
        _mockRateEvaluationService.Verify(x => x.SaveRangeAsync(It.Is<List<RateEvaluation>>( savedRates => savedRates.Count == 4 )), Times.Once);
    }
    
    [Fact]
    public async Task RateUploader_InitiateRatesEvaluations_ThrowsException_Failure()
    {
        var requests = new List<InitiateRatesEvaluationsRequest>
        {
            new()
            {
                SheetName = RateTypes.DirectMotorcycle.GetNameFromValue(),
                EvaluationDetailId = DateTime.Now.Millisecond,
                RowsOrColumns = new List<string> { Guid.NewGuid().ToString() }
            }
        };
        
        _mockRateSheetService.Setup(x => x.GetRatesByRateTypeAsync(It.IsAny<RateTypes>())).Throws(new Exception("Test")).Verifiable();

        await Assert.ThrowsAsync<ServiceException>(async () => await _rateUploaderService.InitiateRatesEvaluations(requests));

        _mockRateSheetService.Verify(x => x.GetRatesByRateTypeAsync(It.IsAny<RateTypes>()), Times.Once);
        _mockEvaluationDetailService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Never);
        _mockRateEvaluationService.Verify(x => x.SaveRangeAsync(It.IsAny<List<RateEvaluation>>()), Times.Never);
    }
}