using CapMachine.Wpf.CanDrive;
using CapMachine.Wpf.Services;
using Prism.Mvvm;
using System;
using System.ComponentModel;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace CapMachine.Wpf.CanDrive.ZlgCan
{
    /// <summary>
    /// 周立功 USBCANFD-200U 工程化封装（CAN/CANFD/LIN）。
    /// </summary>
    public sealed class ZlgCanFd200uDriver : BindableBase, IDisposable
    {
        private readonly object _sync = new object();
        private readonly ILogService _log;

        private static IntPtr _preloadedZlgcanHandle = IntPtr.Zero;
        private static string? _preloadedZlgcanError;

        private IntPtr _deviceHandle = IntPtr.Zero;
        private readonly IntPtr[] _canChannelHandles = new IntPtr[2];
        private IntPtr _linChannelHandle = IntPtr.Zero;

        private CancellationTokenSource? _recvCts;
        private Task? _recvTask;

        private volatile bool _disposed;

        private readonly object _dbcSync = new object();
        private ZlgDbcDatabase? _dbc;
        private ObservableCollection<CanDbcModel>? _dbcModels;
        private Dictionary<string, CanDbcModel>? _dbcModelIndex;

        private List<CanCmdData>? _cmdData;
        private int _cmdSendChannelIndex;
        private byte _cmdSendFrameType;

        /// <summary>
        /// 构造函数。
        /// </summary>
        /// <param name="logService">日志服务。</param>
        public ZlgCanFd200uDriver(ILogService logService)
        {
            _log = logService;
        }

        /// <summary>
        /// 安全关闭设备与通道（需在 _sync 锁内调用）。
        /// </summary>
        /// <remarks>
        /// - 该方法会尽力调用 Reset/Close，并在异常时记录日志且继续执行释放流程；
        /// - 该方法不会停止接收线程，调用方应优先 StopReceiveLoop。
        /// </remarks>

        private bool _openState;
        /// <summary>
        /// 设备打开状态。
        /// </summary>
        public bool OpenState
        {
            get { return _openState; }
            private set { _openState = value; RaisePropertyChanged(); }
        }

        private bool _isReceiving;
        /// <summary>
        /// 是否正在接收。
        /// </summary>
        public bool IsReceiving
        {
            get { return _isReceiving; }
            private set { _isReceiving = value; RaisePropertyChanged(); }
        }

        private bool _isSendOk;
        /// <summary>
        /// 最近是否发生过“发送成功”（用于 UI 指示灯）。
        /// </summary>
        public bool IsSendOk
        {
            get { return _isSendOk; }
            private set { _isSendOk = value; RaisePropertyChanged(); }
        }

        private bool _isReviceOk;
        /// <summary>
        /// 最近是否发生过“接收成功”（用于 UI 指示灯）。
        /// </summary>
        public bool IsReviceOk
        {
            get { return _isReviceOk; }
            private set { _isReviceOk = value; RaisePropertyChanged(); }
        }

        private int _sendOkToken;
        private int _reviceOkToken;

        private void MarkSendOk(int holdMs = 800)
        {
            var token = Interlocked.Increment(ref _sendOkToken);
            IsSendOk = true;
            Task.Run(async () =>
            {
                await Task.Delay(Math.Max(50, holdMs));
                if (token == _sendOkToken)
                {
                    IsSendOk = false;
                }
            });
        }

        private void MarkReviceOk(int holdMs = 800)
        {
            var token = Interlocked.Increment(ref _reviceOkToken);
            IsReviceOk = true;
            Task.Run(async () =>
            {
                await Task.Delay(Math.Max(50, holdMs));
                if (token == _reviceOkToken)
                {
                    IsReviceOk = false;
                }
            });
        }

        /// <summary>
        /// CAN/CANFD 原始帧接收事件。
        /// </summary>
        public event Action<ZlgCanRxFrame>? CanFrameReceived;

        /// <summary>
        /// LIN 原始帧接收事件。
        /// </summary>
        public event Action<ZlgLinRxFrame>? LinFrameReceived;

        private bool _dbcDecodeEnabled;
        /// <summary>
        /// 是否启用 DBC 解码更新（接收帧触发）。
        /// </summary>
        public bool DbcDecodeEnabled
        {
            get { return _dbcDecodeEnabled; }
            set { _dbcDecodeEnabled = value; RaisePropertyChanged(); }
        }

        private bool _isCycleSend;
        /// <summary>
        /// 是否启用“事件驱动发送”。
        /// </summary>
        /// <remarks>
        /// 与现有 ToomossCan/ToomossCanFD 行为对齐：只有 IsCycleSend=true 且 SchEnable=true 时，
        /// 才会在 CmdDataChanged 事件中触发增量下发。
        /// </remarks>
        public bool IsCycleSend
        {
            get { return _isCycleSend; }
            set { _isCycleSend = value; RaisePropertyChanged(); }
        }

        private bool _schEnable;
        /// <summary>
        /// 发送使能（与 UI 的调度表使能语义对齐）。
        /// </summary>
        public bool SchEnable
        {
            get { return _schEnable; }
            set { _schEnable = value; RaisePropertyChanged(); }
        }

        /// <summary>
        /// 打开设备（不初始化 CAN/LIN 通道）。
        /// </summary>
        /// <param name="deviceIndex">设备索引（通常 0）。</param>
        public void OpenDevice(uint deviceIndex)
        {
            ThrowIfDisposed();

            lock (_sync)
            {
                if (_deviceHandle != IntPtr.Zero)
                {
                    OpenState = true;
                    return;
                }

                EnsureNativeDllExists("zlgcan.dll");

                var deviceType = ZLGCAN.ZCAN_USBCANFD_200U;

                try
                {
                    _deviceHandle = ZLGCAN.ZCAN_OpenDevice(deviceType, deviceIndex, 0);
                }
                catch (Exception ex)
                {
                    var baseDir = AppContext.BaseDirectory;
                    var dllFullPath = Path.Combine(baseDir, "zlgcan.dll");
                    var msg = $"ZCAN_OpenDevice 调用异常。deviceType={deviceType}, deviceIndex={deviceIndex}, " +
                              $"Is64BitProcess={Environment.Is64BitProcess}, ProcessArch={RuntimeInformation.ProcessArchitecture}, " +
                              $"DllPath={dllFullPath}, BaseDir={baseDir}。异常：{ex.Message}";
                    _log.Error(msg);
                    throw new InvalidOperationException(msg, ex);
                }

                if (_deviceHandle == IntPtr.Zero)
                {
                    var lastError = Marshal.GetLastWin32Error();
                    var lastErrorMsg = string.Empty;
                    try
                    {
                        lastErrorMsg = new Win32Exception(lastError).Message;
                    }
                    catch
                    {
                    }

                    var baseDir = AppContext.BaseDirectory;
                    var dllFullPath = Path.Combine(baseDir, "zlgcan.dll");
                    var loadedModulePath = GetLoadedModulePath("zlgcan.dll") ?? string.Empty;
                    var depDiag = string.Join(" | ", new[]
                    {
                        BuildDllDiag(baseDir, "zlgcan.dll"),
                        BuildDllDiag(baseDir, "USB2XXX.dll"),
                        BuildDllDiag(baseDir, "libusb-1.0.dll"),
                        BuildDllDiag(baseDir, "zdbc.dll"),
                        BuildDllDiag(baseDir, "kerneldlls\\USBCANFD.dll"),
                        BuildDllDiag(baseDir, "kerneldlls\\CANDevCore.dll"),
                        BuildDllDiag(baseDir, "kerneldlls\\CANDevice.dll"),
                        BuildDllDiag(baseDir, "kerneldlls\\CANFDCOM.dll"),
                        BuildDllDiag(baseDir, "kerneldlls\\CANFDNET.dll"),
                        BuildDllDiag(baseDir, "kerneldlls\\ZPSCANFD.dll"),
                        BuildDllDiag(baseDir, "kerneldlls\\USBCANFD800U.dll"),
                        BuildDllDiag(baseDir, "kerneldlls\\USBCAN.dll"),
                        BuildDllDiag(baseDir, "kerneldlls\\usbcan.dll"),
                    }.Where(s => !string.IsNullOrWhiteSpace(s)));
                    string dllVer = string.Empty;
                    try
                    {
                        if (File.Exists(dllFullPath))
                        {
                            var vi = FileVersionInfo.GetVersionInfo(dllFullPath);
                            dllVer = vi?.FileVersion ?? string.Empty;
                        }
                    }
                    catch
                    {
                    }

                    var msg = $"ZCAN_OpenDevice 失败。deviceType={deviceType}, deviceIndex={deviceIndex}。" +
                              $"Win32LastError={lastError}(0x{lastError:X}){(string.IsNullOrWhiteSpace(lastErrorMsg) ? string.Empty : $"({lastErrorMsg})")}。" +
                              $"Is64BitProcess={Environment.Is64BitProcess}, ProcessArch={RuntimeInformation.ProcessArchitecture}。" +
                              $"DllPath={dllFullPath}, DllVersion={dllVer}, LoadedModulePath={loadedModulePath}, BaseDir={baseDir}。" +
                              $"PreloadError={_preloadedZlgcanError ?? string.Empty}。" +
                              $"DirDllDiag={depDiag}。" +
                              "请确认：1) 已安装ZLG驱动；2) 设备已连接且未被其它程序占用；3) 程序位数与 zlgcan.dll 匹配；4) 设备类型/索引正确。";

                    _log.Error(msg);
                    throw new InvalidOperationException(msg);
                }

                OpenState = true;
            }
        }

        /// <summary>
        /// 预加载指定路径的原生 DLL，尽量避免被 PATH 中的同名 DLL 干扰。
        /// </summary>
        /// <param name="dllFullPath">DLL 完整路径。</param>
        private static void TryPreloadNativeDll(string dllFullPath)
        {
            try
            {
                if (_preloadedZlgcanHandle != IntPtr.Zero)
                {
                    return;
                }

                if (!string.IsNullOrWhiteSpace(_preloadedZlgcanError))
                {
                    return;
                }

                _preloadedZlgcanHandle = NativeLibrary.Load(dllFullPath);
            }
            catch (Exception ex)
            {
                _preloadedZlgcanError = $"{ex.GetType().Name}: {ex.Message}";
            }
        }

        /// <summary>
        /// 构造输出目录下某个 DLL 的诊断信息（架构/大小/版本）。
        /// </summary>
        /// <param name="baseDir">输出目录。</param>
        /// <param name="fileName">DLL 文件名。</param>
        /// <returns>诊断信息字符串；不存在返回 "xxx:not_found"；异常返回 null。</returns>
        private static string? BuildDllDiag(string baseDir, string fileName)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(baseDir) || string.IsNullOrWhiteSpace(fileName))
                {
                    return null;
                }

                var full = Path.Combine(baseDir, fileName);
                if (!File.Exists(full))
                {
                    return $"{fileName}:not_found";
                }

                var arch = TryGetPeArchitecture(full) ?? string.Empty;
                long size = 0;
                try
                {
                    size = new FileInfo(full).Length;
                }
                catch
                {
                }

                var ver = string.Empty;
                try
                {
                    var vi = FileVersionInfo.GetVersionInfo(full);
                    ver = vi?.FileVersion ?? string.Empty;
                }
                catch
                {
                }

                return $"{fileName}:arch={arch},size={size},ver={ver}";
            }
            catch
            {
                return null;
            }
        }

        /// <summary>
        /// 获取当前进程中已加载模块的完整路径。
        /// </summary>
        /// <param name="moduleFileName">模块文件名（如 zlgcan.dll）。</param>
        /// <returns>完整路径；获取失败返回 null。</returns>
        private static string? GetLoadedModulePath(string moduleFileName)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(moduleFileName))
                {
                    return null;
                }

                using var p = Process.GetCurrentProcess();
                foreach (ProcessModule m in p.Modules)
                {
                    if (string.Equals(m.ModuleName, moduleFileName, StringComparison.OrdinalIgnoreCase))
                    {
                        return m.FileName;
                    }
                }

                return null;
            }
            catch
            {
                return null;
            }
        }

        /// <summary>
        /// 打开设备并初始化 CANFD 通道。
        /// </summary>
        /// <param name="deviceIndex">设备索引（通常 0）。</param>
        /// <param name="channel0">通道0配置。</param>
        /// <param name="channel1">通道1配置（可为 null 表示不初始化）。</param>
        public void OpenAndInitCan(uint deviceIndex, ZlgCanFdChannelOptions channel0, ZlgCanFdChannelOptions? channel1 = null)
        {
            ThrowIfDisposed();

            lock (_sync)
            {
                if (_deviceHandle == IntPtr.Zero)
                {
                    OpenDevice(deviceIndex);
                }

                try
                {
                    InitCanChannelInternal(0, channel0);
                    _canChannelHandles[0] = StartCanChannelInternal(0);

                    if (channel1 != null)
                    {
                        InitCanChannelInternal(1, channel1);
                        _canChannelHandles[1] = StartCanChannelInternal(1);
                    }

                    // 合并接收：这是设备级能力，按通道0的配置为准（两通道同时开启/关闭）
                    var mergeEnable = channel0.EnableMergeReceive;
                    var mergeRet = ZLGCAN.ZCAN_SetValue(_deviceHandle, "0/set_device_recv_merge", mergeEnable ? "1" : "0");
                    if (mergeRet != 1)
                    {
                        _log.Warn("设置合并接收失败（0/set_device_recv_merge）。将继续运行，但接收模式可能不符合预期。");
                    }
                }
                catch
                {
                    SafeClose_NoLock();
                    throw;
                }
            }
        }

        /// <summary>
        /// 初始化并启动 LIN 通道。
        /// </summary>
        /// <param name="linIndex">LIN 通道索引（通常 0）。</param>
        /// <param name="options">LIN 初始化参数。</param>
        public void OpenAndInitLin(uint linIndex, ZlgLinChannelOptions options)
        {
            ThrowIfDisposed();

            lock (_sync)
            {
                if (_deviceHandle == IntPtr.Zero)
                {
                    OpenDevice(0);
                }

                if (_linChannelHandle != IntPtr.Zero)
                {
                    throw new InvalidOperationException("LIN 通道已初始化。");
                }

                var cfg = new ZLGCAN.ZCAN_LIN_INIT_CONFIG
                {
                    linMode = (byte)(options.IsMaster ? 1 : 0),
                    chkSumMode = options.ChecksumMode,
                    maxLength = options.MaxLength,
                    reserved = 0,
                    libBaud = options.BaudRate
                };

                IntPtr pCfg = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ZLGCAN.ZCAN_LIN_INIT_CONFIG)));
                try
                {
                    Marshal.StructureToPtr(cfg, pCfg, false);
                    _linChannelHandle = ZLGCAN.ZCAN_InitLIN(_deviceHandle, linIndex, pCfg);
                }
                finally
                {
                    Marshal.FreeHGlobal(pCfg);
                }

                if (_linChannelHandle == IntPtr.Zero)
                {
                    throw new InvalidOperationException("ZCAN_InitLIN 失败。");
                }

                var ret = ZLGCAN.ZCAN_StartLIN(_linChannelHandle);
                if (ret != 1)
                {
                    throw new InvalidOperationException("ZCAN_StartLIN 失败。");
                }
            }
        }

        /// <summary>
        /// 启动后台接收线程。
        /// </summary>
        /// <param name="mergeReceive">是否启用合并接收（ZCAN_ReceiveData）。建议与通道初始化时的 EnableMergeReceive 保持一致。</param>
        /// <param name="bufferFrames">接收缓冲最大帧数（合并接收固定数组大小，过小会丢帧）。</param>
        public void StartReceiveLoop(bool mergeReceive, int bufferFrames = 100)
        {
            ThrowIfDisposed();

            lock (_sync)
            {
                if (_deviceHandle == IntPtr.Zero)
                {
                    throw new InvalidOperationException("设备未打开。");
                }

                if (_recvTask != null)
                {
                    throw new InvalidOperationException("接收线程已启动。");
                }

                if (bufferFrames <= 0) bufferFrames = 1;

                _recvCts = new CancellationTokenSource();
                var token = _recvCts.Token;

                _recvTask = Task.Run(() =>
                {
                    IsReceiving = true;
                    try
                    {
                        if (mergeReceive)
                        {
                            ReceiveLoop_Merge(token, bufferFrames);
                        }
                        else
                        {
                            ReceiveLoop_PerChannel(token, bufferFrames);
                        }
                    }
                    catch (Exception ex)
                    {
                        _log.Error($"ZLG 接收线程异常退出：{ex.Message}");
                    }
                    finally
                    {
                        IsReceiving = false;
                    }
                }, token);
            }
        }

        /// <summary>
        /// 加载 DBC 文件，并生成 UI 绑定用的信号集合。
        /// </summary>
        /// <param name="dbcPath">DBC 文件路径。</param>
        /// <param name="enableAsyncAnalyse">是否启用异步解析。</param>
        /// <param name="merge">是否合并加载。</param>
        /// <param name="protocolType">协议类型。</param>
        /// <returns>CanDbcModel 集合。</returns>
        public ObservableCollection<CanDbcModel> StartDbc(string dbcPath, bool enableAsyncAnalyse = true, bool merge = false, byte protocolType = ZDBC.PROTOCOL_OTHER)
        {
            ThrowIfDisposed();

            lock (_dbcSync)
            {
                _dbc?.Dispose();
                _dbc = new ZlgDbcDatabase(_log);
                _dbc.Load(dbcPath, enableAsyncAnalyse, merge, protocolType);

                _dbcModels = _dbc.BuildCanDbcModels();
                _dbcModelIndex = BuildDbcModelIndex(_dbcModels);

                DbcDecodeEnabled = true;

                return _dbcModels;
            }
        }

        /// <summary>
        /// 设置并订阅要发送的指令集合（事件驱动）。
        /// </summary>
        /// <param name="cmdData">指令集合。</param>
        /// <param name="channelIndex">发送通道（0/1）。</param>
        /// <param name="frameType">帧类型：ZDBC.FT_CAN 或 ZDBC.FT_CANFD。</param>
        public void LoadCmdDataToDrive(List<CanCmdData> cmdData, int channelIndex, byte frameType)
        {
            ThrowIfDisposed();

            lock (_dbcSync)
            {
                if (_cmdData != null)
                {
                    foreach (var old in _cmdData)
                    {
                        old.CanCmdDataChangedHandler -= CmdData_CanCmdDataChangedHandler;
                    }
                }

                _cmdData = cmdData;
                _cmdSendChannelIndex = channelIndex;
                _cmdSendFrameType = frameType;

                if (_cmdData != null)
                {
                    foreach (var item in _cmdData)
                    {
                        item.CanCmdDataChangedHandler += CmdData_CanCmdDataChangedHandler;
                    }
                }
            }
        }

        /// <summary>
        /// 事件驱动回调：某个 MsgName 的信号值变更时，仅增量编码并下发该消息。
        /// </summary>
        /// <param name="sender">发送方。</param>
        /// <param name="msgName">发生变化的消息名称。</param>
        private void CmdData_CanCmdDataChangedHandler(object? sender, string msgName)
        {
            try
            {
                if (!IsCycleSend) return;
                if (!SchEnable) return;

                SendOneMsgByCmdData(msgName, _cmdSendChannelIndex, _cmdSendFrameType);
            }
            catch (Exception ex)
            {
                _log.Warn($"事件驱动发送异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 根据 MsgName，从当前 CmdData 中取出信号值，编码并发送一帧。
        /// </summary>
        /// <param name="msgName">消息名称。</param>
        /// <param name="channelIndex">发送通道。</param>
        /// <param name="frameType">帧类型：ZDBC.FT_CAN 或 ZDBC.FT_CANFD。</param>
        public void SendOneMsgByCmdData(string msgName, int channelIndex, byte frameType)
        {
            ThrowIfDisposed();

            ZlgDbcDatabase? dbc;
            List<CanCmdData>? cmdData;
            lock (_dbcSync)
            {
                dbc = _dbc;
                cmdData = _cmdData;
            }

            if (dbc == null || !dbc.IsLoaded)
            {
                return;
            }

            if (cmdData == null || cmdData.Count == 0)
            {
                return;
            }

            if (string.IsNullOrWhiteSpace(msgName))
            {
                return;
            }

            var dict = new Dictionary<string, double>(StringComparer.Ordinal);
            foreach (var item in cmdData)
            {
                if (!string.Equals(item.MsgName, msgName, StringComparison.Ordinal))
                {
                    continue;
                }

                if (string.IsNullOrWhiteSpace(item.SignalName))
                {
                    continue;
                }

                dict[item.SignalName] = item.SignalCmdValue;
            }

            if (dict.Count == 0)
            {
                return;
            }

            var (canId, data, dataLen) = dbc.EncodeToRawFrame(msgName, dict, frameType);
            if (frameType == ZDBC.FT_CAN)
            {
                SendCan(channelIndex, canId, data, requestTxEcho: true);
                return;
            }

            if (frameType == ZDBC.FT_CANFD)
            {
                SendCanFd(channelIndex, canId, data, requestTxEcho: true);
                return;
            }

            throw new ArgumentOutOfRangeException(nameof(frameType), "frameType 仅支持 ZDBC.FT_CAN=0 或 ZDBC.FT_CANFD=1。");
        }

        /// <summary>
        /// 停止后台接收线程。
        /// </summary>
        public void StopReceiveLoop()
        {
            lock (_sync)
            {
                if (_recvCts == null || _recvTask == null)
                {
                    return;
                }

                try
                {
                    _recvCts.Cancel();
                    _recvTask.Wait(TimeSpan.FromSeconds(2));
                }
                catch (Exception ex)
                {
                    _log.Warn($"停止接收线程等待超时或异常：{ex.Message}");
                }
                finally
                {
                    _recvCts.Dispose();
                    _recvCts = null;
                    _recvTask = null;
                }
            }
        }

        /// <summary>
        /// 发送 CAN 报文。
        /// </summary>
        /// <param name="channelIndex">通道索引（0/1）。</param>
        /// <param name="canId">包含扩展帧标志位的 can_id（可用 ZlgCanIdHelper.MakeCanId 生成）。</param>
        /// <param name="data">数据（0~8字节）。</param>
        /// <param name="requestTxEcho">是否请求发送回显。</param>
        /// <param name="transmitType">发送方式，0=正常发送，1=单次发送，2=自发自收，3=单次自发自收。</param>
        public uint SendCan(int channelIndex, uint canId, byte[] data, bool requestTxEcho = false, uint transmitType = 0)
        {
            ThrowIfDisposed();
            var chn = GetCanChannelHandleOrThrow(channelIndex);

            var frame = new ZLGCAN.can_frame
            {
                can_id = canId,
                can_dlc = (byte)Math.Min(8, data?.Length ?? 0),
                __pad = 0,
                __res0 = 0,
                __res1 = 0,
                data = new byte[8]
            };

            if (data != null && data.Length > 0)
            {
                Array.Copy(data, frame.data, Math.Min(8, data.Length));
            }

            if (requestTxEcho)
            {
                frame.__pad |= 0x20;
            }

            var tx = new ZLGCAN.ZCAN_Transmit_Data
            {
                frame = frame,
                transmit_type = transmitType
            };

            IntPtr pTx = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ZLGCAN.ZCAN_Transmit_Data)));
            try
            {
                Marshal.StructureToPtr(tx, pTx, false);
                var ret = ZLGCAN.ZCAN_Transmit(chn, pTx, 1);
                if (ret > 0)
                {
                    MarkSendOk();
                }
                return ret;
            }
            finally
            {
                Marshal.FreeHGlobal(pTx);
            }
        }

        /// <summary>
        /// 发送 CANFD 报文。
        /// </summary>
        /// <param name="channelIndex">通道索引（0/1）。</param>
        /// <param name="canId">包含扩展帧标志位的 can_id（可用 ZlgCanIdHelper.MakeCanId 生成）。</param>
        /// <param name="data">数据（0~64字节）。</param>
        /// <param name="requestTxEcho">是否请求发送回显。</param>
        /// <param name="transmitType">发送方式，0=正常发送，1=单次发送，2=自发自收，3=单次自发自收。</param>
        public uint SendCanFd(int channelIndex, uint canId, byte[] data, bool requestTxEcho = false, uint transmitType = 0)
        {
            ThrowIfDisposed();
            var chn = GetCanChannelHandleOrThrow(channelIndex);

            var len = (byte)Math.Min(64, data?.Length ?? 0);
            var frame = new ZLGCAN.canfd_frame
            {
                can_id = canId,
                len = len,
                flags = 0,
                __res0 = 0,
                __res1 = 0,
                data = new byte[64]
            };

            if (data != null && data.Length > 0)
            {
                Array.Copy(data, frame.data, Math.Min(64, data.Length));
            }

            if (requestTxEcho)
            {
                frame.flags |= 0x20;
            }

            var tx = new ZLGCAN.ZCAN_TransmitFD_Data
            {
                frame = frame,
                transmit_type = transmitType
            };

            IntPtr pTx = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ZLGCAN.ZCAN_TransmitFD_Data)));
            try
            {
                Marshal.StructureToPtr(tx, pTx, false);
                var ret = ZLGCAN.ZCAN_TransmitFD(chn, pTx, 1);
                if (ret > 0)
                {
                    MarkSendOk();
                }
                return ret;
            }
            finally
            {
                Marshal.FreeHGlobal(pTx);
            }
        }

        /// <summary>
        /// 设置设备定时发送（CAN）。
        /// </summary>
        /// <param name="channelIndex">通道索引。</param>
        /// <param name="taskIndex">定时任务索引。</param>
        /// <param name="enable">是否使能。</param>
        /// <param name="intervalMs">周期（ms）。</param>
        /// <param name="canId">can_id。</param>
        /// <param name="data">数据（0~8）。</param>
        public void ConfigureAutoSendCan(int channelIndex, ushort taskIndex, bool enable, uint intervalMs, uint canId, byte[] data)
        {
            ThrowIfDisposed();

            if (_deviceHandle == IntPtr.Zero)
            {
                throw new InvalidOperationException("设备未打开。");
            }

            var frame = new ZLGCAN.can_frame
            {
                can_id = canId,
                can_dlc = (byte)Math.Min(8, data?.Length ?? 0),
                __pad = 0x20, // 默认发送回显
                __res0 = 0,
                __res1 = 0,
                data = new byte[8]
            };

            if (data != null && data.Length > 0)
            {
                Array.Copy(data, frame.data, Math.Min(8, data.Length));
            }

            var obj = new ZLGCAN.ZCAN_AUTO_TRANSMIT_OBJ
            {
                enable = (ushort)(enable ? 1 : 0),
                index = taskIndex,
                interval = intervalMs,
                obj = new ZLGCAN.ZCAN_Transmit_Data { frame = frame, transmit_type = 0 }
            };

            var path = string.Format("{0}/auto_send", channelIndex);
            var ret = ZLGCAN.ZCAN_SetValue(_deviceHandle, path, ref obj);
            if (ret != 1)
            {
                throw new InvalidOperationException($"配置定时发送失败：{path}");
            }
        }

        /// <summary>
        /// 启动通道定时发送任务（apply_auto_send）。
        /// </summary>
        /// <param name="channelIndex">通道索引。</param>
        public void ApplyAutoSend(int channelIndex)
        {
            ThrowIfDisposed();
            if (_deviceHandle == IntPtr.Zero) throw new InvalidOperationException("设备未打开。");

            var path = string.Format("{0}/apply_auto_send", channelIndex);
            var ret = ZLGCAN.ZCAN_SetValue(_deviceHandle, path, "0");
            if (ret != 1)
            {
                throw new InvalidOperationException($"启动定时发送失败：{path}");
            }
        }

        /// <summary>
        /// 清空通道定时发送任务（clear_auto_send）。
        /// </summary>
        /// <param name="channelIndex">通道索引。</param>
        public void ClearAutoSend(int channelIndex)
        {
            ThrowIfDisposed();
            if (_deviceHandle == IntPtr.Zero) throw new InvalidOperationException("设备未打开。");

            var path = string.Format("{0}/clear_auto_send", channelIndex);
            var ret = ZLGCAN.ZCAN_SetValue(_deviceHandle, path, "0");
            if (ret != 1)
            {
                throw new InvalidOperationException($"清空定时发送失败：{path}");
            }
        }

        /// <summary>
        /// 配置 LIN 发布表。
        /// </summary>
        /// <param name="publishCfg">发布配置集合。</param>
        public void SetLinPublish(IEnumerable<ZLGCAN.ZCAN_LIN_PUBLISH_CFG> publishCfg)
        {
            ThrowIfDisposed();
            if (_linChannelHandle == IntPtr.Zero) throw new InvalidOperationException("LIN 未初始化。");

            var list = publishCfg?.ToList() ?? new List<ZLGCAN.ZCAN_LIN_PUBLISH_CFG>();
            if (list.Count == 0)
            {
                return;
            }

            int size = Marshal.SizeOf(typeof(ZLGCAN.ZCAN_LIN_PUBLISH_CFG));
            IntPtr pArr = Marshal.AllocHGlobal(size * list.Count);
            try
            {
                for (int i = 0; i < list.Count; i++)
                {
                    var item = list[i];
                    if (item.data == null || item.data.Length != 8)
                    {
                        item.data = new byte[8];
                    }

                    if (item.reserved == null || item.reserved.Length != 5)
                    {
                        item.reserved = new byte[5];
                    }

                    Marshal.StructureToPtr(item, IntPtr.Add(pArr, i * size), false);
                }

                var ret = ZLGCAN.ZCAN_SetLINPublish(_linChannelHandle, pArr, (uint)list.Count);
                if (ret != 1)
                {
                    throw new InvalidOperationException("ZCAN_SetLINPublish 失败。");
                }
            }
            finally
            {
                Marshal.FreeHGlobal(pArr);
            }
        }

        /// <summary>
        /// 配置 LIN 订阅表。
        /// </summary>
        /// <param name="subscribeCfg">订阅配置集合。</param>
        public void SetLinSubscribe(IEnumerable<ZLGCAN.ZCAN_LIN_SUBSCIBE_CFG> subscribeCfg)
        {
            ThrowIfDisposed();
            if (_linChannelHandle == IntPtr.Zero) throw new InvalidOperationException("LIN 未初始化。");

            var list = subscribeCfg?.ToList() ?? new List<ZLGCAN.ZCAN_LIN_SUBSCIBE_CFG>();
            if (list.Count == 0)
            {
                return;
            }

            int size = Marshal.SizeOf(typeof(ZLGCAN.ZCAN_LIN_SUBSCIBE_CFG));
            IntPtr pArr = Marshal.AllocHGlobal(size * list.Count);
            try
            {
                for (int i = 0; i < list.Count; i++)
                {
                    var item = list[i];
                    if (item.reserved == null || item.reserved.Length != 5)
                    {
                        item.reserved = new byte[5];
                    }
                    Marshal.StructureToPtr(item, IntPtr.Add(pArr, i * size), false);
                }

                var ret = ZLGCAN.ZCAN_SetLINSubscribe(_linChannelHandle, pArr, (uint)list.Count);
                if (ret != 1)
                {
                    throw new InvalidOperationException("ZCAN_SetLINSubscribe 失败。");
                }
            }
            finally
            {
                Marshal.FreeHGlobal(pArr);
            }
        }

        /// <summary>
        /// 关闭设备。
        /// </summary>
        public void Close()
        {
            lock (_sync)
            {
                StopReceiveLoop();
                SafeClose_NoLock();
            }

            lock (_dbcSync)
            {
                if (_cmdData != null)
                {
                    foreach (var item in _cmdData)
                    {
                        item.CanCmdDataChangedHandler -= CmdData_CanCmdDataChangedHandler;
                    }
                }

                _cmdData = null;

                _dbcModels = null;
                _dbcModelIndex = null;

                _dbc?.Dispose();
                _dbc = null;
            }
        }

        /// <inheritdoc />
        public void Dispose()
        {
            if (_disposed) return;
            _disposed = true;

            try
            {
                Close();
            }
            catch
            {
                // ignored
            }
        }

        private void SafeClose_NoLock()
        {
            try
            {
                if (_linChannelHandle != IntPtr.Zero)
                {
                    var ret = ZLGCAN.ZCAN_ResetLIN(_linChannelHandle);
                    if (ret != 1)
                    {
                        _log.Warn("ZCAN_ResetLIN 失败。");
                    }
                }
            }
            catch (Exception ex)
            {
                _log.Warn($"关闭 LIN 异常：{ex.Message}");
            }
            finally
            {
                _linChannelHandle = IntPtr.Zero;
            }

            for (int i = 0; i < _canChannelHandles.Length; i++)
            {
                try
                {
                    if (_canChannelHandles[i] != IntPtr.Zero)
                    {
                        var ret = ZLGCAN.ZCAN_ResetCAN(_canChannelHandles[i]);
                        if (ret != 1)
                        {
                            _log.Warn($"ZCAN_ResetCAN 失败，通道{i}。");
                        }
                    }
                }
                catch (Exception ex)
                {
                    _log.Warn($"关闭 CAN 通道{i}异常：{ex.Message}");
                }
                finally
                {
                    _canChannelHandles[i] = IntPtr.Zero;
                }
            }

            try
            {
                if (_deviceHandle != IntPtr.Zero)
                {
                    var ret = ZLGCAN.ZCAN_CloseDevice(_deviceHandle);
                    if (ret != 1)
                    {
                        _log.Warn("ZCAN_CloseDevice 失败。");
                    }
                }
            }
            catch (Exception ex)
            {
                _log.Warn($"关闭设备异常：{ex.Message}");
            }
            finally
            {
                _deviceHandle = IntPtr.Zero;
                OpenState = false;
            }
        }

        /// <summary>
        /// 初始化指定 CANFD 通道（仅设置参数并 InitCAN，不负责 StartCAN）。
        /// </summary>
        /// <param name="chnIdx">通道索引。</param>
        /// <param name="options">通道初始化参数。</param>

        private void InitCanChannelInternal(int chnIdx, ZlgCanFdChannelOptions options)
        {
            var path = string.Format("{0}/canfd_abit_baud_rate", chnIdx);
            var ret = ZLGCAN.ZCAN_SetValue(_deviceHandle, path, options.ArbitrationBaudRate.ToString());
            if (ret != 1)
            {
                throw new InvalidOperationException($"设置仲裁域波特率失败：{path}");
            }

            path = string.Format("{0}/canfd_dbit_baud_rate", chnIdx);
            ret = ZLGCAN.ZCAN_SetValue(_deviceHandle, path, options.DataBaudRate.ToString());
            if (ret != 1)
            {
                throw new InvalidOperationException($"设置数据域波特率失败：{path}");
            }

            path = string.Format("{0}/initenal_resistance", chnIdx);
            ret = ZLGCAN.ZCAN_SetValue(_deviceHandle, path, options.EnableInternalResistance ? "1" : "0");
            if (ret != 1)
            {
                throw new InvalidOperationException($"设置终端电阻失败：{path}");
            }

            if (options.EnableBusUsage)
            {
                path = string.Format("{0}/set_bus_usage_enable", chnIdx);
                ret = ZLGCAN.ZCAN_SetValue(_deviceHandle, path, "1");
                if (ret != 1)
                {
                    _log.Warn($"启用总线利用率失败：{path}");
                }

                path = string.Format("{0}/set_bus_usage_period", chnIdx);
                ret = ZLGCAN.ZCAN_SetValue(_deviceHandle, path, options.BusUsagePeriodMs.ToString());
                if (ret != 1)
                {
                    _log.Warn($"设置总线利用率周期失败：{path}");
                }
            }

            var initCfg = new ZLGCAN.ZCAN_CHANNEL_INIT_CONFIG
            {
                can_type = 1,
                config = new ZLGCAN._ZCAN_CHANNEL_INIT_CONFIG
                {
                    canfd = new ZLGCAN._ZCAN_CHANNEL_CANFD_INIT_CONFIG
                    {
                        acc_code = 0,
                        acc_mask = 0xFFFFFFFF,
                        abit_timing = 0,
                        dbit_timing = 0,
                        brp = 0,
                        filter = 0,
                        mode = (byte)(options.ListenOnly ? 1 : 0),
                        pad = 0,
                        reserved = 0
                    }
                }
            };

            var chnHandle = ZLGCAN.ZCAN_InitCAN(_deviceHandle, (uint)chnIdx, ref initCfg);
            if (chnHandle == IntPtr.Zero)
            {
                throw new InvalidOperationException($"初始化 CANFD 通道失败：{chnIdx}");
            }

            _canChannelHandles[chnIdx] = chnHandle;
        }

        /// <summary>
        /// 启动指定 CAN 通道。
        /// </summary>
        /// <param name="chnIdx">通道索引。</param>
        /// <returns>通道句柄。</returns>

        private IntPtr StartCanChannelInternal(int chnIdx)
        {
            var h = _canChannelHandles[chnIdx];
            if (h == IntPtr.Zero)
            {
                throw new InvalidOperationException("CAN 通道句柄为空。");
            }

            var ret = ZLGCAN.ZCAN_StartCAN(h);
            if (ret != 1)
            {
                throw new InvalidOperationException($"启动 CAN 通道失败：{chnIdx}");
            }

            return h;
        }

        /// <summary>
        /// 获取 CAN 通道句柄（不存在则抛异常）。
        /// </summary>
        /// <param name="channelIndex">通道索引。</param>
        /// <returns>通道句柄。</returns>

        private IntPtr GetCanChannelHandleOrThrow(int channelIndex)
        {
            if (channelIndex < 0 || channelIndex >= _canChannelHandles.Length)
            {
                throw new ArgumentOutOfRangeException(nameof(channelIndex));
            }

            var h = _canChannelHandles[channelIndex];
            if (h == IntPtr.Zero)
            {
                throw new InvalidOperationException($"CAN 通道{channelIndex}未初始化。");
            }

            return h;
        }

        /// <summary>
        /// 普通接收模式：按通道轮询 CAN/CANFD 缓冲区读取。
        /// </summary>
        /// <param name="token">取消令牌。</param>
        /// <param name="bufferFrames">每次接收的最大帧数。</param>

        private void ReceiveLoop_PerChannel(CancellationToken token, int bufferFrames)
        {
            const int WaitMs = 10;

            int canStructSize = Marshal.SizeOf(typeof(ZLGCAN.ZCAN_Receive_Data));
            int canfdStructSize = Marshal.SizeOf(typeof(ZLGCAN.ZCAN_ReceiveFD_Data));

            IntPtr pCanBuffer = Marshal.AllocHGlobal(canStructSize * bufferFrames);
            IntPtr pCanfdBuffer = Marshal.AllocHGlobal(canfdStructSize * bufferFrames);

            try
            {
                while (!token.IsCancellationRequested)
                {
                    for (int ch = 0; ch < _canChannelHandles.Length; ch++)
                    {
                        var handle = _canChannelHandles[ch];
                        if (handle == IntPtr.Zero) continue;

                        uint canNum = ZLGCAN.ZCAN_GetReceiveNum(handle, 0);
                        if (canNum > 0)
                        {
                            uint actual = ZLGCAN.ZCAN_Receive(handle, pCanBuffer, (uint)bufferFrames, WaitMs);
                            for (int i = 0; i < actual; i++)
                            {
                                IntPtr pCur = IntPtr.Add(pCanBuffer, i * canStructSize);
                                var rec = Marshal.PtrToStructure<ZLGCAN.ZCAN_Receive_Data>(pCur);
                                RaiseCanFrame(ch, rec.timestamp, false, rec.frame.can_id, rec.frame.data, rec.frame.can_dlc, (rec.frame.__pad & 0x20) == 0x20);
                            }
                        }

                        uint canfdNum = ZLGCAN.ZCAN_GetReceiveNum(handle, 1);
                        if (canfdNum > 0)
                        {
                            uint actual = ZLGCAN.ZCAN_ReceiveFD(handle, pCanfdBuffer, (uint)bufferFrames, WaitMs);
                            for (int i = 0; i < actual; i++)
                            {
                                IntPtr pCur = IntPtr.Add(pCanfdBuffer, i * canfdStructSize);
                                var rec = Marshal.PtrToStructure<ZLGCAN.ZCAN_ReceiveFD_Data>(pCur);
                                RaiseCanFrame(ch, rec.timestamp, true, rec.frame.can_id, rec.frame.data, rec.frame.len, (rec.frame.flags & 0x20) == 0x20);
                            }
                        }

                        ZLGCAN.ZCAN_CHANNEL_ERR_INFO err = new ZLGCAN.ZCAN_CHANNEL_ERR_INFO
                        {
                            error_code = 0,
                            passive_ErrData = new byte[3],
                            arLost_ErrData = 0
                        };

                        try
                        {
                            ZLGCAN.ZCAN_ReadChannelErrInfo(handle, ref err);
                            if (err.error_code != 0)
                            {
                                _log.Warn($"CAN通道{ch}错误码：0x{err.error_code:X}");
                            }
                        }
                        catch
                        {
                            // ignore
                        }
                    }

                    Thread.Sleep(10);
                }
            }
            finally
            {
                Marshal.FreeHGlobal(pCanfdBuffer);
                Marshal.FreeHGlobal(pCanBuffer);
            }
        }

        /// <summary>
        /// 合并接收模式：通过设备级 API（ZCAN_ReceiveData）统一接收 CAN/CANFD/LIN。
        /// </summary>
        /// <param name="token">取消令牌。</param>
        /// <param name="bufferFrames">接收缓存容量。</param>

        private void ReceiveLoop_Merge(CancellationToken token, int bufferFrames)
        {
            int dataObjSize = Marshal.SizeOf(typeof(ZLGCAN.ZCANDataObj));
            int canfdSize = Marshal.SizeOf(typeof(ZLGCAN.ZCANCANFDData));
            int linSize = Marshal.SizeOf(typeof(ZLGCAN.ZCANLINData));

            IntPtr pDataObjs = Marshal.AllocHGlobal(dataObjSize * bufferFrames);
            IntPtr pCanfdBuffer = Marshal.AllocHGlobal(canfdSize);
            IntPtr pLinBuffer = Marshal.AllocHGlobal(linSize);

            try
            {
                while (!token.IsCancellationRequested)
                {
                    uint recvNum = ZLGCAN.ZCAN_GetReceiveNum(_deviceHandle, 2);
                    if (recvNum == 0)
                    {
                        Thread.Sleep(10);
                        continue;
                    }

                    uint actualRecv = ZLGCAN.ZCAN_ReceiveData(_deviceHandle, pDataObjs, (uint)bufferFrames, 10);
                    if (actualRecv == 0)
                    {
                        continue;
                    }

                    for (int i = 0; i < actualRecv; i++)
                    {
                        IntPtr pCur = IntPtr.Add(pDataObjs, i * dataObjSize);
                        var obj = Marshal.PtrToStructure<ZLGCAN.ZCANDataObj>(pCur);

                        switch (obj.dataType)
                        {
                            case 1:
                                Marshal.Copy(obj.data, 0, pCanfdBuffer, canfdSize);
                                var canfdData = Marshal.PtrToStructure<ZLGCAN.ZCANCANFDData>(pCanfdBuffer);
                                bool isFd = (canfdData.flag & 1) == 1;
                                bool isTx = (canfdData.flag & (1 << 9)) != 0;
                                RaiseCanFrame(obj.chnl, canfdData.timeStamp, isFd, canfdData.frame.can_id, canfdData.frame.data, canfdData.frame.len, isTx);
                                break;

                            case 4:
                                if (obj.data == null || obj.data.Length < linSize)
                                {
                                    break;
                                }
                                Marshal.Copy(obj.data, 0, pLinBuffer, linSize);
                                var linData = Marshal.PtrToStructure<ZLGCAN.ZCANLINData>(pLinBuffer);
                                RaiseLinFrame(obj.chnl, linData.rxData.timeStamp, linData.pid.rawVal, linData.rxData.data, linData.rxData.datalen, linData.rxData.dir);
                                break;
                        }
                    }

                    Thread.Sleep(1);
                }
            }
            finally
            {
                Marshal.FreeHGlobal(pLinBuffer);
                Marshal.FreeHGlobal(pCanfdBuffer);
                Marshal.FreeHGlobal(pDataObjs);
            }
        }

        /// <summary>
        /// 将接收到的 CAN/CANFD 帧转换为托管对象并触发事件。
        /// </summary>
        /// <param name="channel">通道号。</param>
        /// <param name="timestamp">时间戳（us）。</param>
        /// <param name="isCanFd">是否 CANFD。</param>
        /// <param name="canId">can_id（含标志位）。</param>
        /// <param name="data">原始数据缓冲区。</param>
        /// <param name="dlc">数据长度。</param>
        /// <param name="isTx">是否为发送回显（Tx）。</param>

        private void RaiseCanFrame(int channel, ulong timestamp, bool isCanFd, uint canId, byte[] data, byte dlc, bool isTx)
        {
            try
            {
                var len = Math.Min(isCanFd ? 64 : 8, Math.Min((int)dlc, data?.Length ?? 0));
                var bytes = new byte[len];
                if (len > 0 && data != null)
                {
                    Array.Copy(data, bytes, len);
                }

                CanFrameReceived?.Invoke(new ZlgCanRxFrame(channel, isCanFd, canId, bytes, timestamp, isTx));

                if (isTx)
                {
                    MarkSendOk();
                }
                else
                {
                    MarkReviceOk();
                }

                if (DbcDecodeEnabled)
                {
                    TryDecodeAndUpdateModels(canId, bytes, isCanFd ? (byte)ZDBC.FT_CANFD : (byte)ZDBC.FT_CAN);
                }
            }
            catch (Exception ex)
            {
                _log.Warn($"派发 CAN 帧事件异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 将接收到的 LIN 帧转换为托管对象并触发事件。
        /// </summary>
        /// <param name="channel">通道号。</param>
        /// <param name="timestamp">时间戳（us）。</param>
        /// <param name="pid">PID。</param>
        /// <param name="data">原始数据缓冲区。</param>
        /// <param name="datalen">数据长度。</param>
        /// <param name="dir">方向（由设备回传）。</param>

        private void RaiseLinFrame(int channel, ulong timestamp, byte pid, byte[] data, byte datalen, byte dir)
        {
            try
            {
                var len = Math.Min(8, Math.Min((int)datalen, data?.Length ?? 0));
                var bytes = new byte[len];
                if (len > 0 && data != null)
                {
                    Array.Copy(data, bytes, len);
                }

                LinFrameReceived?.Invoke(new ZlgLinRxFrame(channel, pid, bytes, timestamp, dir));
            }
            catch (Exception ex)
            {
                _log.Warn($"派发 LIN 帧事件异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 校验指定原生 DLL 是否存在于程序输出目录（AppContext.BaseDirectory）。
        /// </summary>
        /// <param name="dllName">DLL 文件名。</param>
        /// <exception cref="FileNotFoundException">找不到 DLL。</exception>

        private static void EnsureNativeDllExists(string dllName)
        {
            var baseDir = AppContext.BaseDirectory;
            var full = Path.Combine(baseDir, dllName);
            if (!File.Exists(full))
            {
                throw new FileNotFoundException($"未找到 {dllName}，请将其复制到程序输出目录：{baseDir}", full);
            }

            TryPreloadNativeDll(full);
            if (_preloadedZlgcanHandle == IntPtr.Zero && !string.IsNullOrWhiteSpace(_preloadedZlgcanError))
            {
                throw new InvalidOperationException($"预加载 {dllName} 失败：{_preloadedZlgcanError}。DLL 路径：{full}");
            }

            var dllArch = TryGetPeArchitecture(full);
            if (!string.IsNullOrWhiteSpace(dllArch))
            {
                var procArch = Environment.Is64BitProcess ? "x64" : "x86";
                if (Environment.Is64BitProcess && !string.Equals(dllArch, "x64", StringComparison.OrdinalIgnoreCase))
                {
                    throw new InvalidOperationException($"{dllName} 位数不匹配：当前进程为 {procArch}，但 DLL 架构为 {dllArch}。请替换为 x64 版本 DLL，或将程序改为 x86 运行。DLL 路径：{full}");
                }
                if (!Environment.Is64BitProcess && !string.Equals(dllArch, "x86", StringComparison.OrdinalIgnoreCase))
                {
                    throw new InvalidOperationException($"{dllName} 位数不匹配：当前进程为 {procArch}，但 DLL 架构为 {dllArch}。请替换为 x86 版本 DLL，或将程序改为 x64 运行。DLL 路径：{full}");
                }
            }
        }

        /// <summary>
        /// 尝试读取 PE 头判断 DLL 架构。
        /// </summary>
        /// <param name="dllFullPath">DLL 完整路径。</param>
        /// <returns>返回 "x86"/"x64"/"arm64"/"unknown(...)"；读取失败返回 null。</returns>
        private static string? TryGetPeArchitecture(string dllFullPath)
        {
            try
            {
                using var fs = new FileStream(dllFullPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                using var br = new BinaryReader(fs);

                if (fs.Length < 0x40)
                {
                    return null;
                }

                var mz = br.ReadUInt16();
                if (mz != 0x5A4D)
                {
                    return null;
                }

                fs.Position = 0x3C;
                var peOffset = br.ReadInt32();
                if (peOffset <= 0 || peOffset > fs.Length - 6)
                {
                    return null;
                }

                fs.Position = peOffset;
                var peSig = br.ReadUInt32();
                if (peSig != 0x00004550)
                {
                    return null;
                }

                var machine = br.ReadUInt16();
                return machine switch
                {
                    0x014c => "x86",
                    0x8664 => "x64",
                    0xAA64 => "arm64",
                    _ => $"unknown(0x{machine:X})"
                };
            }
            catch
            {
                return null;
            }
        }

        private static Dictionary<string, CanDbcModel> BuildDbcModelIndex(IEnumerable<CanDbcModel> models)
        {
            var dict = new Dictionary<string, CanDbcModel>(StringComparer.Ordinal);

            foreach (var m in models)
            {
                if (string.IsNullOrWhiteSpace(m.MsgName) || string.IsNullOrWhiteSpace(m.SignalName))
                {
                    continue;
                }

                dict[BuildMsgSigKey(m.MsgName, m.SignalName)] = m;
            }

            return dict;
        }

        private static string BuildMsgSigKey(string msgName, string signalName)
        {
            return msgName + "\u0000" + signalName;
        }

        private void TryDecodeAndUpdateModels(uint canId, byte[] payload, byte frameType)
        {
            ZlgDbcDatabase? dbc;
            Dictionary<string, CanDbcModel>? index;

            lock (_dbcSync)
            {
                dbc = _dbc;
                index = _dbcModelIndex;
            }

            if (dbc == null || !dbc.IsLoaded || index == null)
            {
                return;
            }

            try
            {
                var (msgName, signals) = dbc.DecodeRawFrame(canId, payload, frameType);
                if (string.IsNullOrWhiteSpace(msgName) || signals == null || signals.Count == 0)
                {
                    return;
                }

                foreach (var kv in signals)
                {
                    var key = BuildMsgSigKey(msgName, kv.Key);
                    if (index.TryGetValue(key, out var model))
                    {
                        model.SignalRtValue = kv.Value.ToString();
                    }
                }
            }
            catch (Exception ex)
            {
                _log.Warn($"DBC 解码异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 若对象已释放则抛异常。
        /// </summary>
        private void ThrowIfDisposed()
        {
            if (_disposed)
            {
                throw new ObjectDisposedException(nameof(ZlgCanFd200uDriver));
            }
        }
    }

    /// <summary>
    /// CAN/CANFD 接收帧。
    /// </summary>
    public readonly struct ZlgCanRxFrame
    {
        /// <summary>
        /// 构造 CAN/CANFD 接收帧。
        /// </summary>
        /// <param name="channel">通道号。</param>
        /// <param name="isCanFd">是否 CANFD。</param>
        /// <param name="canId">can_id（含标志位）。</param>
        /// <param name="data">数据（已截断为实际长度）。</param>
        /// <param name="timestampUs">时间戳（us）。</param>
        /// <param name="isTx">是否为发送回显。</param>
        public ZlgCanRxFrame(int channel, bool isCanFd, uint canId, byte[] data, ulong timestampUs, bool isTx)
        {
            Channel = channel;
            IsCanFd = isCanFd;
            CanId = canId;
            Data = data;
            TimestampUs = timestampUs;
            IsTx = isTx;
        }

        public int Channel { get; }
        public bool IsCanFd { get; }
        public uint CanId { get; }
        public byte[] Data { get; }
        public ulong TimestampUs { get; }
        public bool IsTx { get; }
    }

    /// <summary>
    /// LIN 接收帧。
    /// </summary>
    public readonly struct ZlgLinRxFrame
    {
        /// <summary>
        /// 构造 LIN 接收帧。
        /// </summary>
        /// <param name="channel">通道号。</param>
        /// <param name="pid">PID。</param>
        /// <param name="data">数据（已截断为实际长度）。</param>
        /// <param name="timestampUs">时间戳（us）。</param>
        /// <param name="dir">方向（由设备回传）。</param>
        public ZlgLinRxFrame(int channel, byte pid, byte[] data, ulong timestampUs, byte dir)
        {
            Channel = channel;
            Pid = pid;
            Data = data;
            TimestampUs = timestampUs;
            Dir = dir;
        }

        public int Channel { get; }
        public byte Pid { get; }
        public byte[] Data { get; }
        public ulong TimestampUs { get; }

        /// <summary>
        /// 方向：由设备回传，0/1 具体含义以 ZLG 文档为准。
        /// </summary>
        public byte Dir { get; }
    }
}