using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using WIDESEAWCS_Core.Caches;
using WIDESEAWCS_RedisService.Connection;
using WIDESEAWCS_RedisService.Options;
using WIDESEAWCS_RedisService.Serialization;

namespace WIDESEAWCS_RedisService.Cache
{
    public class HybridCacheService : ICacheService
    {
        private readonly IMemoryCache _memoryCache;
        private readonly IRedisConnectionManager _connectionManager;
        private readonly IRedisSerializer _serializer;
        private readonly RedisOptions _options;
        private readonly ILogger<HybridCacheService> _logger;
        private bool _disposed;

        private bool RedisAvailable => _connectionManager.IsConnected;

        public HybridCacheService(
            IMemoryCache memoryCache,
            IRedisConnectionManager connectionManager,
            IRedisSerializer serializer,
            IOptions<RedisOptions> options,
            ILogger<HybridCacheService> logger)
        {
            _memoryCache = memoryCache;
            _connectionManager = connectionManager;
            _serializer = serializer;
            _options = options.Value;
            _logger = logger;
        }

        private string BuildKey(string key) => $"{_options.KeyPrefix}{key}";

        public bool Exists(string key)
        {
            if (_memoryCache.TryGetValue(BuildKey(key), out _)) return true;
            if (!RedisAvailable) return false;
            try
            {
                return _connectionManager.GetDatabase().KeyExists(BuildKey(key));
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "Redis Exists失败, key={Key}", key);
                return false;
            }
        }

        public bool Add(string key, string value, int expireSeconds = -1, bool isSliding = false)
        {
            var fullKey = BuildKey(key);
            SetMemoryCache(fullKey, value, expireSeconds, isSliding);
            if (!RedisAvailable)
            {
                _logger.LogWarning("Redis不可用，仅使用内存缓存, key={Key}", key);
                return true;
            }
            try
            {
                var expiry = expireSeconds > 0 ? TimeSpan.FromSeconds(expireSeconds) : (TimeSpan?)null;
                var result = _connectionManager.GetDatabase().StringSet(fullKey, value, expiry);
                _logger.LogInformation("Redis写入成功: key={Key}, result={Result}", fullKey, result);
                return result;
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "Redis Add失败, key={Key}", key);
                return _options.FallbackToMemory;
            }
        }

        public bool AddObject(string key, object value, int expireSeconds = -1, bool isSliding = false)
        {
            return Add(key, _serializer.Serialize(value), expireSeconds, isSliding);
        }

        public void AddOrUpdate(string key, string value, int expireSeconds = -1, bool isSliding = false)
        {
            Add(key, value, expireSeconds, isSliding);
        }

        public void AddOrUpdate(string key, object value, int expireSeconds = -1, bool isSliding = false)
        {
            AddObject(key, value, expireSeconds, isSliding);
        }

        public bool Remove(string key)
        {
            var fullKey = BuildKey(key);
            _memoryCache.Remove(fullKey);
            if (!RedisAvailable) return true;
            try
            {
                return _connectionManager.GetDatabase().KeyDelete(fullKey);
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "Redis Remove失败, key={Key}", key);
                return true;
            }
        }

        public void Remove(IEnumerable<string> keys)
        {
            foreach (var key in keys) Remove(key);
        }

        public T? Get<T>(string key) where T : class
        {
            var fullKey = BuildKey(key);
            if (_memoryCache.TryGetValue(fullKey, out string? cached) && cached != null)
                return _serializer.Deserialize<T>(cached);

            if (!RedisAvailable) return default;
            try
            {
                var value = _connectionManager.GetDatabase().StringGet(fullKey);
                if (value.IsNullOrEmpty) return default;
                var str = value.ToString();
                SetMemoryCache(fullKey, str, 300, false);
                return _serializer.Deserialize<T>(str);
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "Redis Get<T>失败, key={Key}", key);
                return default;
            }
        }

        public object? Get(Type type, string key)
        {
            var fullKey = BuildKey(key);
            if (_memoryCache.TryGetValue(fullKey, out string? cached) && cached != null)
                return _serializer.Deserialize(cached, type);

            if (!RedisAvailable) return null;
            try
            {
                var value = _connectionManager.GetDatabase().StringGet(fullKey);
                if (value.IsNullOrEmpty) return null;
                var str = value.ToString();
                SetMemoryCache(fullKey, str, 300, false);
                return _serializer.Deserialize(str, type);
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "Redis Get(Type)失败, key={Key}", key);
                return null;
            }
        }

        public string? Get(string key)
        {
            var fullKey = BuildKey(key);
            if (_memoryCache.TryGetValue(fullKey, out string? cached))
                return cached;

            if (!RedisAvailable) return null;
            try
            {
                var value = _connectionManager.GetDatabase().StringGet(fullKey);
                if (value.IsNullOrEmpty) return null;
                var str = value.ToString();
                SetMemoryCache(fullKey, str, 300, false);
                return str;
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "Redis Get失败, key={Key}", key);
                return null;
            }
        }

        private void SetMemoryCache(string fullKey, string value, int expireSeconds, bool isSliding)
        {
            var entryOptions = new MemoryCacheEntryOptions();
            if (expireSeconds > 0)
            {
                if (isSliding)
                    entryOptions.SetSlidingExpiration(TimeSpan.FromSeconds(expireSeconds));
                else
                    entryOptions.SetAbsoluteExpiration(TimeSpan.FromSeconds(expireSeconds));
            }
            _memoryCache.Set(fullKey, value, entryOptions);
        }

        #region ConcurrentDictionary风格方法

        public bool TryAdd(string key, string value, int expireSeconds = -1)
        {
            if (Exists(key)) return false;
            return Add(key, value, expireSeconds);
        }

        public bool TryAdd<T>(string key, T value, int expireSeconds = -1) where T : class
        {
            if (Exists(key)) return false;
            return AddObject(key, value, expireSeconds);
        }

        public bool TryGetValue(string key, out string? value)
        {
            value = Get(key);
            return value != null;
        }

        public bool TryGetValue<T>(string key, out T? value) where T : class
        {
            value = Get<T>(key);
            return value != null;
        }

        public bool TryRemove(string key, out string? value)
        {
            value = Get(key);
            if (value == null) return false;
            Remove(key);
            return true;
        }

        public bool TryUpdate(string key, string newValue, int expireSeconds = -1)
        {
            if (!Exists(key)) return false;
            Add(key, newValue, expireSeconds);
            return true;
        }

        public string GetOrAdd(string key, string value, int expireSeconds = -1)
        {
            var existing = Get(key);
            if (existing != null) return existing;
            Add(key, value, expireSeconds);
            return value;
        }

        public string GetOrAdd(string key, Func<string, string> valueFactory, int expireSeconds = -1)
        {
            var existing = Get(key);
            if (existing != null) return existing;
            var value = valueFactory(key);
            Add(key, value, expireSeconds);
            return value;
        }

        public T GetOrAdd<T>(string key, Func<string, T> valueFactory, int expireSeconds = -1) where T : class
        {
            var existing = Get<T>(key);
            if (existing != null) return existing;
            var value = valueFactory(key);
            AddObject(key, value, expireSeconds);
            return value;
        }

        #endregion

        public void Dispose()
        {
            if (_disposed) return;
            _disposed = true;
        }
    }
}