using AsbCloudApp.Services;
using AsbCloudDb.Model;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Caching.Memory;
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 CrudCacheRepositoryBase<TDto, TEntity> : CacheBase<TDto, TEntity>, ICrudRepository<TDto>
        where TDto : AsbCloudApp.Data.IId
        where TEntity : class, IId
    {
        protected int KeySelector(TEntity entity) => entity.Id;
        protected readonly ICrudRepository<TDto> crudServiceBase;

        public CrudCacheRepositoryBase(IAsbCloudDbContext dbContext, IMemoryCache memoryCache)
        : base(dbContext, memoryCache)
        {
            crudServiceBase = new CrudRepositoryBase<TDto, TEntity>(dbContext);
        }

        public CrudCacheRepositoryBase(IAsbCloudDbContext dbContext, IMemoryCache memoryCache, Func<DbSet<TEntity>, IQueryable<TEntity>> makeQuery)
        : base(dbContext, memoryCache, makeQuery) 
        {
            crudServiceBase = new CrudRepositoryBase<TDto, TEntity>(dbContext, makeQuery);
        }

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

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

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

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

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

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

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