using Mapster;
using Microsoft.EntityFrameworkCore;
using DD.Persistence.Models;
using DD.Persistence.Repositories;
using DD.Persistence.Database.Entity;

namespace DD.Persistence.Repository.Repositories;
public class ParameterRepository : IParameterRepository
{
    private DbContext db;

    public ParameterRepository(DbContext db)
    {
        this.db = db;
    }

    protected virtual IQueryable<ParameterData> GetQueryReadOnly() => db.Set<ParameterData>();

    public async Task<DatesRangeDto> GetDatesRangeAsync(Guid idDiscriminator, CancellationToken token)
    {
        var query = GetQueryReadOnly()
            .Where(e => e.DiscriminatorId == idDiscriminator)
            .GroupBy(e => 1)
            .Select(group => new
            {
                Min = group.Min(e => e.Timestamp),
                Max = group.Max(e => e.Timestamp),
            });
        var values = await query.FirstOrDefaultAsync(token);
        var result = new DatesRangeDto()
        {
            From = values?.Min ?? DateTimeOffset.MinValue,
            To = values?.Max ?? DateTimeOffset.MaxValue
        };

        return result;
    }

    public async Task<IEnumerable<ParameterDto>> GetPart(Guid idDiscriminator, DateTimeOffset dateBegin, int take, CancellationToken token)
    {
        var query = GetQueryReadOnly();
        var universalDate = dateBegin.ToUniversalTime();
        var entities = await query
            .Where(e => e.DiscriminatorId == idDiscriminator && e.Timestamp >= universalDate)
            .Take(take)
            .ToArrayAsync(token);
        var dtos = entities.Select(e => e.Adapt<ParameterDto>());

        return dtos;
    }

    public async Task<IEnumerable<ParameterDto>> GetValuesForGraph(Guid discriminatorId, DateTimeOffset dateFrom, DateTimeOffset dateTo,
        int approxPointsCount, int? ratio, CancellationToken token)
    {
        var query = db.Set<ParameterData>().AsNoTracking();
        var universalDateFrom = dateFrom.ToUniversalTime();
        var universalDateTo = dateTo.ToUniversalTime();

        query = query
            .Where(e => e.DiscriminatorId == discriminatorId)
            .Where(e => e.Timestamp >= universalDateFrom && e.Timestamp <= universalDateTo)
            .OrderBy(e => e.Timestamp);
        if (ratio != null)
        {
            query = query.Where(e => ((int)(e.Timestamp - dateFrom).TotalSeconds) % ratio == 0);
        }

        var entities = await query
            .Take((int)(2.5 * approxPointsCount))
            .ToArrayAsync(token);

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

        return dtos;
    }

    public async Task<int> AddRange(IEnumerable<ParameterDto> dtos, CancellationToken token)
    {
        var entities = dtos.Select(e => e.Adapt<ParameterData>());

        await db.Set<ParameterData>().AddRangeAsync(entities, token);
        var result = await db.SaveChangesAsync(token);

        return result;
    }

    //public async Task<int> AddRange(IEnumerable<ParameterDto> dtos, CancellationToken token)
    //{
    //    int result = 0;

    //    var groups = dtos.GroupBy(e => e.ParameterId / 1000);
    //    foreach (var group in groups)
    //    {
    //        switch (group.Key)
    //        {
    //            case 1:
    //                result += await AddRange<ParameterData1>(dtos, token);
    //                break;
    //            case 2:
    //                result += await AddRange<ParameterData2>(dtos, token);
    //                break;
    //            case 3:
    //                result += await AddRange<ParameterData3>(dtos, token);
    //                break;
    //            case 4:
    //                result += await AddRange<ParameterData4>(dtos, token);
    //                break;
    //            case 5:
    //                result += await AddRange<ParameterData5>(dtos, token);
    //                break;
    //            case 6:
    //                result += await AddRange<ParameterData6>(dtos, token);
    //                break;
    //            case 7:
    //                result += await AddRange<ParameterData7>(dtos, token);
    //                break;
    //            case 8:
    //                result += await AddRange<ParameterData8>(dtos, token);
    //                break;
    //            case 9:
    //                result += await AddRange<ParameterData9>(dtos, token);
    //                break;
    //            case 10:
    //                result += await AddRange<ParameterData10>(dtos, token);
    //                break;
    //            case 11:
    //                result += await AddRange<ParameterData11>(dtos, token);
    //                break;
    //            case 12:
    //                result += await AddRange<ParameterData12>(dtos, token);
    //                break;
    //            case 13:
    //                result += await AddRange<ParameterData13>(dtos, token);
    //                break;
    //            case 14:
    //                result += await AddRange<ParameterData14>(dtos, token);
    //                break;
    //            case 15:
    //                result += await AddRange<ParameterData15>(dtos, token);
    //                break;
    //            case 16:
    //                result += await AddRange<ParameterData16>(dtos, token);
    //                break;
    //            case 17:
    //                result += await AddRange<ParameterData17>(dtos, token);
    //                break;
    //            case 18:
    //                result += await AddRange<ParameterData18>(dtos, token);
    //                break;
    //            case 19:
    //                result += await AddRange<ParameterData19>(dtos, token);
    //                break;
    //            case 20:
    //                result += await AddRange<ParameterData20>(dtos, token);
    //                break;
    //            case 21:
    //                result += await AddRange<ParameterData21>(dtos, token);
    //                break;
    //            case 22:
    //                result += await AddRange<ParameterData22>(dtos, token);
    //                break;
    //            case 23:
    //                result += await AddRange<ParameterData23>(dtos, token);
    //                break;
    //            case 24:
    //                result += await AddRange<ParameterData24>(dtos, token);
    //                break;
    //            case 25:
    //                result += await AddRange<ParameterData25>(dtos, token);
    //                break;
    //        }
    //    }

    //    return result;
    //}
    //private async Task<int> AddRange<T>(IEnumerable<ParameterDto> dtos, CancellationToken token)
    //    where T : ParameterData
    //{
    //    var t = dtos.Where(e => e.Value == null);
    //    var entities = dtos.Select(e => e.Adapt<T>());
    //    var tt = entities.Where(e => e.Value == null);
    //    await db.Set<T>().AddRangeAsync(entities, token);
    //    var result = await db.SaveChangesAsync(token);

    //    return result;
    //}
}