using System;
using System.Collections.Generic;
using System.Collections.Concurrent;
using Newtonsoft.Json.Linq;

namespace LTEMvcApp.Models
{
    /// <summary>
    /// 统计数据模型
    /// </summary>
    public class StatisticsData
    {
        /// <summary>
        /// 消息类型
        /// </summary>
        public string Message { get; set; } = "";

        /// <summary>
        /// 实例ID
        /// </summary>
        public string InstanceId { get; set; } = "";

        /// <summary>
        /// CPU信息
        /// </summary>
        public CpuInfo Cpu { get; set; } = new CpuInfo();

        /// <summary>
        /// 小区信息
        /// </summary>
        public Dictionary<string, CellInfo> Cells { get; set; } = new Dictionary<string, CellInfo>();

        /// <summary>
        /// RF端口信息
        /// </summary>
        public Dictionary<string, RfPortInfo> RfPorts { get; set; } = new Dictionary<string, RfPortInfo>();

        /// <summary>
        /// 计数器信息
        /// </summary>
        public CountersInfo Counters { get; set; } = new CountersInfo();

        /// <summary>
        /// 持续时间
        /// </summary>
        public double Duration { get; set; }

        /// <summary>
        /// 消息ID
        /// </summary>
        public int MessageId { get; set; }

        /// <summary>
        /// 时间戳
        /// </summary>
        public double Time { get; set; }

        /// <summary>
        /// 接收时间
        /// </summary>
        public DateTime ReceivedAt { get; set; } = DateTime.Now;

        /// <summary>
        /// 客户端名称
        /// </summary>
        public string ClientName { get; set; } = "";

        /// <summary>
        /// 从JObject创建StatisticsData
        /// </summary>
        public static StatisticsData FromJObject(JObject data, string clientName)
        {
            var stats = new StatisticsData
            {
                Message = data["message"]?.ToString() ?? "",
                InstanceId = data["instance_id"]?.ToString() ?? "",
                Duration = data["duration"]?.Value<double>() ?? 0,
                MessageId = data["message_id"]?.Value<int>() ?? 0,
                Time = data["time"]?.Value<double>() ?? 0,
                ClientName = clientName
            };

            // 解析CPU信息
            if (data["cpu"] is JObject cpuObj)
            {
                stats.Cpu.Global = cpuObj["global"]?.Value<double>() ?? 0;
            }

            // 解析小区信息
            if (data["cells"] is JObject cellsObj)
            {
                foreach (var cell in cellsObj)
                {
                    if (cell.Value is JObject cellObj)
                    {
                        var cellInfo = new CellInfo
                        {
                            DlBitrate = cellObj["dl_bitrate"]?.Value<double>() ?? 0,
                            UlBitrate = cellObj["ul_bitrate"]?.Value<double>() ?? 0,
                            DlTx = cellObj["dl_tx"]?.Value<double>() ?? 0,
                            UlTx = cellObj["ul_tx"]?.Value<double>() ?? 0,
                            DlRetx = cellObj["dl_retx"]?.Value<double>() ?? 0,
                            UlRetx = cellObj["ul_retx"]?.Value<double>() ?? 0,
                            DlUseMin = cellObj["dl_use_min"]?.Value<double>() ?? 0,
                            DlUseMax = cellObj["dl_use_max"]?.Value<double>() ?? 0,
                            DlUseAvg = cellObj["dl_use_avg"]?.Value<double>() ?? 0,
                            UlUseMin = cellObj["ul_use_min"]?.Value<double>() ?? 0,
                            UlUseMax = cellObj["ul_use_max"]?.Value<double>() ?? 0,
                            UlUseAvg = cellObj["ul_use_avg"]?.Value<double>() ?? 0,
                            DlSchedUsersMin = cellObj["dl_sched_users_min"]?.Value<double>() ?? 0,
                            DlSchedUsersMax = cellObj["dl_sched_users_max"]?.Value<double>() ?? 0,
                            DlSchedUsersAvg = cellObj["dl_sched_users_avg"]?.Value<double>() ?? 0,
                            UlSchedUsersMin = cellObj["ul_sched_users_min"]?.Value<double>() ?? 0,
                            UlSchedUsersMax = cellObj["ul_sched_users_max"]?.Value<double>() ?? 0,
                            UlSchedUsersAvg = cellObj["ul_sched_users_avg"]?.Value<double>() ?? 0,
                            UeCountMin = cellObj["ue_count_min"]?.Value<double>() ?? 0,
                            UeCountMax = cellObj["ue_count_max"]?.Value<double>() ?? 0,
                            UeCountAvg = cellObj["ue_count_avg"]?.Value<double>() ?? 0,
                            ErabCountMin = cellObj["erab_count_min"]?.Value<double>() ?? 0,
                            ErabCountMax = cellObj["erab_count_max"]?.Value<double>() ?? 0,
                            ErabCountAvg = cellObj["erab_count_avg"]?.Value<double>() ?? 0,
                            DlGbrUseMin = cellObj["dl_gbr_use_min"]?.Value<double>() ?? 0,
                            DlGbrUseMax = cellObj["dl_gbr_use_max"]?.Value<double>() ?? 0,
                            DlGbrUseAvg = cellObj["dl_gbr_use_avg"]?.Value<double>() ?? 0,
                            UlGbrUseMin = cellObj["ul_gbr_use_min"]?.Value<double>() ?? 0,
                            UlGbrUseMax = cellObj["ul_gbr_use_max"]?.Value<double>() ?? 0,
                            UlGbrUseAvg = cellObj["ul_gbr_use_avg"]?.Value<double>() ?? 0
                        };

                        // 解析计数器
                        if (cellObj["counters"] is JObject countersObj)
                        {
                            if (countersObj["messages"] is JObject messagesObj)
                            {
                                foreach (var msg in messagesObj)
                                {
                                    cellInfo.Counters.Messages[msg.Key] = msg.Value?.Value<int>() ?? 0;
                                }
                            }
                            if (countersObj["errors"] is JObject errorsObj)
                            {
                                foreach (var err in errorsObj)
                                {
                                    cellInfo.Counters.Errors[err.Key] = err.Value?.Value<int>() ?? 0;
                                }
                            }
                        }

                        stats.Cells[cell.Key] = cellInfo;
                    }
                }
            }

            // 解析RF端口信息
            if (data["rf_ports"] is JObject rfPortsObj)
            {
                foreach (var port in rfPortsObj)
                {
                    if (port.Value is JObject portObj)
                    {
                        var rfPortInfo = new RfPortInfo();
                        if (portObj["rxtx_delay"] is JObject delayObj)
                        {
                            foreach (var delay in delayObj)
                            {
                                rfPortInfo.RxtxDelay[delay.Key] = delay.Value?.Value<double>() ?? 0;
                            }
                        }
                        stats.RfPorts[port.Key] = rfPortInfo;
                    }
                }
            }

            // 解析全局计数器
            if (data["counters"] is JObject globalCountersObj)
            {
                if (globalCountersObj["messages"] is JObject messagesObj)
                {
                    foreach (var msg in messagesObj)
                    {
                        stats.Counters.Messages[msg.Key] = msg.Value?.Value<int>() ?? 0;
                    }
                }
                if (globalCountersObj["errors"] is JObject errorsObj)
                {
                    foreach (var err in errorsObj)
                    {
                        stats.Counters.Errors[err.Key] = err.Value?.Value<int>() ?? 0;
                    }
                }
            }

            return stats;
        }
    }

    /// <summary>
    /// CPU信息
    /// </summary>
    public class CpuInfo
    {
        public double Global { get; set; }
    }

    /// <summary>
    /// 小区信息
    /// </summary>
    public class CellInfo
    {
        public double DlBitrate { get; set; }
        public double UlBitrate { get; set; }
        public double DlTx { get; set; }
        public double UlTx { get; set; }
        public double DlRetx { get; set; }
        public double UlRetx { get; set; }
        public double DlUseMin { get; set; }
        public double DlUseMax { get; set; }
        public double DlUseAvg { get; set; }
        public double UlUseMin { get; set; }
        public double UlUseMax { get; set; }
        public double UlUseAvg { get; set; }
        public double DlSchedUsersMin { get; set; }
        public double DlSchedUsersMax { get; set; }
        public double DlSchedUsersAvg { get; set; }
        public double UlSchedUsersMin { get; set; }
        public double UlSchedUsersMax { get; set; }
        public double UlSchedUsersAvg { get; set; }
        public double UeCountMin { get; set; }
        public double UeCountMax { get; set; }
        public double UeCountAvg { get; set; }
        public double ErabCountMin { get; set; }
        public double ErabCountMax { get; set; }
        public double ErabCountAvg { get; set; }
        public double DlGbrUseMin { get; set; }
        public double DlGbrUseMax { get; set; }
        public double DlGbrUseAvg { get; set; }
        public double UlGbrUseMin { get; set; }
        public double UlGbrUseMax { get; set; }
        public double UlGbrUseAvg { get; set; }
        public CountersInfo Counters { get; set; } = new CountersInfo();
    }

    /// <summary>
    /// RF端口信息
    /// </summary>
    public class RfPortInfo
    {
        public Dictionary<string, double> RxtxDelay { get; set; } = new Dictionary<string, double>();
    }

    /// <summary>
    /// 计数器信息
    /// </summary>
    public class CountersInfo
    {
        public Dictionary<string, int> Messages { get; set; } = new Dictionary<string, int>();
        public Dictionary<string, int> Errors { get; set; } = new Dictionary<string, int>();
    }

    /// <summary>
    /// 统计数据队列管理器
    /// </summary>
    public class StatisticsQueueManager
    {
        private readonly ConcurrentQueue<StatisticsData> _statsQueue = new ConcurrentQueue<StatisticsData>();
        private readonly int _maxQueueSize = 1000; // 最大队列大小
        private readonly object _lockObject = new object();

        /// <summary>
        /// 添加统计数据到队列
        /// </summary>
        public void EnqueueStats(StatisticsData stats)
        {
            lock (_lockObject)
            {
                _statsQueue.Enqueue(stats);
                
                // 维持队列大小
                while (_statsQueue.Count > _maxQueueSize)
                {
                    _statsQueue.TryDequeue(out _);
                }
            }
        }

        /// <summary>
        /// 获取队列中的所有统计数据
        /// </summary>
        public List<StatisticsData> GetAllStats()
        {
            lock (_lockObject)
            {
                return _statsQueue.ToList();
            }
        }

        /// <summary>
        /// 获取最新的统计数据
        /// </summary>
        public StatisticsData? GetLatestStats()
        {
            lock (_lockObject)
            {
                return _statsQueue.TryPeek(out var stats) ? stats : null;
            }
        }

        /// <summary>
        /// 清空队列
        /// </summary>
        public void Clear()
        {
            lock (_lockObject)
            {
                while (_statsQueue.TryDequeue(out _))
                {
                    // 清空所有数据
                }
            }
        }

        /// <summary>
        /// 获取队列大小
        /// </summary>
        public int Count
        {
            get
            {
                lock (_lockObject)
                {
                    return _statsQueue.Count;
                }
            }
        }
    }
}