using CSRedis;
using Microsoft.IdentityModel.Logging;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using NLog;
using DS.Module.Core;
using Amazon.Runtime.Internal.Util;
using MySqlConnector.Logging;
namespace DS.Module.RedisModule
{
    public class RedisService: IRedisService
    {
        CSRedisClient csRedis;
        private static readonly NLog.Logger Logger = LogManager.GetCurrentClassLogger();
        private readonly string redisConfig;
        public RedisService(IServiceProvider serviceProvider)
        {
            redisConfig = AppSetting.app(new string[] { "RedisInfo", "RedisConfig" });
            csRedis = new CSRedisClient(redisConfig);
            RedisHelper.Initialization(csRedis);
        }

        /// <summary>
        /// 设置长时间存在的值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool SetLongValue(string key, string value)
        {
            try
            {
                RedisHelper.Set(key, value);
                return true;
            }
            catch (Exception ex)
            {
                Logger.Error("RedisDataHelper-SetValue" + ex.Message);
                return false;
            }
        }

        /// <summary>
        /// 设置值，并设置清除时间
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="outSecond"></param>
        /// <returns></returns>
        public bool SetValue(string key, string value, int outSecond)
        {
            try
            {
                RedisHelper.Set(key, value, outSecond);
                return true;
            }
            catch (Exception ex)
            {
                Logger.Error("RedisDataHelper-SetValue" + ex.Message);
                return false;
            }
        }

        /// <summary>
        /// 设置值，存在则覆盖，并沿用之前的清除时间
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool SetValue(string key, string value)
        {
            try
            {
                if (RedisHelper.Exists(key))
                {
                    long time = RedisHelper.Ttl(key);
                    RedisHelper.Set(key, value, Convert.ToInt32(time));
                }
                else
                    RedisHelper.Set(key, value);

                return true;
            }
            catch (Exception ex)
            {
                Logger.Error($"RedisDataHelper-SetValue[{key}-{value}]" + ex.Message);
                return false;
            }
        }

        /// <summary>
        /// 是否存在key
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool Exists(string key)
        {
            try
            {
                return RedisHelper.Exists(key);
            }
            catch (Exception ex)
            {
                Logger.Error("RedisDataHelper-KeyExists" + ex.Message);
                return false;
            }
        }

        /// <summary>
        /// 更新Key，把自动注销时间设置为原来的key的时间,不存在返回false
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool UpdateValue(string key, string value)
        {
            try
            {
                if (RedisHelper.Exists(key))
                {
                    long time = RedisHelper.Ttl(key);
                    RedisHelper.Set(key, value, Convert.ToInt32(time));
                    return true;
                }
                return false;
            }
            catch (Exception ex)
            {
                Logger.Error($"RedisDataHelper-SetValue[{key}-{value}]" + ex.Message);
                return false;
            }
        }


        public string? GetValue(string key)
        {
            try
            {
                return RedisHelper.Get(key);
            }
            catch (Exception ex)
            {
                Logger.Error($"RedisDataHelper-GetValue[{key}]" + ex.Message);
                return null;
            }
        }

        /// <summary>
        /// 获得json序列化后的
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public T? GetValue<T>(string key)
        {
            try
            {
                var data = RedisHelper.Get(key);
                return JsonConvert.DeserializeObject<T>(data);
            }
            catch (Exception ex)
            {
                Logger.Error($"RedisDataHelper-GetValue[{key}]" + ex.Message);
                return default;
            }
        }

        public T? GetEntity<T>(string key)
        {
            try
            {
                var data = RedisHelper.Get(key);
                return JsonConvert.DeserializeObject<T>(data);
            }
            catch (Exception ex)
            {
                Logger.Error($"RedisDataHelper-GetList[{key}]" + ex.Message);
                return default;
            }
        }

        public List<T>? GetLike<T>(string key)
        {
            try
            {
                var dataList = RedisHelper.Keys(key + "*");
                List<T> list = new List<T>();
                foreach (string item in dataList)
                {
                    var data = GetEntity<T>(item);
                    if (data != null)
                    {
                        list.Add(data);
                    }
                }
                return list;
            }
            catch (Exception ex)
            {
                Logger.Error($"RedisDataHelper-GetList[{key}]" + ex.Message);
                return default;
            }
        }

        public void DeleteKey(string key)
        {
            try
            {
                RedisHelper.Del(key);
            }
            catch (Exception ex)
            {
                Logger.Error($"RedisDataHelper-DeleteKey[{key}]" + ex.Message);
            }
        }

        public void DeleteLike(string key)
        {
            try
            {
                var dataList = RedisHelper.Keys(key + "*");

                foreach (string item in dataList)
                {
                    DeleteKey(item);
                }
            }
            catch (Exception ex)
            {
                Logger.Error($"RedisDataHelper-DeleteLike[{key}]" + ex.Message);
            }
        }


        private bool AcquireLock(string lockKey, string lockValue, int lockTimeoutSeconds)
        {
            // 尝试获取锁
            bool lockAcquired = RedisHelper.SetNx(lockKey, lockValue);

            // 如果成功获取锁，设置锁的超时时间
            if (lockAcquired)
            {
                RedisHelper.Expire(lockKey, lockTimeoutSeconds);
            }

            return lockAcquired;
        }

        private void ReleaseLock(string lockKey, string lockValue)
        {
            // 释放锁
            // 使用 Lua 脚本确保只有持有锁的客户端才能释放锁
            string luaScript = @"
            if redis.call('get', KEYS[1]) == ARGV[1] then
                return redis.call('del', KEYS[1])
            else
                return 0
            end";

            RedisHelper.Eval(luaScript, lockKey, new[] { lockValue });
        }
        /// <summary>
        /// 释放Redis链接
        /// </summary>
        public void Dispose()
        {
            csRedis.Dispose();
        }
    }
}