using CacheInterface;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using NewLife.Caching;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

namespace CacheService
{
    public class MemoryCacheService : ICacheService
    {
        public MemoryCacheService(IServiceProvider services)
        {
            Services = services;

            Logger = Services.GetRequiredService<ILogger<RedisCacheService>>();

            Memory = new MemoryCache();

            Logger.LogDebug("加载缓存服务");
        }

        private readonly IServiceProvider Services;

        private readonly ILogger<RedisCacheService> Logger;

        private readonly MemoryCache Memory;

        public Task Set<T>(string key, T value, int ttl = -1)
        {
            Logger.LogDebug($"设置缓存{key}:{JsonSerializer.Serialize(value)}");

            if (value == null)
            {
                Memory.Remove(key);
            }
            else
            {
                Memory.Set(key, value, ttl);
            }

            return Task.CompletedTask;
        }

        public Task BatchSet<T>(Dictionary<string, T> values, int ttl = -1)
        {
            Logger.LogDebug($"批量设置缓存:{JsonSerializer.Serialize(values)}");

            Memory.SetAll(values, ttl);

            return Task.CompletedTask;
        }

        public Task<T> Get<T>(string key)
        {
            Logger.LogDebug($"读取缓存{key}");

            T Result = Memory.Get<T>(key);

            Logger.LogDebug($"{JsonSerializer.Serialize(Result)}");

            return Task.FromResult(Result);
        }

        public Task<Dictionary<string, T>> BatchGet<T>(IEnumerable<string> keys)
        {
            Logger.LogDebug("批量读取缓存");

            Dictionary<string, T> Result = (Dictionary<string, T>)Memory.GetAll<T>(keys);

            Logger.LogDebug($"{JsonSerializer.Serialize(Result)}");

            return Task.FromResult(Result);
        }

        public Task Delete(string key)
        {
            Logger.LogDebug($"删除缓存{key}");

            Memory.Remove(key);

            return Task.CompletedTask;
        }

        public Task BatchDelete(params string[] keys)
        {
            Logger.LogDebug($"批量删除缓存{JsonSerializer.Serialize(keys)}");

            Memory.Remove(keys);

            return Task.CompletedTask;
        }

        public Task<Dictionary<string, T>> Query<T>(string query, int count = 9999)
        {
            Logger.LogDebug($"查询缓存{query}");

            var Keys = Memory.Keys.Where(x => x.Contains(query));

            var Result = new Dictionary<string, T>();

            if (Keys.Count() > 0)
            {
                Result = (Dictionary<string, T>)Memory.GetAll<T>(Keys);
            }

            Logger.LogDebug($"查询缓存{query}:{JsonSerializer.Serialize(Result)}");

            return Task.FromResult(Result);
        }
    }
}