using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using LTEMvcApp.Models;
using Newtonsoft.Json.Linq;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.DependencyInjection;
using System.IO;
using System.Text.Json;

namespace LTEMvcApp.Services
{
    /// <summary>
    /// WebSocket管理器服务 - 管理多个LTE客户端连接
    /// </summary>
    public class WebSocketManagerService
    {
        #region 私有字段

        private readonly ConcurrentDictionary<string, LTEClientWebSocket> _clients;
        private readonly ConcurrentDictionary<string, ClientConfig> _configs;
        private readonly LogParserService _logParser;
        private readonly ILogger<WebSocketManagerService> _logger;
        private readonly IServiceProvider _serviceProvider;
        private ClientConfig _testClientConfig;
        private const int LogCacheSize = 10000; // 服务器最多缓存10000条最新日志
        private readonly ConcurrentQueue<LTELog> _logCache = new ConcurrentQueue<LTELog>();
        private readonly string _configFilePath = "test_client_config.json";

        #endregion

        #region 事件

        /// <summary>
        /// 客户端连接事件
        /// </summary>
        public event EventHandler<LTEClientWebSocket>? ClientConnected;

        /// <summary>
        /// 客户端断开事件
        /// </summary>
        public event EventHandler<LTEClientWebSocket>? ClientDisconnected;

        /// <summary>
        /// 日志接收事件
        /// </summary>
        public event EventHandler<(string clientName, List<LTELog> logs)>? LogsReceived;

        /// <summary>
        /// 状态变化事件
        /// </summary>
        public event EventHandler<(string clientName, ClientState state)>? StateChanged;

        #endregion

        #region 构造函数

        /// <summary>
        /// 构造函数
        /// </summary>
        public WebSocketManagerService(ILogger<WebSocketManagerService> logger, LogParserService logParser, IServiceProvider serviceProvider)
        {
            _clients = new ConcurrentDictionary<string, LTEClientWebSocket>();
            _configs = new ConcurrentDictionary<string, ClientConfig>();
            _logParser = logParser;
            _logger = logger;
            _serviceProvider = serviceProvider;
            
            LoadTestClientConfig();
            
            _logger.LogInformation("WebSocketManagerService 初始化");
        }

        /// <summary>
        /// 加载测试客户端配置
        /// </summary>
        private void LoadTestClientConfig()
        {
            try
            {
                if (File.Exists(_configFilePath))
                {
                    var json = File.ReadAllText(_configFilePath);
                    _testClientConfig = JsonSerializer.Deserialize<ClientConfig>(json, new JsonSerializerOptions { PropertyNameCaseInsensitive = true })!;
                    _logger.LogInformation("成功从 {FilePath} 加载测试客户端配置。", _configFilePath);
                }
                else
                {
                    _logger.LogWarning("配置文件 {FilePath} 未找到，将创建并使用默认配置。", _configFilePath);
                    _testClientConfig = GetDefaultTestConfig();
                    SaveTestClientConfig();
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "加载或创建测试客户端配置文件时出错。将使用默认配置。");
                _testClientConfig = GetDefaultTestConfig();
            }
        }

        /// <summary>
        /// 保存测试客户端配置到文件
        /// </summary>
        private void SaveTestClientConfig()
        {
            try
            {
                var options = new JsonSerializerOptions { WriteIndented = true, PropertyNamingPolicy = JsonNamingPolicy.CamelCase };
                var json = JsonSerializer.Serialize(_testClientConfig, options);
                File.WriteAllText(_configFilePath, json);
                _logger.LogInformation("测试客户端配置已成功保存到 {FilePath}。", _configFilePath);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "保存测试客户端配置文件失败。");
            }
        }
        
        private ClientConfig GetDefaultTestConfig()
        {
            return new ClientConfig
            {
                Name = "TestClient",
                Enabled = true,
                Address = "192.168.13.12:9001",
                Ssl = false,
                ReconnectDelay = 15000,
                Password = "test123",
                Logs = new Dictionary<string, object>
                {
                    ["layers"] = new Dictionary<string, object>
                    {
                        ["PHY"] = new LogLayerConfig { Level = "info", Filter = "warn", MaxSize = 1000, Payload = true },
                        ["MAC"] = new LogLayerConfig { Level = "info", Filter = "warn", MaxSize = 1000, Payload = true },
                        ["RLC"] = new LogLayerConfig { Level = "info", Filter = "warn", MaxSize = 1000, Payload = false },
                        ["PDCP"] = new LogLayerConfig { Level = "warn", Filter = "warn", MaxSize = 1000, Payload = false },
                        ["RRC"] = new LogLayerConfig { Level = "debug", Filter = "warn", MaxSize = 1000, Payload = true },
                        ["NAS"] = new LogLayerConfig { Level = "debug", Filter = "warn", MaxSize = 1000, Payload = true },
                        ["S1AP"] = new LogLayerConfig { Level = "debug", Filter = "warn", MaxSize = 1000, Payload = false },
                        ["NGAP"] = new LogLayerConfig { Level = "debug", Filter = "warn", MaxSize = 1000, Payload = false },
                        ["GTPU"] = new LogLayerConfig { Level = "info", Filter = "warn", MaxSize = 1000, Payload = false },
                        ["X2AP"] = new LogLayerConfig { Level = "debug", Filter = "warn", MaxSize = 1000, Payload = false },
                        ["XnAP"] = new LogLayerConfig { Level = "info", Filter = "warn", MaxSize = 1000, Payload = false },
                        ["M2AP"] = new LogLayerConfig { Level = "info", Filter = "warn", MaxSize = 1000, Payload = false }
                    },
                    ["signal"] = true,
                    ["cch"] = true
                }
            };
        }

        #endregion

        #region 公共方法

        /// <summary>
        /// 添加客户端配置
        /// </summary>
        /// <param name="config">客户端配置</param>
        /// <returns>是否成功添加</returns>
        public bool AddClientConfig(ClientConfig config)
        {
            if (string.IsNullOrEmpty(config.Name))
            {
                _logger.LogWarning("尝试添加空名称客户端配置");
                return false;
            }
            _logger.LogInformation($"添加客户端配置: {config.Name}");
            _configs[config.Name] = config;
            return true;
        }

        /// <summary>
        /// 移除客户端配置
        /// </summary>
        /// <param name="clientName">客户端名称</param>
        /// <returns>是否成功移除</returns>
        public bool RemoveClientConfig(string clientName)
        {
            _logger.LogInformation($"移除客户端配置: {clientName}");
            if (_configs.TryRemove(clientName, out _))
            {
                // 如果客户端正在运行，停止它
                if (_clients.TryGetValue(clientName, out var client))
                {
                    client.Stop();
                    _clients.TryRemove(clientName, out _);
                }
                return true;
            }
            return false;
        }

        /// <summary>
        /// 启动客户端
        /// </summary>
        /// <param name="clientName">客户端名称</param>
        /// <returns>是否成功启动</returns>
        public bool StartClient(string clientName)
        {
            _logger.LogInformation($"启动客户端: {clientName}");
            
            ClientConfig config;
            if (clientName == _testClientConfig.Name)
            {
                // 使用测试客户端配置
                config = _testClientConfig;
                _logger.LogInformation($"使用测试客户端配置: {config.Name}");
            }
            else if (!_configs.TryGetValue(clientName, out config))
            {
                _logger.LogWarning($"客户端配置不存在: {clientName}");
                return false;
            }

            // 如果客户端已存在，先停止
            if (_clients.TryGetValue(clientName, out var existingClient))
            {
                existingClient.Stop();
                _clients.TryRemove(clientName, out _);
            }

            // 通过依赖注入获取ILogger<LTEClientWebSocket>
            var logger = _serviceProvider.GetService(typeof(ILogger<LTEClientWebSocket>)) as ILogger<LTEClientWebSocket>;
            var client = new LTEClientWebSocket(config, logger!);
            
            // 订阅事件
            client.ConnectionOpened += (sender, e) => OnClientConnected(client);
            client.ConnectionClosed += (sender, e) => OnClientDisconnected(client);
            client.LogsReceived += (sender, logs) => OnLogsReceived(clientName, logs);
            client.StateChanged += (sender, state) => OnStateChanged(clientName, state);

            // 启动客户端
            client.Start();
            
            // 添加到客户端列表
            _clients[clientName] = client;
            
            return true;
        }

        /// <summary>
        /// 停止客户端
        /// </summary>
        /// <param name="clientName">客户端名称</param>
        /// <returns>是否成功停止</returns>
        public bool StopClient(string clientName)
        {
            _logger.LogInformation($"停止客户端: {clientName}");
            if (_clients.TryGetValue(clientName, out var client))
            {
                client.Stop();
                _clients.TryRemove(clientName, out _);
                return true;
            }
            return false;
        }

        /// <summary>
        /// 获取客户端状态
        /// </summary>
        /// <param name="clientName">客户端名称</param>
        /// <returns>客户端状态</returns>
        public ClientState? GetClientState(string clientName)
        {
            if (_clients.TryGetValue(clientName, out var client))
            {
                return client.State;
            }
            return null;
        }

        /// <summary>
        /// 获取所有客户端状态
        /// </summary>
        /// <returns>客户端状态字典</returns>
        public Dictionary<string, ClientState> GetAllClientStates()
        {
            return _clients.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.State);
        }

        /// <summary>
        /// 获取客户端配置
        /// </summary>
        /// <param name="clientName">客户端名称</param>
        /// <returns>客户端配置</returns>
        public ClientConfig? GetClientConfig(string clientName)
        {
            _configs.TryGetValue(clientName, out var config);
            return config;
        }

        /// <summary>
        /// 获取所有客户端配置
        /// </summary>
        /// <returns>客户端配置列表</returns>
        public List<ClientConfig> GetAllClientConfigs()
        {
            return _configs.Values.ToList();
        }

        /// <summary>
        /// 获取客户端日志
        /// </summary>
        /// <param name="clientName">客户端名称</param>
        /// <returns>客户端日志列表</returns>
        public List<LTELog>? GetClientLogs(string clientName)
        {
            if (_clients.TryGetValue(clientName, out var client))
            {
                return client.Client.Logs;
            }
            return null;
        }

        /// <summary>
        /// 重置客户端日志
        /// </summary>
        /// <param name="clientName">客户端名称</param>
        /// <returns>是否成功重置</returns>
        public bool ResetClientLogs(string clientName)
        {
            if (_clients.TryGetValue(clientName, out var client))
            {
                client.ResetLogs();
                return true;
            }
            return false;
        }

        /// <summary>
        /// 设置客户端日志配置
        /// </summary>
        /// <param name="clientName">客户端名称</param>
        /// <param name="logsConfig">日志配置</param>
        /// <param name="save">是否保存</param>
        /// <returns>是否成功设置</returns>
        public bool SetClientLogsConfig(string clientName, Dictionary<string, object> logsConfig, bool save = false)
        {
            if (_clients.TryGetValue(clientName, out var client))
            {
                client.SetLogsConfig(logsConfig, save);
                return true;
            }
            return false;
        }

        /// <summary>
        /// 播放/暂停客户端
        /// </summary>
        /// <param name="clientName">客户端名称</param>
        /// <returns>是否成功操作</returns>
        public bool PlayPauseClient(string clientName)
        {
            if (_clients.TryGetValue(clientName, out var client))
            {
                client.PlayPause();
                return true;
            }
            return false;
        }

        /// <summary>
        /// 发送消息到客户端
        /// </summary>
        /// <param name="clientName">客户端名称</param>
        /// <param name="message">消息</param>
        /// <param name="callback">回调</param>
        /// <returns>消息ID</returns>
        public int SendMessageToClient(string clientName, JObject message, Action<JObject>? callback = null)
        {
            if (_clients.TryGetValue(clientName, out var client))
            {
                return client.SendMessage(message, callback);
            }
            return -1;
        }

        /// <summary>
        /// 获取连接统计信息
        /// </summary>
        /// <returns>连接统计信息</returns>
        public ConnectionStatistics GetConnectionStatistics()
        {
            var stats = new ConnectionStatistics
            {
                TotalClients = _clients.Count,
                ConnectedClients = _clients.Values.Count(c => c.IsConnected),
                DisconnectedClients = _clients.Values.Count(c => !c.IsConnected),
                TotalLogs = _clients.Values.Sum(c => c.Client.LogCount),
                ClientStates = GetAllClientStates()
            };

            return stats;
        }

        /// <summary>
        /// 停止所有客户端
        /// </summary>
        public void StopAllClients()
        {
            foreach (var client in _clients.Values)
            {
                client.Stop();
            }
            _clients.Clear();
        }

        /// <summary>
        /// 启动所有已配置的客户端
        /// </summary>
        public void StartAllConfiguredClients()
        {
            foreach (var config in _configs.Values)
            {
                if (config.Enabled)
                {
                    StartClient(config.Name);
                }
            }
        }

        /// <summary>
        /// 获取客户端实例
        /// </summary>
        /// <param name="clientName">客户端名称</param>
        /// <returns>客户端实例</returns>
        public LTEClientWebSocket? GetClientInstance(string clientName)
        {
            _clients.TryGetValue(clientName, out var client);
            return client;
        }

        /// <summary>
        /// 获取测试客户端配置
        /// </summary>
        /// <returns>测试客户端配置</returns>
        public ClientConfig GetTestClientConfig()
        {
            return _testClientConfig;
        }

        /// <summary>
        /// 设置测试客户端配置
        /// </summary>
        /// <param name="config">测试客户端配置</param>
        /// <returns>是否成功设置</returns>
        public bool SetTestClientConfig(ClientConfig config)
        {
            if (string.IsNullOrEmpty(config.Name))
            {
                _logger.LogWarning("尝试设置空名称的测试客户端配置");
                return false;
            }
            
            _logger.LogInformation($"更新测试客户端配置: {config.Name}");
            _testClientConfig = config;
            SaveTestClientConfig();
            return true;
        }

        /// <summary>
        /// 启动测试客户端
        /// </summary>
        /// <returns>是否成功启动</returns>
        public bool StartTestClient()
        {
            _logger.LogInformation("启动测试客户端");
            return StartClient(_testClientConfig.Name);
        }

        /// <summary>
        /// 停止测试客户端
        /// </summary>
        /// <returns>是否成功停止</returns>
        public bool StopTestClient()
        {
            _logger.LogInformation("停止测试客户端");
            return StopClient(_testClientConfig.Name);
        }

        /// <summary>
        /// 获取测试客户端实例
        /// </summary>
        /// <returns>测试客户端的WebSocket实例</returns>
        public LTEClientWebSocket? GetTestClient()
        {
            return GetClientInstance(_testClientConfig.Name);
        }

        /// <summary>
        /// 获取当前缓存的日志
        /// </summary>
        public IEnumerable<LTELog> GetLogCache() => _logCache;

        /// <summary>
        /// 获取当前缓存的日志总数
        /// </summary>
        public int GetLogCacheCount() => _logCache.Count;

        /// <summary>
        /// 清空日志缓存
        /// </summary>
        public void ClearLogCache()
        {
            _logger.LogInformation("清空日志缓存");
            while (_logCache.TryDequeue(out _))
            {
                // 清空所有日志
            }
        }

        /// <summary>
        /// 重置日志缓存（清空并重新初始化）
        /// </summary>
        public void ResetLogCache()
        {
            _logger.LogInformation("重置日志缓存");
            ClearLogCache();
            // 可以在这里添加其他重置逻辑
        }

        /// <summary>
        /// 手动添加日志到缓存
        /// </summary>
        /// <param name="log">日志对象</param>
        public void AddLogToCache(LTELog log)
        {
            if (log != null)
            {
                _logCache.Enqueue(log);
                _logger.LogInformation("手动添加日志到缓存: {Layer} - {Message}", log.Layer, log.Message);
                
                // 维持缓存大小
                while (_logCache.Count > LogCacheSize)
                {
                    _logCache.TryDequeue(out _);
                }
            }
        }

        /// <summary>
        /// 手动添加多个日志到缓存
        /// </summary>
        /// <param name="logs">日志列表</param>
        public void AddLogsToCache(List<LTELog> logs)
        {
            if (logs != null && logs.Any())
            {
                foreach (var log in logs)
                {
                    _logCache.Enqueue(log);
                }
                
                _logger.LogInformation("手动添加 {Count} 条日志到缓存", logs.Count);
                
                // 维持缓存大小
                while (_logCache.Count > LogCacheSize)
                {
                    _logCache.TryDequeue(out _);
                }
            }
        }

        #endregion

        #region 私有方法

        /// <summary>
        /// 客户端连接事件处理
        /// </summary>
        private void OnClientConnected(LTEClientWebSocket client)
        {
            _logger.LogInformation($"客户端已连接: {client.Client.Config.Name}");
            ClientConnected?.Invoke(this, client);
        }

        /// <summary>
        /// 客户端断开事件处理
        /// </summary>
        private void OnClientDisconnected(LTEClientWebSocket client)
        {
            _logger.LogWarning($"客户端已断开: {client.Client.Config.Name}");
            ClientDisconnected?.Invoke(this, client);
        }

        /// <summary>
        /// 日志接收事件处理
        /// </summary>
        private void OnLogsReceived(string clientName, List<LTELog> logs)
        {
            _logger.LogInformation($"客户端 {clientName} 收到日志: {logs.Count} 条");
            
            // 将新日志存入中央缓存
            foreach (var log in logs)
            {
                _logCache.Enqueue(log);
            }

            // 维持缓存大小
            while (_logCache.Count > LogCacheSize)
            {
                _logCache.TryDequeue(out _);
            }

            LogsReceived?.Invoke(this, (clientName, logs));
        }

        /// <summary>
        /// 状态变化事件处理
        /// </summary>
        private void OnStateChanged(string clientName, ClientState state)
        {
            _logger.LogInformation($"客户端 {clientName} 状态变更: {state}");
            StateChanged?.Invoke(this, (clientName, state));
        }

        #endregion
    }

    /// <summary>
    /// 连接统计信息
    /// </summary>
    public class ConnectionStatistics
    {
        /// <summary>
        /// 总客户端数
        /// </summary>
        public int TotalClients { get; set; }

        /// <summary>
        /// 已连接客户端数
        /// </summary>
        public int ConnectedClients { get; set; }

        /// <summary>
        /// 未连接客户端数
        /// </summary>
        public int DisconnectedClients { get; set; }

        /// <summary>
        /// 总日志数
        /// </summary>
        public int TotalLogs { get; set; }

        /// <summary>
        /// 客户端状态字典
        /// </summary>
        public Dictionary<string, ClientState> ClientStates { get; set; } = new();
    }
}