using EgwCoreLib.Utils;

namespace EgwCoreLib.Lux.Data.Repository.Stats
{
    public class StatsDetailRepository : BaseRepository, IStatsDetailRepository
    {
        #region Public Constructors

        public StatsDetailRepository(IDbContextFactory<DataLayerContext> ctxFactory) : base(ctxFactory)
        {
        }

        #endregion Public Constructors

        #region Internal Methods

        /// <inheritdoc />
        public async Task<List<StatsDetailModel>> GetFiltAsync(DateTime dtStart, DateTime dtEnd, string sEnvir = "", string sType = "")
        {
            await using var dbCtx = await CreateContextAsync();
            List<StatsDetailModel> answ = new List<StatsDetailModel>();

            // recupero ed ordino per data-ora
            var query = dbCtx.DbSetStatsDet
             .Where(x => x.Hour >= dtStart && x.Hour <= dtEnd);

            if (!string.IsNullOrEmpty(sEnvir))
                query = query.Where(x => x.Environment == sEnvir);

            if (!string.IsNullOrEmpty(sType))
                query = query.Where(x => x.Type == sType);

            answ = await query
                         .AsNoTracking()
                         .OrderBy(x => x.Hour)
                         .ThenBy(x => x.Environment)
                         .ThenBy(x => x.Type)
                         .ToListAsync();

            return answ;
        }

        /// <inheritdoc />
        public async Task<DtUtils.Periodo> GetRangeAsync(string sEnvir, string sType)
        {
            await using var dbCtx = await CreateContextAsync();
            DtUtils.Periodo answ = new DtUtils.Periodo(DtUtils.PeriodSet.Today);

            var query = dbCtx.DbSetStatsDet.AsQueryable();

            if (!string.IsNullOrEmpty(sEnvir))
                query = query.Where(x => x.Environment == sEnvir);

            if (!string.IsNullOrEmpty(sType))
                query = query.Where(x => x.Type == sType);

            var minHour = await query.MinAsync(x => x.Hour);
            var maxHour = await query.MaxAsync(x => x.Hour);
            answ.Inizio = minHour;
            answ.Fine = maxHour;
            return answ;
        }

        /// <inheritdoc />
        public async Task<int> UpsertManyAsync(List<StatsDetailModel> listRecords, bool removeOld)
        {
            int answ = 0;
            await using var dbCtx = await CreateContextAsync();
            await using var tx = await dbCtx.Database.BeginTransactionAsync();
            try
            {
                // in primis se richiesto calcolo range periodo e svuoto...
                if (removeOld)
                {
                    var firstRec = listRecords.OrderBy(x => x.Hour).FirstOrDefault();
                    var lastRec = listRecords.OrderByDescending(x => x.Hour).FirstOrDefault();

                    if (firstRec != null && lastRec != null)
                    {
                        DateTime startDate = firstRec.Hour;
                        DateTime endDate = lastRec.Hour;
                        // uso direttamente ExecuteDelete
                        await dbCtx
                                .DbSetStatsDet
                                .Where(x => x.Hour >= startDate && x.Hour <= endDate)
                                .ExecuteDeleteAsync();
                    }
                }

                // ora preparo inserimento massivo
                await dbCtx
                        .DbSetStatsDet
                        .AddRangeAsync(listRecords);

                // salvo!
                answ = await dbCtx.SaveChangesAsync();
                // commit transazione
                await tx.CommitAsync();

                // libero memoria del changeTracker
                dbCtx.ChangeTracker.Clear();
                return answ;
            }
            catch
            {
                await tx.RollbackAsync();
                throw;
            }
        }

        #endregion Internal Methods
    }
}