DD.WellWorkover.Cloud/AsbCloudInfrastructure/Repository/GtrWitsRepository.cs

using AsbCloudApp.Data.GTR;
using AsbCloudApp.Repositories;
using AsbCloudApp.Services;
using AsbCloudDb.Model;
using AsbCloudDb.Model.GTR;
using Mapster;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;

namespace AsbCloudInfrastructure.Repository
{
#nullable enable
    public class GtrWitsRepository : IGtrRepository
    {
        private readonly IAsbCloudDbContext db;
        private readonly ITelemetryService telemetryService;

        public GtrWitsRepository(
            IAsbCloudDbContext db,
            ITelemetryService telemetryService)
        {
            
            this.db = db;
            this.telemetryService = telemetryService;
        }

        public async Task<IEnumerable<WitsRecordDto>> GetAsync(int idWell, DateTime dateBegin = default, double intervalSec = 600, int approxPointsCount = 1024, CancellationToken token = default)
        {
            var telemetry = telemetryService.GetOrDefaultTelemetryByIdWell(idWell);
            if (telemetry is null)
                return Enumerable.Empty<WitsRecordDto>();

            var timezone = telemetryService.GetTimezone(telemetry.Id);

            var filterByDateEnd = dateBegin != default;
            DateTimeOffset dateBeginUtc;
            if (dateBegin == default)
            {
                dateBeginUtc = telemetryService.GetLastTelemetryDate(telemetry.Id)
                    .ToUtcDateTimeOffset(timezone.Hours);
                if (dateBeginUtc != default)
                    dateBeginUtc = dateBeginUtc.AddSeconds(-intervalSec);
            }
            else
            {
                dateBeginUtc = dateBegin.ToUtcDateTimeOffset(timezone.Hours);
            }

            if (dateBeginUtc == default)
                dateBeginUtc = DateTime.UtcNow.AddSeconds(-intervalSec);
            //var cacheData = telemetryDataCache.GetOrDefault(telemetry.Id, dateBeginUtc.ToRemoteDateTime(timezone.Hours), intervalSec, approxPointsCount);
            //if (cacheData is not null)
            //    return cacheData;
            var dateEnd = dateBeginUtc.AddSeconds(intervalSec);

            var queryWitsInt = db.WitsItemInt
                .Where(d => d.IdTelemetry == telemetry.Id
                    && d.DateTime >= dateBeginUtc);
            var queryWitsStr = db.WitsItemString
                .Where(d => d.IdTelemetry == telemetry.Id
                    && d.DateTime >= dateBeginUtc);
            var queryWitsFloat = db.WitsItemFloat
                .Where(d => d.IdTelemetry == telemetry.Id
                    && d.DateTime >= dateBeginUtc);

            var recordAllInt = await GetEntityIntAsync(queryWitsInt, dateEnd, filterByDateEnd, approxPointsCount, token);
            var recordAllFloat = await GetEntityFloatAsync(queryWitsFloat, dateEnd, filterByDateEnd, approxPointsCount, token);
            var recordAllStr = await GetEntityStrAsync(queryWitsStr, dateEnd, filterByDateEnd, approxPointsCount, token);            
            var dtos = new List<WitsRecordDto>();
            if (recordAllInt.Any())
            {
                foreach (var record in recordAllInt)
                {
                    var existingDto = dtos.Where(r => r.Id == record.IdRecord)
                            .Where(r => r.Date.ToUtcDateTimeOffset(timezone.Hours) == record.DateTime)
                            .FirstOrDefault();
                    if (existingDto is null)
                    {
                        var dto = new WitsRecordDto
                        {

                            IdTelemetry = record.IdTelemetry,
                            Id = record.IdRecord,
                            Date = record.DateTime.ToRemoteDateTime(timezone.Hours),
                        };
                        dto.Items.Add(record.IdItem, new JsonValue(record.Value!));
                        dtos.Add(dto);
                    }
                    else
                    {
                        existingDto.Items.Add(record.IdItem, new JsonValue(record.Value!));
                    }
                }
            }
            if (recordAllStr.Any())
            {
                foreach (var record in recordAllStr)
                {
                    var existingDto = dtos.Where(r => r.Id == record.IdRecord)
                        .Where(r => r.Date.ToUtcDateTimeOffset(timezone.Hours) == record.DateTime)
                        .FirstOrDefault();
                    if (existingDto is null)
                    {
                        var dto = new WitsRecordDto
                        {
                            IdTelemetry = record.IdTelemetry,
                            Id = record.IdRecord,
                            Date = record.DateTime.ToRemoteDateTime(timezone.Hours),
                        };
                        dto.Items.Add(record.IdItem, new JsonValue(record.Value!));
                        dtos.Add(dto);
                    }
                    else
                    {
                        existingDto.Items.Add(record.IdItem, new JsonValue(record.Value!));
                    }
                }
            }
            if (recordAllFloat.Any())
            {
                foreach (var record in recordAllFloat)
                {
                    var existingDto = dtos
                        .Where(r => r.Id == record.IdRecord)
                        .Where(r => r.Date.ToUtcDateTimeOffset(timezone.Hours) == record.DateTime)
                        .FirstOrDefault();
                    if (existingDto is null)
                    {
                        var dto = new WitsRecordDto
                        {

                            IdTelemetry = record.IdTelemetry,
                            Id = record.IdRecord,
                            Date = record.DateTime.ToRemoteDateTime(timezone.Hours),
                        };
                        dto.Items.Add(record.IdItem, new JsonValue(record.Value!));
                        dtos.Add(dto);
                    }
                    else
                    {
                        existingDto.Items.Add(record.IdItem, new JsonValue(record.Value!));
                    }
                }
            }
            return dtos;
        }

        public async Task SaveDataAsync(int idTelemetry, WitsRecordDto dto, CancellationToken token)
        {
            if (dto is null)
                return;
            var timezoneHours = telemetryService.GetTimezone(idTelemetry).Hours;
            foreach (var item in dto.Items)
            {                
                var jsonValue = item.Value;       
                if(jsonValue.Value is string valueString)
                {
                    var entity = GetEntity(dto, valueString, item.Key, timezoneHours);
                    db.WitsItemString.Add(entity.Adapt<WitsItemString>());
                }
                if (jsonValue.Value is float valueFloat)
                {
                    var entity = GetEntity(dto, valueFloat, item.Key, timezoneHours);
                    db.WitsItemFloat.Add(entity.Adapt<WitsItemFloat>());
                }
                if (jsonValue.Value is int valueInt)
                {
                    var entity = GetEntity(dto, valueInt, item.Key, timezoneHours);
                    db.WitsItemInt.Add(entity.Adapt<WitsItemInt>());
                }                
            }            
            await db.SaveChangesAsync(token);
        }

        private static async Task<IEnumerable<WitsItemInt>> GetEntityIntAsync(IQueryable<WitsItemInt> query,
            DateTimeOffset dateEnd, bool filterByDateEnd, int approxPointsCount
            , CancellationToken token)
        {
            //if (filterByDateEnd)
            //    query = query.Where(d => d.DateTime <= dateEnd);

            //var fullDataCount = await query.CountAsync(token)
            //    .ConfigureAwait(false);

            //if (fullDataCount == 0)
            //    return Enumerable.Empty<WitsItemInt>();

            //if (fullDataCount > 1.75 * approxPointsCount)
            //{
            //    var m = (int)Math.Round(1d * fullDataCount / approxPointsCount);
            //    if (m > 1)
            //        query = query.Where((d) => (((d.DateTime.DayOfYear * 24 + d.DateTime.Hour) * 60 + d.DateTime.Minute) * 60 + d.DateTime.Second) % m == 0);
            //}

            var entities = await query
                .OrderBy(d => d.DateTime)
                .AsNoTracking()
                .ToListAsync(token)
                .ConfigureAwait(false);
            return entities;
        }

        private static async Task<IEnumerable<WitsItemFloat>> GetEntityFloatAsync(IQueryable<WitsItemFloat> query,
            DateTimeOffset dateEnd, bool filterByDateEnd, int approxPointsCount
            , CancellationToken token)
        {
            //if (filterByDateEnd)
            //    query = query.Where(d => d.DateTime <= dateEnd);

            //var fullDataCount = await query.CountAsync(token)
            //    .ConfigureAwait(false);

            //if (fullDataCount == 0)
            //    return Enumerable.Empty<WitsItemFloat>();

            //if (fullDataCount > 1.75 * approxPointsCount)
            //{
            //    var m = (int)Math.Round(1d * fullDataCount / approxPointsCount);
            //    if (m > 1)
            //        query = query.Where((d) => (((d.DateTime.DayOfYear * 24 + d.DateTime.Hour) * 60 + d.DateTime.Minute) * 60 + d.DateTime.Second) % m == 0);
            //}

            var entities = await query
                .OrderBy(d => d.DateTime)
                .AsNoTracking()
                .ToListAsync(token)
                .ConfigureAwait(false);
            return entities;
        }

        private static async Task<IEnumerable<WitsItemString>> GetEntityStrAsync(IQueryable<WitsItemString> query,
            DateTimeOffset dateEnd, bool filterByDateEnd, int approxPointsCount
            , CancellationToken token)
        {
            //if (filterByDateEnd)
            //    query = query.Where(d => d.DateTime <= dateEnd);

            //var fullDataCount = await query.CountAsync(token)
            //    .ConfigureAwait(false);

            //if (fullDataCount == 0)
            //    return Enumerable.Empty<WitsItemString>();

            //if (fullDataCount > 1.75 * approxPointsCount)
            //{
            //    var m = (int)Math.Round(1d * fullDataCount / approxPointsCount);
            //    if (m > 1)
            //        query = query.Where((d) => (((d.DateTime.DayOfYear * 24 + d.DateTime.Hour) * 60 + d.DateTime.Minute) * 60 + d.DateTime.Second) % m == 0);
            //}

            var entities = await query
                .OrderBy(d => d.DateTime)
                .AsNoTracking()
                .ToListAsync(token)
                .ConfigureAwait(false);
            return entities;
        }
        
        private static WitsItemBase<Tvalue> GetEntity<Tvalue>(WitsRecordDto record, Tvalue value, int idItems, double timezoneHours)
        {
            var entity = new WitsItemBase<Tvalue>
            {
                IdTelemetry = record.IdTelemetry,
                DateTime = record.Date.ToUtcDateTimeOffset(timezoneHours),
                IdRecord = record.Id,
                IdItem = idItems,
                Value = value,
            };
            return entity;
        }
    }
#nullable disable
}