TestLogs/LTEMvcApp/Models/LTEClient.cs

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 = _lteLogs.GetLayerConfig();
            foreach (var layer in layerConfig.Keys)
            {
                _modelGuess[layer] = false;
            }
        }
    }

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

    /// <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;
            }
        }

        // 从 LogsManager 获取层配置
        var layerConfig = _lteLogs.GetLayerConfig();
        var modelList = new List<string> { "RUE", "UE", "PROBE", "ENB", "N3IWF", "MBMSGW", "MME", "IMS", "LICENSE", "MONITOR" };
        var availableModels = new List<string>(modelList);

        // 根据层配置过滤模型（与 JavaScript 版本保持一致）
        foreach (var layer in modelGuess.Keys)
        {
            if (!modelGuess[layer]) continue;

            if (layerConfig.TryGetValue(layer, out var config))
            {
                // 使用反射获取 dir 属性
                var configType = config.GetType();
                var dirProperty = configType.GetProperty("dir");
                if (dirProperty != null)
                {
                    var dir = dirProperty.GetValue(config) as Dictionary<string, int>;
                    if (dir != null)
                    {
                        // 移除不支持的模型（与 JavaScript 版本逻辑一致）
                        for (int j = 0; j < modelList.Count; j++)
                        {
                            var model = modelList[j];
                            if (!dir.ContainsKey(model))
                            {
                                var idx = availableModels.IndexOf(model);
                                if (idx >= 0)
                                    availableModels.RemoveAt(idx);
                            }
                        }
                    }
                }
            }

            // 如果只剩下一个模型，直接设置（与 JavaScript 版本一致）
            if (availableModels.Count < 2)
                break;
        }

        // 设置模型（与 JavaScript 版本一致）
        if (availableModels.Count > 0)
        {
            if (availableModels.Count == 1)
            {
                SetModel(availableModels[0]);
            }
            else
            {
                // 支持多个模型的情况，传递第一个模型
                SetModel(availableModels[0]);
            }
            _modelGuess = null; // 清除猜测字典
        }
    }

    /// <summary>
    /// 方向转换 - 对应JavaScript的_dirConvert方法
    /// </summary>
    /// <param name="log">日志对象</param>
    /// <returns>转换后的方向值</returns>
    public int DirConvert(LTELog log)
    {
        // 获取当前层的方向配置
        if (_layerDir.TryGetValue(log.Layer, out var layerDir))
        {
            // 根据日志的原始方向获取转换后的方向
            if (layerDir.TryGetValue(log.Direction.ToString(), out var convertedDir))
            {
                return convertedDir;
            }
        }
        return 0; // 默认返回0（DIR_NONE）
    }

    /// <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();
        }

        // 初始化层方向配置
        InitializeLayerDirectionConfig(model);

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

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

    /// <summary>
    /// 初始化层方向配置 - 对应JavaScript版本的层方向配置初始化
    /// </summary>
    /// <param name="model">模型名称</param>
    private void InitializeLayerDirectionConfig(string? model)
    {
        // 获取层配置
        var layerConfig = _lteLogs.GetLayerConfig();
        
        // 为每个层初始化默认方向配置
        foreach (var layer in layerConfig.Keys)
        {
            if (!_layerDir.ContainsKey(layer))
            {
                _layerDir[layer] = new Dictionary<string, int>
                {
                    { "UL", LogsManager.DIR_UL },
                    { "DL", LogsManager.DIR_DL },
                    { "FROM", LogsManager.DIR_DL },
                    { "TO", LogsManager.DIR_UL },
                    { "-", LogsManager.DIR_NONE }
                };
            }
        }

        // 根据模型设置特殊的方向配置（与 JavaScript 版本保持一致）
        switch (model?.ToUpper())
        {
            case "MME":
                // MME 模型特殊配置
                foreach (var layer in layerConfig.Keys)
                {
                    if (layer != "IMS" && layer != "CX" && layer != "RX" && 
                        layer != "S6" && layer != "S13" && layer != "SGsAP" && 
                        layer != "SBcAP" && layer != "N8" && layer != "N12" && 
                        layer != "N13" && layer != "N17" && layer != "N50" && 
                        layer != "MMS" && layer != "HTTP2" && layer != "LCSAP" && 
                        layer != "NL1" && layer != "GTPC")
                    {
                        if (_layerDir.ContainsKey(layer))
                        {
                            _layerDir[layer]["FROM"] = LogsManager.DIR_UL;
                            _layerDir[layer]["TO"] = LogsManager.DIR_DL;
                        }
                    }
                }
                break;

            case "IMS":
                // IMS 模型特殊配置
                foreach (var layer in layerConfig.Keys)
                {
                    if (_layerDir.ContainsKey(layer))
                    {
                        _layerDir[layer]["FROM"] = LogsManager.DIR_UL;
                        _layerDir[layer]["TO"] = LogsManager.DIR_DL;
                    }
                }
                break;

            case "N3IWF":
                // N3IWF 模型特殊配置
                if (_layerDir.ContainsKey("IKEV2"))
                {
                    _layerDir["IKEV2"]["FROM"] = LogsManager.DIR_UL;
                    _layerDir["IKEV2"]["TO"] = LogsManager.DIR_DL;
                }
                if (_layerDir.ContainsKey("IPSEC"))
                {
                    _layerDir["IPSEC"]["FROM"] = LogsManager.DIR_UL;
                    _layerDir["IPSEC"]["TO"] = LogsManager.DIR_DL;
                }
                break;

            case "ENB":
                // ENB 模型特殊配置
                if (_layerDir.ContainsKey("TRX"))
                {
                    _layerDir["TRX"]["FROM"] = LogsManager.DIR_UL;
                    _layerDir["TRX"]["TO"] = LogsManager.DIR_DL;
                }
                break;

            case "UE":
                // UE 模型特殊配置
                if (_layerDir.ContainsKey("GTPU"))
                {
                    _layerDir["GTPU"]["FROM"] = LogsManager.DIR_UL;
                    _layerDir["GTPU"]["TO"] = LogsManager.DIR_DL;
                }
                break;
        }
    }

    #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; }
}