using DD.Persistence.Database.Entity;
using DD.Persistence.Models;
using DD.Persistence.Models.Common;
using DD.Persistence.Repositories;
using DD.Persistence.Repository.Extensions;
using Mapster;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json.Linq;
using System.Linq;
using System.Text.Json;
using System.Text.Json.Nodes;

namespace DD.Persistence.Repository.Repositories;
public class TimestampedValuesRepository : ITimestampedValuesRepository
{
    private readonly DbContext db;
    private readonly IRelatedDataRepository<ValuesIdentityDto> relatedDataRepository;

    public TimestampedValuesRepository(DbContext db, IRelatedDataRepository<ValuesIdentityDto> relatedDataRepository)
    {
        this.db = db;
        this.relatedDataRepository = relatedDataRepository;
    }

    protected virtual IQueryable<TimestampedValues> GetQueryReadOnly() => this.db.Set<TimestampedValues>()
        .Include(e => e.ValuesIdentity);

    public virtual async Task<DatesRangeDto?> GetDatesRange(Guid discriminatorId, CancellationToken token)
    {
        var query = GetQueryReadOnly()
            .GroupBy(entity => entity.DiscriminatorId)
            .Select(group => new
            {
                Min = group.Min(entity => entity.Timestamp),
                Max = group.Max(entity => entity.Timestamp),
            });

        var item = await query.FirstOrDefaultAsync(token);
        if (item is null)
            return null;

        return new DatesRangeDto
        {
            From = item.Min,
            To = item.Max,
        };
    }

    public virtual async Task<IEnumerable<TimestampedValuesDto>> GetGtDate(Guid discriminatorId, DateTimeOffset date, CancellationToken token)
    {
        var query = GetQueryReadOnly().Where(e => e.Timestamp > date);
        var entities = await query.ToArrayAsync(token);

        var dtos = entities.Select(e => e.Adapt<TimestampedValuesDto>());

        return dtos;
    }

    public virtual async Task<int> AddRange(Guid discriminatorId, IEnumerable<TimestampedValuesDto> dtos, CancellationToken token)
    {
        var timestampedValuesEntities = new List<TimestampedValues>();
        foreach (var dto in dtos)
        {
            var values = dto.Values
                .SelectMany(v => JsonSerializer.Deserialize<Dictionary<string, object>>(v.ToString()!)!)
                .ToDictionary();

            var keys = values.Keys.ToArray();
            await CreateValuesIdentityIfNotExist(discriminatorId, keys, token);

            var timestampedValuesEntity = new TimestampedValues()
            {
                DiscriminatorId = discriminatorId,
                Timestamp = dto.Timestamp.ToUniversalTime(),
                Values = values.Values.ToArray()
            };
            timestampedValuesEntities.Add(timestampedValuesEntity);
        }

        await db.Set<TimestampedValues>().AddRangeAsync(timestampedValuesEntities, token);

        var result = await db.SaveChangesAsync(token);

        return result;
    }

    protected async Task<IEnumerable<TimestampedValuesDto>> GetLastAsync(int takeCount, CancellationToken token)
    {
        var query = GetQueryReadOnly()
            .OrderByDescending(e => e.Timestamp)
            .Take(takeCount);

        var entities = await query.ToArrayAsync(token);
        var dtos = entities.Select(e => e.Adapt<TimestampedValuesDto>());

        return dtos;
    }

    protected async Task<TimestampedValuesDto?> GetFirstAsync(CancellationToken token)
    {
        var query = GetQueryReadOnly()
            .OrderBy(e => e.Timestamp);

        var entity = await query.FirstOrDefaultAsync(token);

        if (entity == null)
            return null;

        var dto = entity.Adapt<TimestampedValuesDto>();
        return dto;
    }

    public async virtual Task<IEnumerable<TimestampedValuesDto>> GetResampledData(
        Guid discriminatorId,
        DateTimeOffset dateBegin,
        double intervalSec = 600d,
        int approxPointsCount = 1024,
        CancellationToken token = default)
    {
        var dtos = await GetGtDate(discriminatorId, dateBegin, token);

        var dateEnd = dateBegin.AddSeconds(intervalSec);
        dtos = dtos
            .Where(i => i.Timestamp <= dateEnd);

        var ratio = dtos.Count() / approxPointsCount;
        if (ratio > 1)
            dtos = dtos
                .Where((_, index) => index % ratio == 0);

        return dtos;
    }

    public async Task<IEnumerable<TimestampedValuesDto>> Get(Guid discriminatorId, DateTimeOffset? geTimestamp, IEnumerable<string>? columnNames, int skip, int take, CancellationToken token)
    {
        var dbSet = db.Set<TimestampedValues>();
        var query = dbSet.Where(entity => entity.DiscriminatorId == discriminatorId);

        if (geTimestamp.HasValue)
            query = ApplyGeTimestamp(query, geTimestamp.Value);

        query = query
            .OrderBy(item => item.Timestamp)
            .Skip(skip)
            .Take(take);

        var data = await Materialize(discriminatorId, query, token);

        if (columnNames is not null && columnNames.Any())
            data = ReduceSetColumnsByNames(data, columnNames);

        return data;
    }

    public async Task<IEnumerable<TimestampedValuesDto>> GetLast(Guid discriminatorId, IEnumerable<string>? columnNames, int take, CancellationToken token)
    {
        var dbSet = db.Set<TimestampedValues>();
        var query = dbSet.Where(entity => entity.DiscriminatorId == discriminatorId);

        query = query.OrderByDescending(entity => entity.Timestamp)
            .Take(take)
            .OrderBy(entity => entity.Timestamp);

        var data = await Materialize(discriminatorId, query, token);

        if (columnNames is not null && columnNames.Any())
            data = ReduceSetColumnsByNames(data, columnNames);

        return data;
    }

    public Task<int> Count(Guid discriminatorId, CancellationToken token)
    {
        var dbSet = db.Set<TimestampedValues>();
        var query = dbSet.Where(entity => entity.DiscriminatorId == discriminatorId);
        return query.CountAsync(token);
    }

    private async Task<IEnumerable<TimestampedValuesDto>> Materialize(Guid discriminatorId, IQueryable<TimestampedValues> query, CancellationToken token)
    {
        var dtoQuery = query.Select(entity => new TimestampedValuesDto() 
        { 
            Timestamp = entity.Timestamp, 
            Values = entity.Values 
        });

        var dtos = await dtoQuery.ToArrayAsync(token);
        foreach(var dto in dtos)
        {
            var valuesIdentities = await relatedDataRepository.Get(token);
            var valuesIdentity = valuesIdentities?
                .FirstOrDefault(e => e.DiscriminatorId == discriminatorId);
            if (valuesIdentity == null)
                return []; // ToDo: какая логика должна быть?

            for (var i = 0; i < valuesIdentity.Identity.Count(); i++)
            {
                var key = valuesIdentity.Identity[i];
                var value = dto.Values[i];

                dto.Values[i] = new { key = value }; // ToDo: вывод?
            }
        }

        return dtos;
    }

    private IQueryable<TimestampedValues> ApplyGeTimestamp(IQueryable<TimestampedValues> query, DateTimeOffset geTimestamp)
    {
        var geTimestampUtc = geTimestamp.ToUniversalTime();
        return query.Where(entity => entity.Timestamp >= geTimestampUtc);
    }

    private static IEnumerable<TimestampedValuesDto> ReduceSetColumnsByNames(IEnumerable<TimestampedValuesDto> query, IEnumerable<string> columnNames)
    {
        var newQuery = query;
            //.Select(entity => new TimestampedValuesDto()
            //{
            //    Timestamp = entity.Timestamp,
            //    Values = entity.Values?
            //        .Where(prop => columnNames.Contains(
            //            JsonSerializer.Deserialize<Dictionary<string, object>>(prop.ToString()!)?
            //                .FirstOrDefault().Key
            //        )).ToArray()
            //});
        return newQuery;
    }

    private async Task CreateValuesIdentityIfNotExist(Guid discriminatorId, string[] keys, CancellationToken token)
    {
        var valuesIdentities = await relatedDataRepository.Get(token);
        var valuesIdentity = valuesIdentities?
            .FirstOrDefault(e => e.DiscriminatorId == discriminatorId);

        if (valuesIdentity == null)
        {
            valuesIdentity = new ValuesIdentityDto()
            {
                DiscriminatorId = discriminatorId,
                Identity = keys
            };
            await relatedDataRepository.Add(valuesIdentity, token);

            return;
        }

        if (!valuesIdentity.Identity.SequenceEqual(keys))
        {
            var expectedIdentity = string.Join(", ", valuesIdentity.Identity);
            var actualIdentity = string.Join(", ", keys);
            throw new InvalidOperationException($"Для системы {discriminatorId.ToString()} " +
                $"характерен набор данных: [{expectedIdentity}], однако был передан набор: [{actualIdentity}]");
        }
    }
}