using AsbCloudApp.Data;
using AsbCloudApp.Data.DetectedOperation;
using AsbCloudApp.Data.SAUB;
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests;
using AsbCloudApp.Services;
using AsbCloudInfrastructure.Services;
using Mapster;
using NSubstitute;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Xunit;

namespace AsbCloudInfrastructure.Tests.Services;

public class DataSaubStatDtillingQualityServiceTest
{
    private readonly int Gap = 5;
    private readonly IDataSaubStatRepository<DataSaubStatDrillingQualityDto> dataSaubStatRepositoryMock = Substitute.For<IDataSaubStatRepository<DataSaubStatDrillingQualityDto>>();
    private readonly ITelemetryDataCache<TelemetryDataSaubDto> telemetryDataCacheMock = Substitute.For<ITelemetryDataCache<TelemetryDataSaubDto>>();
    private readonly IDetectedOperationRepository detectedOperationRepositoryMock = Substitute.For<IDetectedOperationRepository>();
    private readonly ITelemetryDataSaubService dataSaubServiceMock = Substitute.For<ITelemetryDataSaubService>();

    private DataSaubStatDrillingQualityService dataSaubStatService;

    private int[] idTelemetries = [1];
    private IEnumerable<DataSaubStatDrillingQualityDto> dataSaubStatDrillingQualityDtos = new List<DataSaubStatDrillingQualityDto>()
    {
        new DataSaubStatDrillingQualityDto {
            Id = 1,
            DateEnd = DateTime.UtcNow,
            DateStart = DateTime.UtcNow.AddHours(-1),
            DepthEnd = 2,
            DepthStart = 1,
            IdFeedRegulator = 1,
            IdTelemetry = 1
        },
        new DataSaubStatDrillingQualityDto {
            Id = 2,
            DateEnd = DateTime.UtcNow,
            DateStart = DateTime.UtcNow.AddHours(-1),
            DepthEnd = 3,
            DepthStart = 2,
            IdFeedRegulator = 2,
            IdTelemetry = 2,
        },
        new DataSaubStatDrillingQualityDto {
            Id = 3,
            DateEnd = DateTime.UtcNow,
            DateStart = DateTime.UtcNow.AddHours(-1),
            DepthEnd = 4,
            DepthStart = 3,
            IdFeedRegulator = 3,
            IdTelemetry = 3,
        },
    };


    private List<TelemetryDataSaubDto> telemetryDataSaubDtos = new List<TelemetryDataSaubDto> {
        new TelemetryDataSaubDto()
        {
            IdTelemetry = 1,
            DateTime = DateTime.UtcNow.AddMinutes(-30),
            AxialLoad = 800,
            AxialLoadLimitMax = 1,
            AxialLoadSp = 1,
            BitDepth = 1,
            BlockPosition = 1,
            BlockPositionMax = 1,
            BlockPositionMin = 1,
            BlockSpeed = 1,
            BlockSpeedSp = 1,
            BlockSpeedSpDevelop = 1,
            BlockSpeedSpRotor = 1,
            BlockSpeedSpSlide = 1,
            Flow = 1,
            FlowDeltaLimitMax = 1,
            FlowIdle = 1,
            HookWeight = 1,
            HookWeightIdle = 1,
            HookWeightLimitMax = 1,
            HookWeightLimitMin = 1,
            IdFeedRegulator = 1,
            IdUser = 1,
            Mode = 1,
            Mse = 1,
            MseState = 1,
            Pressure = 1,
            PressureDeltaLimitMax = 1,
            PressureIdle = 1,
            PressureSp = 1,
            PressureSpDevelop = 1,
            PressureSpRotor = 1,
            PressureSpSlide = 1,
            Pump0Flow = 1,
            Pump1Flow = 1,
            Pump2Flow = 1,
            RotorSpeed = 1,
            RotorTorque = 1,
            RotorTorqueIdle = 1,
            RotorTorqueSp = 1,
            RotorTorqueLimitMax = 1,
            WellDepth = 800,
        }
    };

    public DataSaubStatDtillingQualityServiceTest()
    {
        telemetryDataCacheMock
            .GetIds(Arg.Any<TelemetryDataRequest>())
            .Returns(idTelemetries);

        dataSaubStatRepositoryMock
            .GetLastsAsync(Arg.Any<int[]>(), Arg.Any<CancellationToken>())
            .Returns(dataSaubStatDrillingQualityDtos);

        dataSaubStatService = new DataSaubStatDrillingQualityService(
            dataSaubStatRepositoryMock,
            telemetryDataCacheMock,
            dataSaubServiceMock);
    }

    private TelemetryDataSaubDto CreateTelemetryDataSaubItem(
        TelemetryDataSaubDto telemetrySaubDto, 
        float wellDepth, 
        float bitDepth,
        short idFeedRegulator,
        DateTime dateTime)
    {
        var telemetrySaubDto1 = telemetrySaubDto.Adapt<TelemetryDataSaubDto>();
        telemetrySaubDto1.WellDepth = wellDepth;
        telemetrySaubDto1.BitDepth = bitDepth;
        telemetrySaubDto1.IdFeedRegulator = idFeedRegulator;
        telemetrySaubDto1.DateTime = dateTime;

        return telemetrySaubDto1;
    }

    [Fact]
    public async Task Create_1DataSaubStatItems_ShouldReturn__Success()
    {
        var telemetrySaubDto = telemetryDataSaubDtos.FirstOrDefault();
        if (telemetrySaubDto != null)
        {
            //idFeedRegulator   depthWell
            //1                 800
            //1                 900
            //1                 1000
            //1                 900
            //1                 1200
            //1                 1300
            //1                 1100
            //1                 1500
            //2                 1600
            //Ожидаемые результаты для idFeedRegulator:
            // количество возвращаемых записей = 3
            // общая глубина = (1000 - 800) + (1300 - 900) + (1600 - 1100) = 1100
            var telemetrySaubDto1 = CreateTelemetryDataSaubItem(
                telemetrySaubDto,
                wellDepth: 900,
                bitDepth: 900,
                idFeedRegulator: 1,
                dateTime: DateTime.UtcNow.AddMinutes(20));
            telemetryDataSaubDtos.Add(telemetrySaubDto1);

            var telemetrySaubDto2 = CreateTelemetryDataSaubItem(
                telemetrySaubDto,
                wellDepth: 1000,
                bitDepth: 1000,
                idFeedRegulator: 1,
                dateTime: DateTime.UtcNow.AddMinutes(20));
            telemetryDataSaubDtos.Add(telemetrySaubDto2);

            var telemetrySaubDto3 = CreateTelemetryDataSaubItem(
                telemetrySaubDto,
                wellDepth: 900,
                bitDepth: 900,
                idFeedRegulator: 1,
                dateTime: DateTime.UtcNow.AddMinutes(20));
            telemetryDataSaubDtos.Add(telemetrySaubDto3);

            var telemetrySaubDto4 = CreateTelemetryDataSaubItem(
                telemetrySaubDto,
                wellDepth: 1200,
                bitDepth: 1200,
                idFeedRegulator: 1,
                dateTime: DateTime.UtcNow.AddMinutes(20));
            telemetryDataSaubDtos.Add(telemetrySaubDto4);

            var telemetrySaubDto5 = CreateTelemetryDataSaubItem(
                telemetrySaubDto,
                wellDepth: 1300,
                bitDepth: 1300,
                idFeedRegulator: 1,
                dateTime: DateTime.UtcNow.AddMinutes(20));
            telemetryDataSaubDtos.Add(telemetrySaubDto5);

            var telemetrySaubDto6 = CreateTelemetryDataSaubItem(
                telemetrySaubDto,
                wellDepth: 1100,
                bitDepth: 1100,
                idFeedRegulator: 1,
                dateTime: DateTime.UtcNow.AddMinutes(20));
            telemetryDataSaubDtos.Add(telemetrySaubDto6);

            var telemetrySaubDto7 = CreateTelemetryDataSaubItem(
                telemetrySaubDto,
                wellDepth: 1500,
                bitDepth: 1500,
                idFeedRegulator: 1,
                dateTime: DateTime.UtcNow.AddMinutes(20));
            telemetryDataSaubDtos.Add(telemetrySaubDto7);

            var telemetrySaubDto8 = CreateTelemetryDataSaubItem(
                telemetrySaubDto,
                wellDepth: 1600,
                bitDepth: 1600,
                idFeedRegulator: 2,
                dateTime: DateTime.UtcNow.AddMinutes(20));
            telemetryDataSaubDtos.Add(telemetrySaubDto8);
        }

        dataSaubServiceMock
            .Get(Arg.Any<int>(), Arg.Any<bool>(), Arg.Any<DateTimeOffset>(), Arg.Any<DateTimeOffset>(), Arg.Any<int>(), Arg.Any<CancellationToken>())
            .Returns(telemetryDataSaubDtos);

        //act
        var result = await dataSaubStatService.CreateStatDrillingQualityForTelemetry(1, DateTimeOffset.UnixEpoch, CancellationToken.None);

        //assert
        Assert.Equal(3, result.Count());
    }



    //[Fact]
    //public async Task Create_2DataSaubStatItems_ShouldReturn__Success()
    //{
    //    var insertedDataSaubStatCount = 2;

    //    var detectedOperationDto = detectedOperationDtos.FirstOrDefault();
    //    if (detectedOperationDto != null)
    //    {
    //        var detectedOperationDto1 = detectedOperationDto.Adapt<DetectedOperationDto>();
    //        detectedOperationDto1.DateStart = DateTimeOffset.UtcNow.AddMinutes(1);
    //        detectedOperationDto1.DateEnd = DateTimeOffset.UtcNow.AddHours(1);

    //        detectedOperationDtos.Add(detectedOperationDto1);
    //    }

    //    var telemetryDataSaubDto = telemetryDataSaubDtos.LastOrDefault();
    //    if (telemetryDataSaubDto != null)
    //    {
    //        var telemetryDataSaubDto1 = telemetryDataSaubDto.Adapt<TelemetryDataSaubDto>();
    //        telemetryDataSaubDto1.DateTime = DateTime.UtcNow.AddMinutes(10);
    //        telemetryDataSaubDto1.WellDepth = telemetryDataSaubDto.WellDepth + 1;

    //        var telemetryDataSaubDto2 = telemetryDataSaubDto.Adapt<TelemetryDataSaubDto>();
    //        telemetryDataSaubDto2.DateTime = DateTime.UtcNow.AddMinutes(20);
    //        telemetryDataSaubDto2.WellDepth = telemetryDataSaubDto1.WellDepth + 1;

    //        var telemetryDataSaubDto3 = telemetryDataSaubDto.Adapt<TelemetryDataSaubDto>();
    //        telemetryDataSaubDto3.DateTime = DateTime.UtcNow.AddMinutes(30);
    //        telemetryDataSaubDto3.WellDepth = telemetryDataSaubDto2.WellDepth + 1;

    //        telemetryDataSaubDtos.Add(telemetryDataSaubDto1);
    //        telemetryDataSaubDtos.Add(telemetryDataSaubDto2);
    //        telemetryDataSaubDtos.Add(telemetryDataSaubDto3);
    //    }

    //    detectedOperationRepositoryMock
    //        .Get(Arg.Any<DetectedOperationByTelemetryRequest>(), Arg.Any<CancellationToken>())
    //        .Returns(detectedOperationDtos);

    //    dataSaubStatRepositoryMock
    //        .InsertRangeAsync(Arg.Any<IEnumerable<DataSaubStatDto>>(), Arg.Any<CancellationToken>())
    //        .Returns(insertedDataSaubStatCount);

    //    Action<string, double?> action = (message, percent) =>
    //    {
    //        //assert
    //        Assert.NotNull(percent);
    //        Assert.InRange(percent.Value, 0.0, 1.0);
    //    };

    //    //act
    //    await dataSaubStatService.CreateStatAsync(Gap, action, CancellationToken.None);

    //    //assert
    //    await dataSaubStatRepositoryMock.Received().InsertRangeAsync(
    //        Arg.Is<IEnumerable<DataSaubStatDto>>(l => l.Count() == insertedDataSaubStatCount),
    //        Arg.Any<CancellationToken>());
    //}
}