using AsbCloudDb.Model;
using AsbCloudInfrastructure.EfCache;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace AsbCloudInfrastructure.Repository
{
#nullable enable
    /// <summary>
    /// CRUD сервис с кешем в оперативке
    /// </summary>
    /// <typeparam name="TDto"></typeparam>
    /// <typeparam name="TEntity"></typeparam>
    public class CrudCacheServiceBase<TDto, TEntity> : CrudServiceBase<TDto, TEntity>
        where TDto : AsbCloudApp.Data.IId
        where TEntity : class, IId
    {
        protected string CacheTag = typeof(TDto).Name;
        protected TimeSpan CacheOlescence = TimeSpan.FromMinutes(5);
        protected int KeySelector(TEntity entity) => entity.Id;

        public CrudCacheServiceBase(IAsbCloudDbContext dbContext)
        : base(dbContext) { }

        public CrudCacheServiceBase(IAsbCloudDbContext dbContext, ISet<string> includes)
        : base(dbContext, includes) { }

        public CrudCacheServiceBase(IAsbCloudDbContext dbContext, Func<DbSet<TEntity>, IQueryable<TEntity>> makeQuery)
        : base(dbContext, makeQuery) { }

        /// <inheritdoc/>
        public override async Task<int> InsertAsync(TDto newItem, CancellationToken token)
        {
            var result = await base.InsertAsync(newItem, token);
            if (result > 0)
                DropCache();
            return result;
        }

        /// <inheritdoc/>
        public override async Task<int> InsertRangeAsync(IEnumerable<TDto> dtos, CancellationToken token)
        {
            var result = await base.InsertRangeAsync(dtos, token);
            if (result > 0)
                DropCache();
            return result;
        }

        /// <inheritdoc/>
        public override async Task<IEnumerable<TDto>> GetAllAsync(CancellationToken token)
        {
            var cache = await GetCacheAsync(token);
            return cache.Values;
        }

        /// <summary>
        /// Синхронно получить запись по ИД
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public override TDto? GetOrDefault(int id)
        {
            var cache = GetCache();
            return cache.GetValueOrDefault(id);
        }

        /// <inheritdoc/>
        public override async Task<TDto?> GetOrDefaultAsync(int id, CancellationToken token)
        {
            var cache = await GetCacheAsync(token);
            return cache.GetValueOrDefault(id);
        }

        /// <inheritdoc/>
        public override async Task<int> UpdateAsync(TDto dto, CancellationToken token)
        {
            var result = await base.UpdateAsync(dto, token);
            if (result > 0)
                DropCache();
            return result;
        }

        /// <inheritdoc/>
        public override async Task<int> UpdateRangeAsync(IEnumerable<TDto> dtos, CancellationToken token)
        {
            var result = await base.UpdateRangeAsync(dtos, token);
            if (result > 0)
                DropCache();
            return result;
        }

        /// <inheritdoc/>
        public override async Task<int> DeleteAsync(int id, CancellationToken token)
        {
            var result = await base.DeleteAsync(id, token);
            if (result > 0)
                DropCache();
            return result;
        }

        protected virtual Task<Dictionary<int, TDto>> GetCacheAsync(CancellationToken token)
            => GetQuery()
                .FromCacheDictionaryAsync(CacheTag, CacheOlescence, KeySelector, Convert, token);


        protected virtual Dictionary<int, TDto> GetCache()
            => GetQuery()
                .FromCacheDictionary(CacheTag, CacheOlescence, KeySelector, Convert);

        protected virtual void DropCache()
            => dbSet.DropCacheDictionary(CacheTag);
    }
#nullable disable
}