DD.WellWorkover.Cloud/AsbCloudInfrastructure/Services/DetectOperations/DetectedOperationService.cs

using System;
using AsbCloudApp.Data;
using AsbCloudApp.Data.DetectedOperation;
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests;
using AsbCloudApp.Services;
using AsbCloudDb.Model;
using Mapster;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AsbCloudApp.Data.WellOperation;
using AsbCloudApp.Exceptions;
using AsbCloudInfrastructure.Services.DetectOperations.Detectors;

namespace AsbCloudInfrastructure.Services.DetectOperations;

public class DetectedOperationService : IDetectedOperationService
{
    private readonly IDetectedOperationRepository operationRepository;
    private readonly IWellOperationCategoryRepository wellOperationCategoryRepository;
    private readonly IWellService wellService;
    private readonly ITelemetryService telemetryService;
    private readonly IRepositoryWellRelated<OperationValueDto> operationValueRepository;
    private readonly IScheduleRepository scheduleRepository;
    private readonly ITelemetryDataSaubService telemetryDataSaubService;

    private static readonly DetectorAbstract[] detectors = {
        new DetectorDrilling(),
        new DetectorSlipsTime(),
        new DetectorFlashing(),
        new DetectorConditioning(),
    };
    
    public DetectedOperationService(
        IDetectedOperationRepository operationRepository,
        IWellOperationCategoryRepository wellOperationCategoryRepository,
        IWellService wellService,
        ITelemetryService telemetryService,
        IRepositoryWellRelated<OperationValueDto> operationValueRepository,
        IScheduleRepository scheduleRepository,
        ITelemetryDataSaubService telemetryDataSaubService)
    {
        this.operationRepository = operationRepository;
        this.wellOperationCategoryRepository = wellOperationCategoryRepository;
        this.wellService = wellService;
        this.telemetryService = telemetryService;
        this.operationValueRepository = operationValueRepository;
        this.scheduleRepository = scheduleRepository;
        this.telemetryDataSaubService = telemetryDataSaubService;
    }

    public async Task<DetectedOperationListDto> GetAsync(DetectedOperationByWellRequest request, CancellationToken token)
    {
        var dtos = await GetOperationsAsync(request, token);
        if (dtos?.Any() != true)
            return new DetectedOperationListDto();

        var stats = GetOperationsDrillersStat(dtos);
        var result = new DetectedOperationListDto
        {
            Operations = dtos,
            Stats = stats
        };
        return result;
    }

    public async Task<IEnumerable<DetectedOperationWithDrillerDto>> GetOperationsAsync(DetectedOperationByWellRequest request, CancellationToken token)
    {
        var well = await wellService.GetOrDefaultAsync(request.IdWell, token);
        if (well?.IdTelemetry is null)
            return Enumerable.Empty<DetectedOperationWithDrillerDto>();

        var requestByTelemetry = new DetectedOperationByTelemetryRequest(well.IdTelemetry.Value, request);
        var data = await operationRepository.Get(requestByTelemetry, token);

        var operationValues = await operationValueRepository.GetByIdWellAsync(request.IdWell, token);
        var schedules = await scheduleRepository.GetByIdWellAsync(request.IdWell, token);
        var dtos = data.Select(o => Convert(o, operationValues, schedules));
        return dtos;
    }

    public async Task<int> InsertRangeManualAsync(int idEditor, int idWell, IEnumerable<DetectedOperationDto> dtos, CancellationToken token)
    {
        var idTelemetry = await GetIdTelemetryByWell(idWell, token);
        
        foreach (var dto in dtos)
        {
            dto.IdEditor = idEditor;
            dto.IdTelemetry = idTelemetry;
        }

        return await operationRepository.InsertRangeAsync(dtos, token);
    }

    public async Task<int> UpdateRangeManualAsync(int idEditor, int idWell, IEnumerable<DetectedOperationDto> dtos, CancellationToken token)
    {
        var idTelemetry = await GetIdTelemetryByWell(idWell, token);
        
        foreach (var dto in dtos)
        {
            dto.IdEditor = idEditor;
            dto.IdTelemetry = idTelemetry;
        }

        return await operationRepository.UpdateRangeAsync(dtos, token);
    }
    
    private async Task<int> GetIdTelemetryByWell(int idWell, CancellationToken token)
    {
        var well = await wellService.GetOrDefaultAsync(idWell, token) ??
                   throw new ArgumentInvalidException(nameof(idWell), "Well doesn`t exist");

        var idTelemetry = well.IdTelemetry ??
                          throw new ArgumentInvalidException(nameof(idWell), "У скважины отсутствует телеметрия");

        return idTelemetry;
    }

    public async Task<IEnumerable<WellOperationCategoryDto>> GetCategoriesAsync(int? idWell, CancellationToken token)
    {
        if(idWell is null)
        {
            return wellOperationCategoryRepository.Get(false);
        }
        else
        {
            var well = await wellService.GetOrDefaultAsync((int )idWell, token);
            if (well?.IdTelemetry is null)
                return Enumerable.Empty<WellOperationCategoryDto>();

            var request = new DetectedOperationByTelemetryRequest()
            {
                IdTelemetry = well.IdTelemetry.Value
            };

            var operations = await operationRepository.Get(request, token);
            var categories = operations
                .Select(o => o.OperationCategory)
                .Distinct();
            return categories;
        }
    }

    [Obsolete]
    public async Task<IEnumerable<DetectedOperationStatDto>> GetOperationsStatAsync(DetectedOperationByWellRequest request, CancellationToken token)
    {
        var well = await wellService.GetOrDefaultAsync(request.IdWell, token);
        if (well?.IdTelemetry is null || well.Timezone is null)
            return Enumerable.Empty<DetectedOperationStatDto>();

        var requestByTelemetry = new DetectedOperationByTelemetryRequest(well.IdTelemetry.Value, request);

        var operations = await operationRepository.Get(requestByTelemetry, token);

        if (!operations.Any())
            return Enumerable.Empty<DetectedOperationStatDto>();

        var dtos = operations
            .GroupBy(o => (o.IdCategory, o.OperationCategory.Name))
            .OrderBy(g => g.Key)
            .Select(g => new DetectedOperationStatDto
            {
                IdCategory = g.Key.IdCategory,
                Category = g.Key.Name,
                Count = g.Count(),
                MinutesAverage = g.Average(o => o.DurationMinutes),
                MinutesMin = g.Min(o => o.DurationMinutes),
                MinutesMax = g.Max(o => o.DurationMinutes),
                MinutesTotal = g.Sum(o => o.DurationMinutes),
                ValueAverage = g.Average(o => o.Value),
                ValueMax = g.Max(o => o.Value),
                ValueMin = g.Min(o => o.Value),
            });

        return dtos;
    }

    public async Task<(DateTimeOffset LastDate, IEnumerable<DetectedOperationDto> Items)> DetectOperationsAsync(int idTelemetry,
        TelemetryDataRequest request,
        DetectedOperationDto? lastDetectedOperation,
        CancellationToken token)
    {
        const int minOperationLength = 5;
        const int maxDetectorsInterpolationFrameLength = 30;
        const int gap = maxDetectorsInterpolationFrameLength + minOperationLength;

        var telemetries = await telemetryDataSaubService.GetByTelemetryAsync(idTelemetry, request, token);

        var count = telemetries.Count();

        if (count == 0)
            throw new InvalidOperationException("InvalidOperation_EmptyTelemetries");

        var timezone = telemetryService.GetTimezone(idTelemetry);

        if (telemetries.Count() <= gap)
        {
            var lastTelemetry = telemetries.Last();
            var lastDateTelemetry = new DateTimeOffset(lastTelemetry.DateTime, timezone.Offset);
            return (lastDateTelemetry, Enumerable.Empty<DetectedOperationDto>());
        }

        var detectedOperations = new List<DetectedOperationDto>();

        var detectableTelemetries = telemetries
            .Where(t => t.BlockPosition >= 0)
            .Select(t => new DetectableTelemetry
            {
                DateTime = new DateTimeOffset(t.DateTime, timezone.Offset),
                IdUser = t.IdUser,
                Mode = t.Mode,
                WellDepth = t.WellDepth,
                Pressure = t.Pressure,
                HookWeight = t.HookWeight,
                BlockPosition = t.BlockPosition,
                BitDepth = t.BitDepth,
                RotorSpeed = t.RotorSpeed,
                AxialLoad = t.AxialLoad,
            }).ToArray();

        var positionBegin = 0;
        var positionEnd = detectableTelemetries.Length - gap;

        while (positionEnd > positionBegin)
        {
            foreach (var detector in detectors)
            {
                if (!detector.TryDetect(idTelemetry, detectableTelemetries, positionBegin, positionEnd, lastDetectedOperation,
                        out var result))
                    continue;

                detectedOperations.Add(result!.Operation);
                lastDetectedOperation = result.Operation;
                positionBegin = result.TelemetryEnd;
                break;
            }

            var skip = 1;
            
            while (IsChangingTelemetryInterval(detectableTelemetries[positionBegin], detectableTelemetries[positionBegin + skip]))
                skip++;

            positionBegin += skip;
        }

        return (detectableTelemetries[positionBegin].DateTime, detectedOperations);
    }

    public async Task<int> DeleteAsync(DetectedOperationByWellRequest request, CancellationToken token)
    {
        var well = await wellService.GetOrDefaultAsync(request.IdWell, token);
        if (well?.IdTelemetry is null || well.Timezone is null)
            return 0;

        var requestByTelemetry = new DetectedOperationByTelemetryRequest(well.IdTelemetry.Value, request);
        var result = await operationRepository.DeleteAsync(requestByTelemetry, token);
        return result;
    }

    private static bool IsChangingTelemetryInterval(DetectableTelemetry telemetryBegin, DetectableTelemetry telemetryEnd)
    {
        return telemetryBegin.Mode == telemetryEnd.Mode &&
               EqualParameter(telemetryBegin.WellDepth, telemetryEnd.WellDepth, 0.01f) &&
               EqualParameter(telemetryBegin.Pressure, telemetryEnd.Pressure, 0.1f) &&
               EqualParameter(telemetryBegin.HookWeight, telemetryEnd.HookWeight, 0.1f) &&
               EqualParameter(telemetryBegin.BlockPosition, telemetryEnd.BlockPosition, 0.01f) &&
               EqualParameter(telemetryBegin.BitDepth, telemetryEnd.BitDepth, 0.01f) &&
               EqualParameter(telemetryBegin.RotorSpeed, telemetryEnd.RotorSpeed, 0.01f) &&
               EqualParameter(telemetryBegin.AxialLoad, telemetryEnd.AxialLoad, 0.1f);

        bool EqualParameter(float value, float origin, float tolerance) =>
            value <= origin + tolerance && value >= origin - tolerance;
    } 

    private static IEnumerable<DetectedOperationDrillersStatDto> GetOperationsDrillersStat(IEnumerable<DetectedOperationWithDrillerDto> operations)
    {
        var groups = operations.GroupBy(o => o.Driller);

        var stats = new List<DetectedOperationDrillersStatDto>(groups.Count());
        foreach (var group in groups)
        {
            var itemsWithTarget = group.Where(i => i.OperationValue is not null);
            var stat = new DetectedOperationDrillersStatDto
            {
                Driller = group.Key,
                AverageValue = group.Sum(e => e.Value) / group.Count(),
                Count = group.Count(),
            };
            if (itemsWithTarget.Any())
            {
                var itemsOutOfTarget = itemsWithTarget.Where(o => !IsTargetOk(o));
                stat.AverageTargetValue = itemsWithTarget.Average(e => e.OperationValue?.TargetValue);
                stat.Efficiency = 100d * itemsOutOfTarget.Count() / itemsWithTarget.Count();
                stat.Loss = itemsOutOfTarget.Sum(DeltaToTarget);
            }

            stats.Add(stat);
        }
        return stats;
    }

    private static bool IsTargetOk(DetectedOperationWithDrillerDto op)
    {
        return (op.IdCategory) switch
        {
            WellOperationCategory.IdRotor => op.Value > op.OperationValue?.TargetValue,
            WellOperationCategory.IdSlide => op.Value > op.OperationValue?.TargetValue,
            WellOperationCategory.IdSlipsTime => op.Value > op.OperationValue?.TargetValue,
            _ => op.Value > op.OperationValue?.TargetValue,
        };
    }

    private static double DeltaToTarget(DetectedOperationWithDrillerDto op)
    {
        return (op.IdCategory) switch
        {
            WellOperationCategory.IdRotor => 0,
            WellOperationCategory.IdSlide => 0,
            WellOperationCategory.IdSlipsTime => op.Value - op.OperationValue?.TargetValue??0,
            _ => 0,
        };
    }


    private static DetectedOperationWithDrillerDto Convert(DetectedOperationDto operation, IEnumerable<OperationValueDto> operationValues, IEnumerable<ScheduleDto> schedules)
    {
        var dto = operation.Adapt<DetectedOperationWithDrillerDto>();
        dto.OperationValue = operationValues.FirstOrDefault(v => v.IdOperationCategory == dto.IdCategory
              && v.DepthStart <= dto.DepthStart
              && v.DepthEnd > dto.DepthStart);
        
        var dateStart = dto.DateStart.ToUniversalTime();
        var timeStart = new TimeDto(dateStart);
        var driller = schedules.FirstOrDefault(s =>
            s.DrillStart <= dateStart &&
            s.DrillEnd > dateStart && (
            s.ShiftStart > s.ShiftEnd
            ) ^ (s.ShiftStart <= timeStart &&
            s.ShiftEnd > timeStart
            ))
            ?.Driller;
        dto.Driller = driller;

        return dto;
    }
}