using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using StackExchange.Redis;
using System.Linq;
using WIDESEAWCS_RedisService.Options;

namespace WIDESEAWCS_RedisService.Connection
{
    public class RedisConnectionManager : IRedisConnectionManager
    {
        private readonly RedisOptions _options;
        private readonly ILogger<RedisConnectionManager> _logger;
        private readonly Lazy<ConnectionMultiplexer> _connection;
        private bool _disposed;

        public bool IsConnected
        {
            get
            {
                try
                {
                    // 强制访问Value来触发连接创建
                    var connected = _connection.Value.IsConnected;
                    _logger.LogDebug("IsConnected检查: IsValueCreated={IsValueCreated}, IsConnected={Connected}",
                        _connection.IsValueCreated, connected);
                    return connected;
                }
                catch (Exception ex)
                {
                    _logger.LogWarning(ex, "IsConnected检查失败");
                    return false;
                }
            }
        }

        public RedisConnectionManager(IOptions<RedisOptions> options, ILogger<RedisConnectionManager> logger)
        {
            _options = options.Value;
            _logger = logger;
            _logger.LogInformation("RedisConnectionManager构造开始, ConnectionString={ConnectionString}, Enabled={Enabled}",
                _options.ConnectionString, _options.Enabled);
            _connection = new Lazy<ConnectionMultiplexer>(CreateConnection);
            _logger.LogInformation("RedisConnectionManager构造完成, Lazy已创建");
        }

        private ConnectionMultiplexer CreateConnection()
        {
            try
            {
                _logger.LogInformation("开始创建Redis连接, ConnectionString={ConnectionString}", _options.ConnectionString);
                var configOptions = ConfigurationOptions.Parse(_options.ConnectionString);
                configOptions.AbortOnConnectFail = false;
                configOptions.ConnectRetry = _options.ConnectRetry;
                configOptions.DefaultDatabase = _options.DefaultDatabase;
                _logger.LogInformation("ConfigurationOptions解析完成, EndPoints={EndPoints}", string.Join(",", configOptions.EndPoints.Select(e => e.ToString())));

                if (_options.EnableSentinel && _options.SentinelEndpoints.Count > 0)
                {
                    configOptions.ServiceName = _options.SentinelMasterName;
                    foreach (var endpoint in _options.SentinelEndpoints)
                    {
                        configOptions.EndPoints.Add(endpoint);
                    }
                }

                var connection = ConnectionMultiplexer.Connect(configOptions);
                connection.ConnectionFailed += (_, e) =>
                    _logger.LogError("Redis连接失败: {FailureType}", e.FailureType);
                connection.ConnectionRestored += (_, e) =>
                    _logger.LogInformation("Redis连接恢复: {EndPoint}", e.EndPoint);

                _logger.LogInformation("Redis连接成功: {EndPoints}", string.Join(",", configOptions.EndPoints));
                return connection;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Redis连接创建失败");
                throw;
            }
        }

        public IDatabase GetDatabase(int db = -1)
        {
            return _connection.Value.GetDatabase(db == -1 ? _options.DefaultDatabase : db);
        }

        public IServer GetServer()
        {
            var endpoints = _connection.Value.GetEndPoints();
            return _connection.Value.GetServer(endpoints[0]);
        }

        public ISubscriber GetSubscriber()
        {
            return _connection.Value.GetSubscriber();
        }

        public ConnectionMultiplexer GetConnection()
        {
            return _connection.Value;
        }

        public void Dispose()
        {
            if (_disposed) return;
            _disposed = true;
            if (_connection.IsValueCreated)
                _connection.Value.Dispose();
        }
    }
}