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

namespace 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(int 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(int 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 Task<ParameterDto> GetValuesForGraph(DateTimeOffset dateFrom, DateTimeOffset dateTo)
	{
		throw new NotImplementedException();
	}

	public async Task<int> InsertRange(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;
	}
}