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

using AsbCloudApp.Data;
using AsbCloudApp.Data.DetectedOperation;
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests;
using AsbCloudApp.Services;
using AsbCloudDb;
using AsbCloudDb.Model;
using Mapster;
using Microsoft.EntityFrameworkCore;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace AsbCloudInfrastructure.Services.DetectOperations;

public class DetectedOperationService : IDetectedOperationService
{
    private readonly IDetectedOperationRepository operationRepository;
    private readonly IWellOperationCategoryRepository wellOperationCategoryRepository;
    private readonly IWellService wellService;
    private readonly IRepositoryWellRelated<OperationValueDto> operationValueService;
    private readonly IScheduleRepository scheduleService;

    public DetectedOperationService(
        IDetectedOperationRepository operationRepository,
        IWellOperationCategoryRepository wellOperationCategoryRepository,
        IWellService wellService,
        IRepositoryWellRelated<OperationValueDto> operationValueRepository, 
        IScheduleRepository scheduleRepository)
    {
        this.operationRepository = operationRepository;
        this.wellOperationCategoryRepository = wellOperationCategoryRepository;
        this.wellService = wellService;
        this.operationValueService = operationValueRepository;
        this.scheduleService = scheduleRepository;
    }

    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 operationValueService.GetByIdWellAsync(request.IdWell, token);
        var schedules = await scheduleService.GetByIdWellAsync(request.IdWell, token);
        var dtos = data.Select(o => Convert(o, operationValues, schedules));
        return dtos;
    }

    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;
        }
    }

    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 operationValues = await operationValueService.GetByIdWellAsync(request.IdWell, token);

        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<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.Delete(-1, requestByTelemetry, token);
        return result;
    }

    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;
        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;
    }
}