using AyCode.Interfaces.Entities;
using AyCode.Interfaces.TimeStampInfo;
using Mango.Nop.Core.Interfaces;
using Mango.Nop.Core.Loggers;
using Nop.Core;
using Nop.Core.Caching;
using Nop.Core.Configuration;
using Nop.Core.Domain.Catalog;
using Nop.Core.Domain.Common;
using Nop.Core.Events;
using Nop.Data;
using System.Linq.Expressions;

namespace Mango.Nop.Core.Repositories;

public abstract class MgDbTableBase<TEntity>(IEventPublisher eventPublisher, INopDataProvider dataProvider, IShortTermCacheManager shortTermCacheManager, IStaticCacheManager staticCacheManager, AppSettings appSettings)
    : EntityRepository<TEntity>(eventPublisher, dataProvider, shortTermCacheManager, staticCacheManager, appSettings), IMgDbTableBase where TEntity : BaseEntity
{
    //protected ILogger Logger = logger;
    protected IEventPublisher EventPublisher = eventPublisher;
    protected INopDataProvider DataProvider = dataProvider;
    protected IShortTermCacheManager ShortTermCacheManager = shortTermCacheManager;

    public virtual IQueryable<TEntity> GetAll() => Table;

    #region SetTimeStampInfos

    private static void SetTimeStampCreated(TEntity entity)
    {
        if (typeof(TEntity).GetInterface(nameof(ITimeStampCreated)) != null)
        {
            (entity as ITimeStampCreated)!.Created = DateTime.UtcNow;
        }
    }

    private static void SetTimeStampModified(TEntity entity)
    {
        if (typeof(TEntity).GetInterface(nameof(ITimeStampModified)) != null)
        {
            (entity as ITimeStampModified)!.Modified = DateTime.UtcNow;
        }
    }

    #endregion SetTimeStampInfos

    //TODO: Transaction-be tenni az event-eket! - J.

    #region OnCrudEvents

    private void OnInsert(IList<TEntity> entities)
    {
        foreach (var entity in entities) OnInsert(entity);
    }

    protected virtual void OnInsert(TEntity entity)
    {
        SetTimeStampCreated(entity);
        SetTimeStampModified(entity);

        //_staticCacheManager.RemoveByPrefix(MgDbContextBase.AUCTION_PATTERN_KEY);
    }

    private void OnUpdate(IList<TEntity> entities)
    {
        foreach (var entity in entities) OnUpdate(entity);
    }

    protected virtual void OnUpdate(TEntity entity)
    {
        SetTimeStampModified(entity);

        _staticCacheManager.ClearAsync().GetAwaiter().GetResult(); //TODO: EZ MI??? - J.
        //_staticCacheManager.RemoveByPrefix(MgDbContextBase.AUCTION_PATTERN_KEY);
    }

    private void OnDelete(IList<TEntity> entities)
    {
        foreach (var entity in entities) OnDelete(entity);
    }

    protected virtual void OnDelete(TEntity entity)
    {
        if (typeof(TEntity).GetInterface(nameof(ISoftDeletedEntity)) != null)
        {
            SetTimeStampModified(entity);
        }

        //_staticCacheManager.RemoveByPrefix(MgDbContextBase.AUCTION_PATTERN_KEY);
    }

    #endregion OnCrudEvents

    #region Insert

    public override void Insert(TEntity entity, bool publishEvent = true)
    {
        OnInsert(entity);
        base.Insert(entity, publishEvent);
    }

    public override void Insert(IList<TEntity> entities, bool publishEvent = true)
    {
        OnInsert(entities);
        base.Insert(entities, publishEvent);
    }

    public override Task InsertAsync(TEntity entity, bool publishEvent = true)
    {
        OnInsert(entity);
        return base.InsertAsync(entity, publishEvent);
    }

    public override Task InsertAsync(IList<TEntity> entities, bool publishEvent = true)
    {
        OnInsert(entities);
        return base.InsertAsync(entities, publishEvent);
    }

    #endregion Insert

    #region Update

    public override void Update(TEntity entity, bool publishEvent = true)
    {
        OnUpdate(entity);
        base.Update(entity, publishEvent);
    }

    public override void Update(IList<TEntity> entities, bool publishEvent = true)
    {
        OnUpdate(entities);
        base.Update(entities, publishEvent);
    }

    public override Task UpdateAsync(TEntity entity, bool publishEvent = true)
    {
        OnUpdate(entity);
        return base.UpdateAsync(entity, publishEvent);
    }

    public override Task UpdateAsync(IList<TEntity> entities, bool publishEvent = true)
    {
        OnUpdate(entities);
        return base.UpdateAsync(entities, publishEvent);
    }

    #endregion Update

    #region Delete

    protected override IQueryable<TEntity> AddDeletedFilter(IQueryable<TEntity> query, in bool includeDeleted)
    {
        //EZ NEM DELETE METHOD! A GET-EKNÉL HASZNÁLJA A ISFOTDELETE FILTER-HEZ! - J.
        //foreach (var entity in query) OnDelete(entity);

        return base.AddDeletedFilter(query, in includeDeleted);
    }

    public virtual async Task DeleteAsync(int entityId, bool publishEvent = true)
    {
        var entity = await GetByIdAsync(entityId);
        await DeleteAsync(entity, publishEvent);
    }

    public override Task DeleteAsync(TEntity entity, bool publishEvent = true)
    {
        OnDelete(entity);
        return base.DeleteAsync(entity, publishEvent);
    }

    public override Task DeleteAsync(IList<TEntity> entities, bool publishEvent = true)
    {
        OnDelete(entities);
        return base.DeleteAsync(entities, publishEvent);
    }

    /// <summary>
    /// It does not call the PublishEvent() and OnDelete() functions!
    /// </summary>
    /// <param name="predicate"></param>
    /// <returns></returns>
    public override Task<int> DeleteAsync(Expression<Func<TEntity, bool>> predicate)
    {
        return base.DeleteAsync(predicate);
    }

    public virtual async Task DeleteAsync(Expression<Func<TEntity, bool>> predicate, bool publishEvent)
    {
        if (publishEvent)
        {
            var deletingEntities = await Table.Where(predicate).ToListAsync();
            await base.DeleteAsync(deletingEntities, true);

            return;
        }

        await DeleteAsync(predicate);
    }

    public override void Delete(TEntity entity, bool publishEvent = true)
    {
        OnDelete(entity);
        base.Delete(entity, publishEvent);
    }

    public override void Delete(IList<TEntity> entities, bool publishEvent = true)
    {
        OnDelete(entities);
        base.Delete(entities, publishEvent);
    }

    public override int Delete(Expression<Func<TEntity, bool>> predicate)
    {
        //TODO:ide mit kéne?! - J.
        return base.Delete(predicate);
    }

    #endregion Delete
}