using System.Collections.Immutable;
using System.Text.RegularExpressions;
using Newtonsoft.Json;

namespace LTEMvcApp.Models;

/// <summary>
/// LTE客户端类 - 对应JavaScript中的lte.client对象
/// </summary>
public class LTEClient
{
    #region 常量定义

    /// <summary>
    /// HFN回绕阈值
    /// </summary>
    private const int HFN_WRAP_THRESHOLD = 512;

    /// <summary>
    /// 最大日志数量
    /// </summary>
    private const int LOGS_MAX = 2000000;

    #endregion

    #region 正则表达式

    /// <summary>
    /// PHY层日志正则表达式
    /// </summary>
    private static readonly Regex RegExpPhy = new(@"^([a-f0-9\-]+)\s+([a-f0-9\-]+)\s+([\d\.\-]+) (\w+): (.+)", RegexOptions.Compiled);

    /// <summary>
    /// 信息1正则表达式
    /// </summary>
    private static readonly Regex RegExpInfo1 = new(@"^([\w\-]+): (.+)", RegexOptions.Compiled);

    /// <summary>
    /// 信息2正则表达式
    /// </summary>
    private static readonly Regex RegExpInfo2 = new(@"^([\w]+) (.+)", RegexOptions.Compiled);

    /// <summary>
    /// IP日志正则表达式
    /// </summary>
    private static readonly Regex RegExpIP = new(@"^(len=\d+)\s+(\S+)\s+(.*)", RegexOptions.Compiled);

    /// <summary>
    /// IPsec日志正则表达式
    /// </summary>
    private static readonly Regex RegExpIPsec = new(@"^len=(\d+)\s+(.*)", RegexOptions.Compiled);

    /// <summary>
    /// SDU长度正则表达式
    /// </summary>
    private static readonly Regex RegExpSDULen = new(@"SDU_len=(\d+)", RegexOptions.Compiled);

    /// <summary>
    /// SIP日志正则表达式
    /// </summary>
    private static readonly Regex RegExpSIP = new(@"^([:\.\[\]\da-f]+)\s+(\S+) (.+)", RegexOptions.Compiled);

    /// <summary>
    /// 媒体请求正则表达式
    /// </summary>
    private static readonly Regex RegExpMediaReq = new(@"^(\S+) (.+)", RegexOptions.Compiled);

    /// <summary>
    /// 信号记录正则表达式
    /// </summary>
    private static readonly Regex RegExpSignalRecord = new(@"Link:\s([\w\d]+)@(\d+)", RegexOptions.Compiled);

    /// <summary>
    /// 小区ID正则表达式
    /// </summary>
    private static readonly Regex RegExpCellID = new(@"^([a-f0-9\-]+) (.+)", RegexOptions.Compiled);

    /// <summary>
    /// RRC UE ID正则表达式
    /// </summary>
    private static readonly Regex RegExpRRC_UE_ID = new(@"Changing UE_ID to 0x(\d+)", RegexOptions.Compiled);

    /// <summary>
    /// RRC TMSI正则表达式
    /// </summary>
    private static readonly Regex RegExpRRC_TMSI = new(@"(5G|m)-TMSI '([\dA-F]+)'H", RegexOptions.Compiled);

    /// <summary>
    /// RRC新ID正则表达式
    /// </summary>
    private static readonly Regex RegExpRRC_NEW_ID = new(@"newUE-Identity (['\dA-FH]+)", RegexOptions.Compiled);

    /// <summary>
    /// RRC CRNTI正则表达式
    /// </summary>
    private static readonly Regex RegExpRRC_CRNTI = new(@"c-RNTI '([\dA-F]+)'H", RegexOptions.Compiled);

    /// <summary>
    /// NAS TMSI正则表达式
    /// </summary>
    private static readonly Regex RegExpNAS_TMSI = new(@"m-TMSI = 0x([\da-f]+)", RegexOptions.Compiled);

    /// <summary>
    /// NAS 5G TMSI正则表达式
    /// </summary>
    private static readonly Regex RegExpNAS_5GTMSI = new(@"5G-TMSI = 0x([\da-f]+)", RegexOptions.Compiled);

    /// <summary>
    /// RRC频段组合正则表达式
    /// </summary>
    private static readonly Regex RegExpRRC_BC = new(@"(EUTRA|MRDC|NR|NRDC) band combinations", RegexOptions.Compiled);

    /// <summary>
    /// PDCCH正则表达式
    /// </summary>
    private static readonly Regex RegExpPDCCH = new(@"^\s*(.+)=(\d+)$", RegexOptions.Compiled);

    /// <summary>
    /// S1/NGAP正则表达式
    /// </summary>
    private static readonly Regex RegExpS1NGAP = new(@"^([\da-f\-]+)\s+([\da-f\-]+) (([^\s]+) .+)", RegexOptions.Compiled);

    /// <summary>
    /// 十六进制转储正则表达式
    /// </summary>
    private static readonly Regex RegExpHexDump = new(@"^[\da-f]+:(\s+[\da-f]{2}){1,16}\s+.{1,16}$", RegexOptions.Compiled);

    #endregion

    #region 基础属性

    /// <summary>
    /// 客户端ID
    /// </summary>
    public int ClientId { get; set; }

    /// <summary>
    /// 客户端名称
    /// </summary>
    public string Name { get; set; } = string.Empty;

    /// <summary>
    /// 客户端配置
    /// </summary>
    public ClientConfig Config { get; set; } = new();

    /// <summary>
    /// 客户端状态
    /// </summary>
    public ClientState State { get; set; } = ClientState.Stop;

    /// <summary>
    /// 版本信息
    /// </summary>
    public string? Version { get; set; }

    /// <summary>
    /// 许可证信息
    /// </summary>
    public string? License { get; set; }

    /// <summary>
    /// 模型类型
    /// </summary>
    public string? Model { get; set; }

    /// <summary>
    /// 是否有信号记录
    /// </summary>
    public bool HasSignalRecord { get; set; }

    #endregion

    #region 日志相关属性

    /// <summary>
    /// 日志列表
    /// </summary>
    public List<LTELog> Logs { get; set; } = new();

    /// <summary>
    /// 日志数量
    /// </summary>
    public int LogCount => Logs.Count;

    /// <summary>
    /// 是否已过滤
    /// </summary>
    public bool Filtered { get; set; }

    /// <summary>
    /// 重置标志
    /// </summary>
    public bool ResetFlag { get; set; }

    #endregion

    #region 解析器状态

    /// <summary>
    /// 最后HARQ信息
    /// </summary>
    public Dictionary<int, Dictionary<int, LTELog>> LastHarq { get; set; } = new();

    /// <summary>
    /// 最后NB HARQ信息
    /// </summary>
    public Dictionary<int, Dictionary<int, List<LTELog>>> LastNbHarq { get; set; } = new();

    /// <summary>
    /// 帧信息
    /// </summary>
    public FrameInfo Frame { get; set; } = new();

    /// <summary>
    /// TMSI到UE ID的映射
    /// </summary>
    public Dictionary<int, int> TmsiToUeId { get; set; } = new();

    /// <summary>
    /// RNTI到UE ID的映射
    /// </summary>
    public Dictionary<int, int> RntiToUeId { get; set; } = new();

    /// <summary>
    /// UE列表
    /// </summary>
    public Dictionary<int, UEInfo> UeList { get; set; } = new();

    /// <summary>
    /// 最后时间戳
    /// </summary>
    public long LastTimestamp { get; set; }

    /// <summary>
    /// 时间戳偏移
    /// </summary>
    public long TimestampOffset { get; set; }

    /// <summary>
    /// 最后小区
    /// </summary>
    public int? LastCell { get; set; }

    #endregion

    #region 功能标志

    /// <summary>
    /// 是否有小区信息
    /// </summary>
    public bool HasCell { get; set; }

    /// <summary>
    /// 是否有物理层信息
    /// </summary>
    public bool HasPhy { get; set; }

    /// <summary>
    /// 是否有数据
    /// </summary>
    public bool HasData { get; set; }

    /// <summary>
    /// 是否有RNTI
    /// </summary>
    public bool HasRnti { get; set; }

    /// <summary>
    /// 是否有资源块
    /// </summary>
    public bool HasRb { get; set; }

    #endregion

    #region 参数和组件

    /// <summary>
    /// 参数信息
    /// </summary>
    public Dictionary<string, object> Parameters { get; set; } = new();

    /// <summary>
    /// 组件列表
    /// </summary>
    public Dictionary<string, object> Components { get; set; } = new();

    #endregion

    #region 依赖注入

    /// <summary>
    /// 日志管理器
    /// </summary>
    private readonly LogsManager _lteLogs;

    /// <summary>
    /// 获取日志管理器实例
    /// </summary>
    public LogsManager LogsManager => _lteLogs;

    #endregion

    #region 构造函数

    public LTEClient(ClientConfig config, LogsManager logsManager)
    {
        Config = config;
        Name = config.Name;
        ClientId = GenerateClientId();
        _lteLogs = logsManager;
        ResetParserState();
    }

    /// <summary>
    /// 使用名称创建客户端
    /// </summary>
    /// <param name="name">客户端名称</param>
    /// <param name="logsManager">日志管理器</param>
    public LTEClient(string name, LogsManager logsManager)
    {
        Config = new ClientConfig { Name = name, Enabled = true };
        Name = name;
        ClientId = GenerateClientId();
        _lteLogs = logsManager;
        ResetParserState();
    }

    #endregion

    #region 客户端控制方法

    /// <summary>
    /// 启动客户端
    /// </summary>
    public void Start()
    {
        SetState(ClientState.Start);
    }

    /// <summary>
    /// 停止客户端
    /// </summary>
    public void Stop()
    {
        SetState(ClientState.Stop);
    }

    /// <summary>
    /// 销毁客户端
    /// </summary>
    public void Destroy()
    {
        SetState(ClientState.Destroy);
    }

    #endregion

    #region 日志管理方法

    /// <summary>
    /// 重置日志
    /// </summary>
    public void ResetLogs()
    {
        if (LogCount > 0)
        {
            ResetFlag = true;
            Logs.Clear();
            ResetParserState();
            HasCell = false;
            HasPhy = false;
            HasData = false;
            HasRnti = false;
            HasRb = false;
            HasSignalRecord = false;
        }
    }

    /// <summary>
    /// 添加日志
    /// </summary>
    public void AddLog(LTELog log)
    {
        // 检查时间戳回绕
        var timestamp = log.Timestamp + TimestampOffset;
        if (timestamp < LastTimestamp - 100)
        {
            Console.WriteLine($"Log wrap by {LastTimestamp - timestamp}");
            timestamp += 86400000; // 24小时
            TimestampOffset += 86400000;
        }
        LastTimestamp = log.Timestamp = timestamp;

        log.Client = this;
        log.Id = GenerateLogId();
    }

    #endregion

    #region 工具方法

    /// <summary>
    /// 设置头信息
    /// </summary>
    public void SetHeaders(string[] headers)
    {
        // 实现头信息设置逻辑
    }

    /// <summary>
    /// 初始化模型猜测
    /// </summary>
    public void LogModelGuessInit()
    {
        if (string.IsNullOrEmpty(Config.Model))
        {
            // 尝试所有模型
            var modelList = new List<string> { "RUE", "UE", "PROBE", "ENB", "N3IWF", "MBMSGW", "MME", "IMS", "LICENSE", "MONITOR" };
            if (!TryModelHint(modelList))
            {
                SetModel("MME"); // 默认模型
            }

            // 初始化模型猜测字典
            _modelGuess = new Dictionary<string, bool>();
            var layerConfig = GetLayerConfig();
            foreach (var layer in layerConfig.Keys)
            {
                _modelGuess[layer] = false;
            }
        }
    }

    /// <summary>
    /// 模型猜测字典
    /// </summary>
    private Dictionary<string, bool>? _modelGuess;

    /// <summary>
    /// 获取层配置
    /// </summary>
    /// <returns>层配置字典</returns>
    private Dictionary<string, object> GetLayerConfig()
    {
        // 这里应该从 LogsManager 获取层配置
        // 暂时返回一个基本的层配置
        return new Dictionary<string, object>
        {
            { "PHY", new { Color = "#606070" } },
            { "MAC", new { Color = "#10A0FF" } },
            { "RLC", new { Color = "#FFFF80" } },
            { "PDCP", new { Color = "#B0D0B0" } },
            { "RRC", new { Color = "#00FF60" } },
            { "NAS", new { Color = "#90FFC0" } },
            { "GTPU", new { Color = "#FF80FF" } },
            { "GTPC", new { Color = "#FFC0FF" } },
            { "IP", new { Color = "#E0E0E0" } },
            { "S1AP", new { Color = "#80FF00" } },
            { "NGAP", new { Color = "#5DD122" } },
            { "X2AP", new { Color = "#FF8000" } },
            { "XnAP", new { Color = "#FFB020" } },
            { "M2AP", new { Color = "#7F675B" } },
            { "IMS", new { Color = "#C0FF80" } },
            { "CX", new { Color = "#F49542" } },
            { "RX", new { Color = "#D4A190" } },
            { "COM", new { Color = "#C000FF" } },
            { "SIP", new { Color = "#C080FF" } },
            { "MEDIA", new { Color = "#800040" } },
            { "RTP", new { Color = "#FF00C0" } },
            { "PROD", new { Color = "#80C0FF" } },
            { "S6", new { Color = "#F44B42" } },
            { "S13", new { Color = "#D6F953" } },
            { "SGsAP", new { Color = "#FF7DB8" } },
            { "SBcAP", new { Color = "#8FA00F" } },
            { "N8", new { Color = "#106020" } },
            { "N12", new { Color = "#602020" } },
            { "N13", new { Color = "#202060" } },
            { "N17", new { Color = "#D6F953" } },
            { "N50", new { Color = "#8FA00F" } },
            { "MMS", new { Color = "#B4D98F" } },
            { "HTTP2", new { Color = "#644824" } },
            { "LCSAP", new { Color = "#cfd50d" } },
            { "LPPa", new { Color = "#0dcfd5" } },
            { "NL1", new { Color = "#d040cf" } },
            { "NRPPa", new { Color = "#0dd5cf" } },
            { "IKEV2", new { Color = "#C0B732" } },
            { "SWU", new { Color = "#101080" } },
            { "NWU", new { Color = "#2080B8" } },
            { "IPSEC", new { Color = "#F04010" } },
            { "N3IWF", new { Color = "#C080C0" } },
            { "TRX", new { Color = "#42C0a0" } },
            { "MON", new { Color = "#C0C080" } },
            { "EVENT", new { Color = "#80C0FF" } },
            { "ALARM", new { Color = "#FF8040" } },
            { "LIC", new { Color = "#ff80c0" } },
            { "OTS", new { Color = "#8080FF" } },
            { "ERROR", new { Color = "#ff0000" } }
        };
    }

    /// <summary>
    /// 模型猜测
    /// </summary>
    /// <param name="logs">日志列表</param>
    public void LogModelGuess(List<Dictionary<string, object>> logs)
    {
        var modelGuess = _modelGuess;
        if (modelGuess == null)
            return;

        // 标记所有出现的层
        foreach (var log in logs)
        {
            if (log.TryGetValue("layer", out var layer) && layer is string layerStr)
            {
                modelGuess[layerStr] = true;
            }
        }

        // 尝试根据层配置确定模型
        var modelList = new List<string> { "RUE", "UE", "PROBE", "ENB", "N3IWF", "MBMSGW", "MME", "IMS", "LICENSE", "MONITOR" };
        var availableModels = new List<string>(modelList);

        // 根据层配置过滤模型
        foreach (var layer in modelGuess.Keys)
        {
            if (!modelGuess[layer]) continue;

            var layerConfig = GetLayerConfig();
            if (layerConfig.TryGetValue(layer, out var config))
            {
                // 这里应该检查层的方向配置来过滤模型
                // 暂时简化处理
                var layerDir = GetLayerDirection(layer);
                if (layerDir != null)
                {
                    // 移除不支持的模型
                    availableModels.RemoveAll(model => !layerDir.ContainsKey(model));
                }
            }

            // 如果只剩下一个模型，直接设置
            if (availableModels.Count <= 1)
                break;
        }

        // 如果找到了合适的模型，设置它
        if (availableModels.Count > 0 && availableModels.Count < modelList.Count)
        {
            SetModel(availableModels[0]);
            _modelGuess = null; // 清除猜测字典
        }
    }

    /// <summary>
    /// 获取层方向配置
    /// </summary>
    /// <param name="layer">层名称</param>
    /// <returns>方向配置字典</returns>
    private Dictionary<string, int>? GetLayerDirection(string layer)
    {
        // 这里应该从 LogsManager 获取层的方向配置
        // 暂时返回一个基本的配置
        return layer switch
        {
            "PHY" => new Dictionary<string, int> { { "UE", 2 }, { "PROBE", 3 }, { "ENB", 1 } },
            "MAC" => new Dictionary<string, int> { { "UE", 2 }, { "PROBE", 3 }, { "ENB", 1 } },
            "RLC" => new Dictionary<string, int> { { "UE", 2 }, { "PROBE", 3 }, { "ENB", 1 } },
            "PDCP" => new Dictionary<string, int> { { "UE", 2 }, { "PROBE", 3 }, { "ENB", 1 } },
            "RRC" => new Dictionary<string, int> { { "UE", 2 }, { "PROBE", 3 }, { "ENB", 1 } },
            "NAS" => new Dictionary<string, int> { { "UE", 2 }, { "PROBE", 3 }, { "ENB", 3 }, { "N3IWF", 3 }, { "MME", 1 } },
            "GTPU" => new Dictionary<string, int> { { "ENB", 2 }, { "N3IWF", 2 }, { "MME", 1 }, { "MBMSGW", 1 }, { "UE", 1 }, { "RUE", 2 } },
            "GTPC" => new Dictionary<string, int> { { "MME", 2 } },
            "IP" => new Dictionary<string, int> { { "RUE", 2 }, { "UE", 2 }, { "N3IWF", 3 }, { "PROBE", 3 }, { "MME", 3 } },
            "S1AP" => new Dictionary<string, int> { { "ENB", 2 }, { "MME", 1 } },
            "NGAP" => new Dictionary<string, int> { { "ENB", 2 }, { "MME", 1 }, { "N3IWF", 2 } },
            "X2AP" => new Dictionary<string, int> { { "ENB", 2 } },
            "XnAP" => new Dictionary<string, int> { { "ENB", 2 } },
            "M2AP" => new Dictionary<string, int> { { "ENB", 2 }, { "MBMSGW", 1 } },
            "IMS" => new Dictionary<string, int> { { "MME", 2 }, { "IMS", 1 } },
            "CX" => new Dictionary<string, int> { { "MME", 2 }, { "IMS", 1 } },
            "RX" => new Dictionary<string, int> { { "MME", 2 }, { "IMS", 1 } },
            "COM" => new Dictionary<string, int> { { "*", 2 } },
            "SIP" => new Dictionary<string, int> { { "IMS", 1 } },
            "MEDIA" => new Dictionary<string, int> { { "IMS", 1 } },
            "RTP" => new Dictionary<string, int> { { "IMS", 1 } },
            "PROD" => new Dictionary<string, int> { },
            "S6" => new Dictionary<string, int> { { "MME", 2 } },
            "S13" => new Dictionary<string, int> { { "MME", 2 } },
            "SGsAP" => new Dictionary<string, int> { { "MME", 2 } },
            "SBcAP" => new Dictionary<string, int> { { "MME", 2 } },
            "N8" => new Dictionary<string, int> { { "MME", 2 } },
            "N12" => new Dictionary<string, int> { { "MME", 2 } },
            "N13" => new Dictionary<string, int> { { "MME", 2 } },
            "N17" => new Dictionary<string, int> { { "MME", 2 } },
            "N50" => new Dictionary<string, int> { { "MME", 2 } },
            "MMS" => new Dictionary<string, int> { { "MME", 2 } },
            "HTTP2" => new Dictionary<string, int> { { "MME", 2 } },
            "LCSAP" => new Dictionary<string, int> { { "MME", 2 } },
            "LPPa" => new Dictionary<string, int> { { "ENB", 2 }, { "MME", 3 } },
            "NL1" => new Dictionary<string, int> { { "MME", 2 } },
            "NRPPa" => new Dictionary<string, int> { { "ENB", 2 }, { "MME", 3 } },
            "IKEV2" => new Dictionary<string, int> { { "UE", 2 }, { "MME", 1 }, { "N3IWF", 1 } },
            "SWU" => new Dictionary<string, int> { { "UE", 2 }, { "MME", 1 } },
            "NWU" => new Dictionary<string, int> { { "UE", 2 }, { "MME", 1 } },
            "IPSEC" => new Dictionary<string, int> { { "UE", 2 }, { "IMS", 1 }, { "N3IWF", 1 }, { "MME", 1 } },
            "N3IWF" => new Dictionary<string, int> { { "UE", 2 }, { "N3IWF", 1 } },
            "TRX" => new Dictionary<string, int> { { "UE", 2 }, { "ENB", 1 } },
            "MON" => new Dictionary<string, int> { },
            "EVENT" => new Dictionary<string, int> { },
            "ALARM" => new Dictionary<string, int> { },
            "LIC" => new Dictionary<string, int> { { "LICENSE", 1 } },
            "OTS" => new Dictionary<string, int> { },
            "ERROR" => new Dictionary<string, int> { },
            _ => null
        };
    }

    /// <summary>
    /// 方向转换
    /// </summary>
    public int DirConvert(LTELog log)
    {
        // 实现方向转换逻辑
        return 0;
    }

    /// <summary>
    /// 字符串转ID - 委托给LogsManager
    /// </summary>
    public int StringToId(string str)
    {
        return _lteLogs.String2Id(str);
    }

    /// <summary>
    /// ID转字符串 - 委托给LogsManager
    /// </summary>
    public string IdToString(int id)
    {
        return _lteLogs.Id2String(id);
    }

    #endregion

    #region 日志解析方法

    /// <summary>
    /// 解析日志列表 - 对应JavaScript的_logListParse方法
    /// </summary>
    /// <param name="logs">日志列表</param>
    /// <param name="isWebSocket">是否为WebSocket消息</param>
    public void ParseLogList(List<LTELog> logs, bool isWebSocket = false)
    {
        var length = logs.Count;

        for (int i = 0; i < length; i++)
        {
            var log = logs[i];
            log.Message = log.Message + "";

            AddLog(log);

            // 解析消息
            switch (log.Layer)
            {
                case "PHY":
                    if (!ParsePhyLog(log, log.Message, isWebSocket)) continue;
                    ProcessPhyLog(log);
                    break;

                case "RRC":
                    ParseCellId(log, isWebSocket);
                    var rrcUeIdMatch = RegExpRRC_UE_ID.Match(log.Message);
                    if (rrcUeIdMatch.Success)
                    {
                        SetSameUe(log, int.Parse(rrcUeIdMatch.Groups[1].Value, System.Globalization.NumberStyles.HexNumber));
                        continue;
                    }

                    var infoMatch = RegExpInfo1.Match(log.Message);
                    if (infoMatch.Success)
                    {
                        if (!SetLogInfo(log, infoMatch.Groups[1].Value)) continue;
                        log.Message = infoMatch.Groups[2].Value;
                        ProcessRrcLog(log);
                    }

                    var bcMatch = RegExpRRC_BC.Match(log.Message);
                    if (bcMatch.Success)
                    {
                        try
                        {
                            var data = log.GetDataString();
                            var jsonData = JsonConvert.DeserializeObject<object>(data);
                            // 处理频段组合信息
                        }
                        catch
                        {
                            // 忽略JSON解析错误
                        }
                    }
                    break;

                case "NAS":
                    ParseCellId(log, isWebSocket);
                    var nasTmsiMatch = RegExpNAS_TMSI.Match(log.Message);
                    if (nasTmsiMatch.Success)
                    {
                        SetTmsi(log, nasTmsiMatch.Groups[1].Value);
                        continue;
                    }

                    var nas5gTmsiMatch = RegExpNAS_5GTMSI.Match(log.Message);
                    if (nas5gTmsiMatch.Success)
                    {
                        SetTmsi(log, nas5gTmsiMatch.Groups[1].Value);
                        continue;
                    }

                    var nasInfoMatch = RegExpInfo2.Match(log.Message);
                    if (nasInfoMatch.Success)
                    {
                        if (!SetLogInfo(log, nasInfoMatch.Groups[1].Value)) continue;
                        log.Message = nasInfoMatch.Groups[2].Value;
                        ProcessNasLog(log);
                    }
                    break;

                case "MAC":
                    ParseCellId(log, isWebSocket);
                    ParseMacLog(log);
                    break;

                case "IP":
                    var ipMatch = RegExpIP.Match(log.Message);
                    if (ipMatch.Success)
                    {
                        var lenPart = ipMatch.Groups[1].Value;
                        log.IpLen = int.Parse(lenPart.Split('=')[1]);
                        if (!SetLogInfo(log, ipMatch.Groups[2].Value)) continue;
                        log.Message = ipMatch.Groups[3].Value;
                        HasData = true;
                    }
                    break;

                case "GTPU":
                    var sduLenMatch = RegExpSDULen.Match(log.Message);
                    if (sduLenMatch.Success)
                    {
                        log.SduLen = int.Parse(sduLenMatch.Groups[1].Value);
                        HasData = true;
                    }
                    break;

                case "S1AP":
                case "NGAP":
                    var s1ngMatch = RegExpS1NGAP.Match(log.Message);
                    if (s1ngMatch.Success)
                    {
                        log.Message = s1ngMatch.Groups[3].Value;
                        var coreId = int.TryParse(s1ngMatch.Groups[1].Value, System.Globalization.NumberStyles.HexNumber, null, out var core) ? core : (int?)null;
                        var ranId = int.TryParse(s1ngMatch.Groups[2].Value, System.Globalization.NumberStyles.HexNumber, null, out var ran) ? ran : (int?)null;

                        log.LinkIds = new LinkIds { Core = coreId, Ran = ranId };
                    }
                    break;

                case "SIP":
                    var sipMatch = RegExpSIP.Match(log.Message);
                    if (sipMatch.Success)
                    {
                        if (!SetLogInfo(log, sipMatch.Groups[2].Value)) continue;
                        log.Message = sipMatch.Groups[3].Value;
                    }
                    break;

                case "MEDIA":
                    var mediaMatch = RegExpMediaReq.Match(log.Message);
                    if (mediaMatch.Success)
                    {
                        if (!SetLogInfo(log, mediaMatch.Groups[1].Value)) continue;
                        log.Message = mediaMatch.Groups[2].Value;
                    }
                    break;

                case "IPsec":
                    var ipsecMatch = RegExpIPsec.Match(log.Message);
                    if (ipsecMatch.Success)
                    {
                        log.IpLen = int.Parse(ipsecMatch.Groups[1].Value);
                        log.Message = ipsecMatch.Groups[2].Value;
                    }
                    break;

                default:
                    break;
            }

            // 处理提示信息
            ProcessHints(log);
        }

        // 限制日志数量
        if (LogCount > LOGS_MAX)
        {
            var excess = LogCount - LOGS_MAX;
            Logs.RemoveRange(0, excess);
        }
    }

    #endregion

    #region PHY层解析方法

    /// <summary>
    /// 解析PHY日志
    /// </summary>
    private bool ParsePhyLog(LTELog log, string message, bool isWebSocket)
    {
        if (!isWebSocket)
        {
            var phyMatch = RegExpPhy.Match(message);
            if (!phyMatch.Success)
            {
                Console.WriteLine($"Bad PHY log: {log}");
                return false;
            }

            log.Cell = int.Parse(phyMatch.Groups[1].Value, System.Globalization.NumberStyles.HexNumber);
            log.Rnti = int.Parse(phyMatch.Groups[2].Value, System.Globalization.NumberStyles.HexNumber);
            log.Channel = phyMatch.Groups[4].Value;
            log.Message = phyMatch.Groups[5].Value;
        }

        HasPhy = true;
        HasCell = true;
        HasRnti = true;

        // 解析PHY参数
        var lines = log.GetData();
        foreach (var line in lines)
        {
            var parts = line.Split('=');
            if (parts.Length == 2)
            {
                ParsePhyParameter(log, parts[0].Trim(), parts[1].Trim());
            }
        }

        return true;
    }

    /// <summary>
    /// 解析PHY参数
    /// </summary>
    private void ParsePhyParameter(LTELog log, string param, string value)
    {
        switch (param.ToLower())
        {
            case "frame":
                if (int.TryParse(value, out var frame))
                {
                    log.Frame = frame;
                    HasPhy = true;
                }
                break;
            case "subframe":
                if (int.TryParse(value, out var subframe))
                {
                    log.Subframe = subframe;
                }
                break;
            case "slot":
                if (int.TryParse(value, out var slot))
                {
                    log.Slot = slot;
                }
                break;
            case "symbol":
                if (int.TryParse(value, out var symbol))
                {
                    log.Symbol = symbol;
                }
                break;
            case "ant":
                if (int.TryParse(value, out var ant))
                {
                    log.AntennaPort = ant;
                }
                break;
            case "rb_start":
                if (int.TryParse(value, out var rbStart))
                {
                    log.RbStart = rbStart;
                    HasRb = true;
                }
                break;
            case "rb_count":
                if (int.TryParse(value, out var rbCount))
                {
                    log.RbCount = rbCount;
                    HasRb = true;
                }
                break;
            case "mcs":
                if (int.TryParse(value, out var mcs))
                {
                    log.Mcs = mcs;
                }
                break;
            case "tbs":
                if (int.TryParse(value, out var tbs))
                {
                    log.Tbs = tbs;
                }
                break;
            case "harq_id":
                if (int.TryParse(value, out var harqId))
                {
                    log.HarqId = harqId;
                }
                break;
            case "harq_ndi":
                if (bool.TryParse(value, out var harqNdi))
                {
                    log.HarqNdi = harqNdi;
                }
                break;
            case "harq_rv":
                if (int.TryParse(value, out var harqRv))
                {
                    log.HarqRedundancyVersion = harqRv;
                }
                break;
        }
    }

    /// <summary>
    /// 处理PHY日志
    /// </summary>
    private void ProcessPhyLog(LTELog log)
    {
        // 处理HARQ信息
        if (log.HarqId.HasValue)
        {
            ProcessHarqLog(log, log.HarqId.Value);
        }

        // 处理帧信息
        if (log.Frame.HasValue)
        {
            var frame = log.Frame.Value;
            var hfn = frame >> 10;
            var sfn = frame & 0x3FF;

            if (Frame.Timestamp == -1)
            {
                Frame.Timestamp = log.Timestamp;
                Frame.Hfn = hfn;
                Frame.Last = sfn;
            }
            else
            {
                var diff = sfn - Frame.Last;
                if (diff < -HFN_WRAP_THRESHOLD)
                {
                    Frame.Hfn++;
                }
                else if (diff > HFN_WRAP_THRESHOLD)
                {
                    Frame.Hfn--;
                }

                Frame.Last = sfn;
            }
        }
    }

    /// <summary>
    /// 处理HARQ日志
    /// </summary>
    private void ProcessHarqLog(LTELog log, int harq)
    {
        if (log.Cell.HasValue && log.UeId.HasValue)
        {
            var cell = log.Cell.Value;
            var ueId = log.UeId.Value;
            var key = ueId * 32 + harq;

            if (!LastHarq.ContainsKey(cell))
            {
                LastHarq[cell] = new Dictionary<int, LTELog>();
            }

            LastHarq[cell][key] = log;
        }
    }

    #endregion

    #region 其他层解析方法

    /// <summary>
    /// 解析小区ID
    /// </summary>
    private void ParseCellId(LTELog log, bool isWebSocket)
    {
        if (!isWebSocket)
        {
            var cellMatch = RegExpCellID.Match(log.Message);
            if (cellMatch.Success)
            {
                log.Cell = int.Parse(cellMatch.Groups[1].Value, System.Globalization.NumberStyles.HexNumber);
                log.Message = cellMatch.Groups[2].Value;
                HasCell = true;
            }
        }
    }

    /// <summary>
    /// 设置日志信息
    /// </summary>
    private bool SetLogInfo(LTELog log, string info)
    {
        if (string.IsNullOrEmpty(info) || info == "?")
            return false;

        log.Info = StringToId(info);
        return true;
    }

    /// <summary>
    /// 设置相同UE
    /// </summary>
    private void SetSameUe(LTELog log, int ueId)
    {
        log.UeId = ueId;
        if (!UeList.ContainsKey(ueId))
        {
            UeList[ueId] = new UEInfo { UeId = ueId };
        }
    }

    /// <summary>
    /// 处理RRC日志
    /// </summary>
    private void ProcessRrcLog(LTELog log)
    {
        // 处理RRC TMSI
        var tmsiMatch = RegExpRRC_TMSI.Match(log.Message);
        if (tmsiMatch.Success)
        {
            SetTmsi(log, tmsiMatch.Groups[2].Value);
        }

        // 处理RRC CRNTI
        var crntiMatch = RegExpRRC_CRNTI.Match(log.Message);
        if (crntiMatch.Success)
        {
            SetRnti(log, crntiMatch.Groups[1].Value);
        }
    }

    /// <summary>
    /// 处理NAS日志
    /// </summary>
    private void ProcessNasLog(LTELog log)
    {
        // NAS日志处理逻辑
    }

    /// <summary>
    /// 解析MAC日志
    /// </summary>
    private void ParseMacLog(LTELog log)
    {
        // MAC日志解析逻辑
    }

    /// <summary>
    /// 处理提示信息
    /// </summary>
    private void ProcessHints(LTELog log, Dictionary<string, object>? config = null)
    {
        // 处理提示信息逻辑
    }

    /// <summary>
    /// 设置TMSI
    /// </summary>
    private void SetTmsi(LTELog log, string tmsi)
    {
        var tmsiId = int.Parse(tmsi, System.Globalization.NumberStyles.HexNumber);
        if (log.UeId.HasValue)
        {
            TmsiToUeId[tmsiId] = log.UeId.Value;
        }
    }

    /// <summary>
    /// 设置RNTI
    /// </summary>
    private void SetRnti(LTELog log, string rnti)
    {
        var rntiId = int.Parse(rnti, System.Globalization.NumberStyles.HexNumber);
        if (log.UeId.HasValue)
        {
            RntiToUeId[rntiId] = log.UeId.Value;
        }
    }

    #endregion

    #region 私有辅助方法

    /// <summary>
    /// 设置状态
    /// </summary>
    private void SetState(ClientState state)
    {
        if (State != state)
        {
            State = state;
            switch (state)
            {
                case ClientState.Stop:
                    ResetLogs();
                    break;
                case ClientState.Start:
                case ClientState.Connected:
                    break;
                case ClientState.Destroy:
                    return;
            }
        }
    }

    /// <summary>
    /// 重置解析器状态
    /// </summary>
    private void ResetParserState()
    {
        LastHarq.Clear();
        LastNbHarq.Clear();
        Frame = new FrameInfo();
        TmsiToUeId.Clear();
        RntiToUeId.Clear();
        UeList.Clear();
        LastTimestamp = 0;
        TimestampOffset = 0;
        LastCell = null;
        
        // 注意：LogsManager 的字符串ID缓存是全局的，不需要重置
        // 这样可以保持字符串ID的一致性
    }

    /// <summary>
    /// 生成客户端ID
    /// </summary>
    private static int GenerateClientId()
    {
        return Interlocked.Increment(ref _clientIdCounter);
    }

    /// <summary>
    /// 生成日志ID
    /// </summary>
    private static int GenerateLogId()
    {
        return Interlocked.Increment(ref _logIdCounter);
    }

    #endregion

    #region 静态字段

    private static int _clientIdCounter = 0;
    private static int _logIdCounter = 0;

    #endregion

    #region 模型管理方法

    /// <summary>
    /// 模型提示信息
    /// </summary>
    private string? _modelHint;

    /// <summary>
    /// 传输方向
    /// </summary>
    public int TxDir { get; set; }

    /// <summary>
    /// 接收方向
    /// </summary>
    public int RxDir { get; set; }

    /// <summary>
    /// RAN ID列表
    /// </summary>
    public List<string> RanIds { get; set; } = new();

    /// <summary>
    /// 层方向配置
    /// </summary>
    private Dictionary<string, Dictionary<string, int>> _layerDir = new();

    /// <summary>
    /// 尝试模型提示
    /// </summary>
    /// <param name="models">模型列表</param>
    /// <returns>是否成功设置模型</returns>
    public bool TryModelHint(List<string> models)
    {
        if (string.IsNullOrEmpty(_modelHint))
            return false;

        foreach (var model in models)
        {
            if (_clientModelConfigs.TryGetValue(model, out var config))
            {
                var modelHint = config.ModelHint;
                if (string.IsNullOrEmpty(modelHint))
                {
                    // 没有提示，基于模型名称
                    modelHint = model;
                }

                if (Regex.IsMatch(_modelHint, modelHint, RegexOptions.IgnoreCase))
                {
                    return SetModel(model);
                }
            }
        }
        return false;
    }

    /// <summary>
    /// 设置模型
    /// </summary>
    /// <param name="model">模型名称</param>
    /// <param name="force">是否强制设置</param>
    /// <returns>是否成功设置</returns>
    public bool SetModel(string model, bool force = false)
    {
        // 如果模型相同且不强制，直接返回成功
        if (model == Config.Model && !force)
            return true;

        Config.Model = model;

        // 根据模型设置传输方向
        switch (model?.ToUpper())
        {
            case "ENB":
                TxDir = 2; // DIR_DL
                RxDir = 1; // DIR_UL
                RanIds.Clear();
                break;
            case "UE":
                TxDir = 1; // DIR_UL
                RxDir = 2; // DIR_DL
                break;
            default:
                break;
        }

        // 设置层方向配置
        if (_clientModelConfigs.TryGetValue(model ?? "", out var config))
        {
            _layerDir = config.LayerDir ?? new Dictionary<string, Dictionary<string, int>>();
        }
        else
        {
            _layerDir.Clear();
        }

        // 通知日志管理器更新网格列
        _lteLogs.GridColumnsUpdate();
        return true;
    }

    /// <summary>
    /// 设置模型提示
    /// </summary>
    /// <param name="hint">提示信息</param>
    public void SetModelHint(string hint)
    {
        _modelHint = hint;
    }

    #endregion

    #region 模型配置

    /// <summary>
    /// 客户端模型配置类
    /// </summary>
    public class ClientModelConfig
    {
        public string? Icon { get; set; }
        public string? ModelHint { get; set; }
        public string? Title { get; set; }
        public Dictionary<string, Dictionary<string, int>>? LayerDir { get; set; }
    }

    /// <summary>
    /// 客户端模型配置字典
    /// </summary>
    private static readonly Dictionary<string, ClientModelConfig> _clientModelConfigs = new()
    {
        { "RUE", new ClientModelConfig { Icon = "icon-ue2" } },
        { "UE", new ClientModelConfig { Icon = "icon-ue" } },
        { "PROBE", new ClientModelConfig() },
        { "ENB", new ClientModelConfig { Icon = "icon-air", ModelHint = "enb|gnb|bbu", Title = "RAN" } },
        { "N3IWF", new ClientModelConfig { Icon = "icon-air", ModelHint = "n3iwf", Title = "N3IWF" } },
        { "MME", new ClientModelConfig { Icon = "icon-server", ModelHint = "epc|mme|amf", Title = "CN" } },
        { "MBMSGW", new ClientModelConfig { Icon = "icon-download", ModelHint = "mbms" } },
        { "IMS", new ClientModelConfig { Icon = "icon-dial" } },
        { "MONITOR", new ClientModelConfig { Icon = "icon-monitor" } },
        { "LICENSE", new ClientModelConfig { Icon = "icon-file" } }
    };

    #endregion
}

/// <summary>
/// 客户端日志配置
/// </summary>
public class ClientLogsConfig
{
    /// <summary>
    /// 日志层配置
    /// </summary>
    public Dictionary<string, LogLayerConfig> Layers { get; set; } = new();

    /// <summary>
    /// 是否启用信号日志
    /// </summary>
    public bool? Signal { get; set; }

    /// <summary>
    /// 是否启用控制信道日志
    /// </summary>
    public bool? Cch { get; set; }

    // 允许其他未明确定义的属性
    [JsonExtensionData]
    public Dictionary<string, object>? ExtensionData { get; set; }
}

/// <summary>
/// 客户端配置
/// </summary>
public class ClientConfig
{
    /// <summary>
    /// 客户端名称
    /// </summary>
    public string Name { get; set; } = string.Empty;

    /// <summary>
    /// 服务器地址
    /// </summary>
    public string Address { get; set; } = string.Empty;

    /// <summary>
    /// 是否启用
    /// </summary>
    public bool Enabled { get; set; }

    /// <summary>
    /// 密码
    /// </summary>
    public string Password { get; set; } = string.Empty;

    /// <summary>
    /// 重连延迟（毫秒）
    /// </summary>
    public int ReconnectDelay { get; set; } = 5000;

    /// <summary>
    /// 是否启用SSL
    /// </summary>
    public bool Ssl { get; set; }

    /// <summary>
    /// 日志配置
    /// </summary>
    public ClientLogsConfig Logs { get; set; } = new();

    /// <summary>
    /// 是否暂停
    /// </summary>
    public bool Pause { get; set; }

    /// <summary>
    /// 是否只读
    /// </summary>
    public bool Readonly { get; set; }

    /// <summary>
    /// 是否跳过日志菜单
    /// </summary>
    public bool SkipLogMenu { get; set; }

    /// <summary>
    /// 是否锁定
    /// </summary>
    public bool Locked { get; set; }

    /// <summary>
    /// 是否激活
    /// </summary>
    public bool Active { get; set; }

    /// <summary>
    /// 模型
    /// </summary>
    public string? Model { get; set; }
}

/// <summary>
/// 客户端状态
/// </summary>
public enum ClientState
{
    Stop,
    Start,
    Loading,
    Connecting,
    Connected,
    Error,
    Destroy
}

/// <summary>
/// 帧信息
/// </summary>
public class FrameInfo
{
    public int Last { get; set; }
    public int Hfn { get; set; }
    public long Timestamp { get; set; } = -1;
}

/// <summary>
/// UE信息
/// </summary>
public class UEInfo
{
    public int UeId { get; set; }
    public string? Imsi { get; set; }
    public string? Imei { get; set; }
    public object? Caps { get; set; }
}