using System.Threading;
using ZiggyCreatures.Caching.Fusion;

namespace Dpz.Core.Service;

public abstract class AbstractCacheService(IFusionCache fusionCache) : ICacheService
{
    protected abstract string CachePrefixKey { get; }

    protected abstract TimeSpan CacheDefaultExpiration { get; }

    public virtual string BuildCacheKey(string method, object? parameters = null) =>
        GenerateCacheKey.Build(CachePrefixKey, method, parameters);

    public virtual async Task<T> GetOrSetCacheAsync<T>(
        string methodName,
        Func<FusionCacheFactoryExecutionContext<T>, CancellationToken, Task<T>> factory,
        object? parameters = null,
        Action<FusionCacheEntryOptions>? setupAction = null
    )
    {
        var cacheKey = BuildCacheKey(methodName, parameters);
        return await fusionCache.GetOrSetAsync<T>(
            cacheKey,
            async (context, cancellationToken) =>
            {
                context.Tags = [CachePrefixKey, CachePrefixKey + methodName];
                return await factory(context, cancellationToken);
            },
            setupAction ?? (options => options.SetDuration(CacheDefaultExpiration))
        );
    }

    public virtual async ValueTask<MaybeValue<T>> TryGetFromCacheAsync<T>(
        string methodName,
        object? parameters = null
    )
    {
        var cacheKey = BuildCacheKey(methodName, parameters);
        return await fusionCache.TryGetAsync<T>(cacheKey);
    }

    public virtual async Task SetCacheAsync<T>(
        string methodName,
        T value,
        object? parameters = null,
        params string[] additionalTags
    )
    {
        var cacheKey = BuildCacheKey(methodName, parameters);
        var tags = new List<string> { CachePrefixKey, CachePrefixKey + methodName };
        tags.AddRange(additionalTags);
        await fusionCache.SetAsync(
            cacheKey,
            value,
            options => options.SetDuration(CacheDefaultExpiration),
            tags.ToArray()
        );
    }

    public virtual async Task RemoveCacheAsync(string methodName, object? parameters = null)
    {
        var cacheKey = BuildCacheKey(methodName, parameters);
        await fusionCache.RemoveAsync(cacheKey);
    }

    public virtual async Task<IPagedList<T>> GetOrSetPagedListAsync<T>(
        string methodName,
        Func<List<string>, Task<IPagedList<T>>> factory,
        object? parameters = null,
        Action<FusionCacheEntryOptions>? setupAction = null,
        params string[] additionalTags
    )
    {
        var cacheKey = BuildCacheKey(methodName, parameters);
        var cache = await fusionCache.TryGetAsync<PagedListWarp<T>>(cacheKey);
        if (cache.HasValue)
        {
            return cache.Value.ToPagedList();
        }

        var tags = new List<string> { CachePrefixKey, CachePrefixKey + methodName };
        if (additionalTags.Length > 0)
        {
            tags.AddRange(additionalTags);
        }
        var pagedList = await factory(tags);

        await fusionCache.SetAsync(
            cacheKey,
            pagedList.ToPagedListWarp(),
            setupAction ?? (options => options.SetDuration(CacheDefaultExpiration)),
            tags
        );
        return pagedList;
    }

    public virtual ValueTask RemoveByMethodAsync(string methodName)
    {
        return fusionCache.RemoveByTagAsync(CachePrefixKey + methodName);
    }

    public ValueTask RemoveByPrefixAsync()
    {
        return fusionCache.RemoveByTagAsync(CachePrefixKey);
    }
}