using System;
using System.Buffers;
using System.Collections.Concurrent;
using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;
using Prism.Events;
using XP.Hardware.Detector.Abstractions;
using XP.Hardware.Detector.Abstractions.Enums;
using XP.Hardware.Detector.Config;
using XP.Common.Logging.Interfaces;

namespace XP.Hardware.Detector.Implementations
{
    /// <summary>
    /// Varex 探测器实现类 | Varex detector implementation class
    /// 通过 XISL API 控制 Varex 探测器硬件
    /// </summary>
    public class VarexDetector : AreaDetectorBase, IVarexDetector
    {
        #region 私有字段 | Private Fields

        // 配置 | Configuration
        private readonly VarexDetectorConfig _config;

        // 日志服务 | Logger service
        private readonly ILoggerService _logger;

        // 内存管理 | Memory Management
        private readonly ArrayPool<ushort> _arrayPool;
        private readonly ConcurrentQueue<short[]> _imageQueue;

        // XISL 句柄 | XISL Handles
        private IntPtr _hAcqDesc = IntPtr.Zero;
        private IntPtr _pAcqBuffer = IntPtr.Zero;
        private IntPtr _pOffsetBuffer = IntPtr.Zero;
        private IntPtr _pGainBuffer = IntPtr.Zero;
        private IntPtr _pGainAvgBuffer = IntPtr.Zero;  // 增益映射输出缓冲区（DWORD*）| Gain map output buffer (DWORD*)
        private IntPtr _pCorrList = IntPtr.Zero;

        // 回调委托 | Callback Delegates
        private XISLApi.EndFrameCallback _endFrameCallback;
        private XISLApi.EndAcqCallback _endAcqCallback;

        // 事件句柄 | Event Handles
        private IntPtr _hevEndFrame = IntPtr.Zero;
        private IntPtr _hevEndAcq = IntPtr.Zero;

        // 配置参数 | Configuration Parameters
        private BinningMode _binningMode;
        private GainMode _gainMode;
        private uint _exposureTime;
        private (uint x, uint y, uint width, uint height) _roi;

        // 采集控制 | Acquisition Control
        private bool _isAcquiring = false;
        private CancellationTokenSource _acquisitionCts;
        private readonly object _acquisitionLock = new object();

        // 缓存的图像分辨率（初始化/参数变更时更新）| Cached image resolution (updated on init/param change)
        private uint _cachedRows;
        private uint _cachedColumns;

        #endregion

        #region 属性 | Properties

        /// <summary>
        /// 探测器类型 | Detector type
        /// </summary>
        public override DetectorType Type => DetectorType.Varex;

        #endregion

        #region 构造函数 | Constructor

        /// <summary>
        /// 构造函数 | Constructor
        /// </summary>
        /// <param name="config">Varex 探测器配置 | Varex detector configuration</param>
        /// <param name="eventAggregator">事件聚合器 | Event aggregator</param>
        /// <param name="logger">日志服务 | Logger service</param>
        public VarexDetector(VarexDetectorConfig config, IEventAggregator eventAggregator, ILoggerService logger = null)
            : base(eventAggregator)
        {
            _config = config ?? throw new ArgumentNullException(nameof(config));
            _logger = logger?.ForModule("VarexDetector");

            // 初始化内存管理 | Initialize memory management
            _arrayPool = ArrayPool<ushort>.Shared;
            _imageQueue = new ConcurrentQueue<short[]>();

            // 初始化配置参数 | Initialize configuration parameters
            _binningMode = config.BinningMode;
            _gainMode = config.GainMode;
            _exposureTime = config.ExposureTime;
            _roi = (config.RoiX, config.RoiY, config.RoiWidth, config.RoiHeight);

            // 创建回调委托实例（防止被 GC 回收）| Create callback delegate instances (prevent GC collection)
            _endFrameCallback = OnEndFrameCallback;
            _endAcqCallback = OnEndAcqCallback;

            _logger?.Info("VarexDetector 实例已创建 | VarexDetector instance created");
        }

        #endregion

        #region 抽象方法实现（占位符）| Abstract Method Implementations (Placeholders)

        /// <summary>
        /// 初始化探测器内部实现 | Initialize detector internal implementation
        /// </summary>
        protected override Task<DetectorResult> InitializeInternalAsync(CancellationToken cancellationToken)
        {
            return Task.Run(() =>
            {
                try
                {
                    _logger?.Info("开始初始化 Varex 探测器 | Starting Varex detector initialization");

                    // 1. 调用 VarexDetDll 底层初始化 | Call VarexDetDll low-level initialization
                    _logger?.Debug("调用 DoDetInit 进行底层初始化 | Calling DoDetInit for low-level initialization");
                    int initResult = XISLApi.DoDetInit(ref _hAcqDesc);
                    if (initResult != 0)
                    {
                        var errorMsg = $"探测器底层初始化失败 | Detector low-level initialization failed, DoDetInit 返回码：{initResult}";
                        _logger?.Error(null, errorMsg);
                        return DetectorResult.Failure(errorMsg, null, initResult);
                    }
                    _logger?.Info("DoDetInit 初始化成功 | DoDetInit initialization successful");

                    // 2. 获取探测器句柄 | Get detector handle
                    IntPtr hWnd = IntPtr.Zero;
                    var result = XISLApi.Acquisition_GetNextSensor(ref hWnd, ref _hAcqDesc);
                    if (_hAcqDesc == IntPtr.Zero)
                    {
                        var errorMsg = "获取探测器句柄失败，句柄为空 | Failed to get detector handle, handle is null";
                        _logger?.Error(null, errorMsg);
                        return DetectorResult.Failure(errorMsg, null, (int)result);
                    }
                    _logger?.Debug("探测器句柄获取成功 | Detector handle acquired successfully");

                    // 3. 注册回调函数 | Register callbacks
                    Thread.Sleep(200);
                    result = XISLApi.Acquisition_SetCallbacksAndMessages(
                        _hAcqDesc, IntPtr.Zero, 0, 0, _endFrameCallback, _endAcqCallback);
                    if (result != XISLApi.HIS_RETURN.HIS_ALL_OK)
                    {
                        var errorMsg = $"注册回调函数失败 | Failed to register callbacks: {result}";
                        _logger?.Error(null, errorMsg + $"，返回码：{(int)result}");
                        return DetectorResult.Failure(errorMsg, null, (int)result);
                    }
                    _logger?.Debug("回调函数注册成功 | Callbacks registered successfully");

                    // 4. 设置帧同步模式为内部定时器 | Set frame sync mode to internal timer
                    result = XISLApi.Acquisition_SetFrameSyncMode(_hAcqDesc, (uint)XISLApi.HIS_SYNCMODE_INTERNAL_TIMER);
                    if (result != XISLApi.HIS_RETURN.HIS_ALL_OK)
                    {
                        _logger?.Warn($"设置帧同步模式失败 | Failed to set frame sync mode: {result}");
                    }

                    // 5. 获取探测器配置（分辨率等）| Get detector configuration (resolution etc.)
                    uint dwFrames, dwRows, dwColumns, dwDataType, dwSortFlags;
                    uint dwAcqType, dwSystemID, dwSyncMode, dwHwAccess;
                    int iIRQFlags;
                    result = XISLApi.Acquisition_GetConfiguration(
                        _hAcqDesc, out dwFrames, out dwRows, out dwColumns,
                        out dwDataType, out dwSortFlags, out iIRQFlags,
                        out dwAcqType, out dwSystemID, out dwSyncMode, out dwHwAccess);
                    if (result != XISLApi.HIS_RETURN.HIS_ALL_OK)
                    {
                        var errorMsg = $"获取探测器配置失败 | Failed to get detector configuration: {result}";
                        _logger?.Error(null, errorMsg + $"，返回码：{(int)result}");
                        return DetectorResult.Failure(errorMsg, null, (int)result);
                    }
                    _logger?.Info($"探测器配置：分辨率 {dwColumns}x{dwRows}，数据类型 {dwDataType} | Detector config: resolution {dwColumns}x{dwRows}, data type {dwDataType}");

                    // 6. 分配采集缓冲区（校正缓冲区保持 IntPtr.Zero，未校正前不可传给 API）
                    // Allocate acquisition buffer (correction buffers stay IntPtr.Zero until calibration is done)
                    int bufferSize = (int)(dwRows * dwColumns * sizeof(ushort));
                    _pAcqBuffer = Marshal.AllocHGlobal(bufferSize);
                    _logger?.Debug($"采集缓冲区已分配，大小：{bufferSize} 字节 | Acquisition buffer allocated, size: {bufferSize} bytes");

                    // 7. 定义目标缓冲区 | Define destination buffers
                    result = XISLApi.Acquisition_DefineDestBuffers(
                        _hAcqDesc, _pAcqBuffer, 1, dwRows, dwColumns);
                    if (result != XISLApi.HIS_RETURN.HIS_ALL_OK)
                    {
                        var errorMsg = $"定义目标缓冲区失败 | Failed to define destination buffers: {result}";
                        _logger?.Error(null, errorMsg + $"，返回码：{(int)result}");
                        return DetectorResult.Failure(errorMsg, null, (int)result);
                    }
                    _logger?.Debug("目标缓冲区定义成功 | Destination buffers defined successfully");

                    // 9. 创建事件句柄 | Create event handles
                    _hevEndFrame = XISLApi.CreateEvent(IntPtr.Zero, false, false, null);
                    _hevEndAcq = XISLApi.CreateEvent(IntPtr.Zero, false, false, null);
                    _logger?.Debug("事件句柄已创建 | Event handles created");

                    // 10. 应用初始配置（Binning/增益/曝光时间）| Apply initial configuration (Binning/Gain/Exposure)
                    var configResult = ApplyConfiguration();
                    if (!configResult.IsSuccess)
                    {
                        _logger?.Error(null, $"应用初始配置失败 | Failed to apply initial configuration: {configResult.ErrorMessage}");
                        return configResult;
                    }

                    _logger?.Info("Varex 探测器初始化成功 | Varex detector initialized successfully");
                    return DetectorResult.Success("Varex 探测器初始化成功 | Varex detector initialized successfully");
                }
                catch (Exception ex)
                {
                    var errorMsg = $"初始化异常 | Initialization exception: {ex.Message}";
                    _logger?.Error(ex, errorMsg);
                    return DetectorResult.Failure(errorMsg, ex, -1);
                }
            }, cancellationToken);
        }


        /// <summary>
        /// 应用配置参数 | Apply configuration parameters
        /// </summary>
        private DetectorResult ApplyConfiguration()
        {
            try
            {
                // 设置 Binning 模式（API 值从 1 开始）| Set binning mode (API value starts from 1)
                var result = XISLApi.Acquisition_SetCameraBinningMode(_hAcqDesc, (uint)_binningMode + 1);
                if (result != XISLApi.HIS_RETURN.HIS_ALL_OK)
                {
                    return DetectorResult.Failure($"设置 Binning 模式失败 | Failed to set binning mode: {result}");
                }

                // 设置增益模式 | Set gain mode
                result = XISLApi.Acquisition_SetCameraGain(_hAcqDesc, (uint)_gainMode);
                if (result != XISLApi.HIS_RETURN.HIS_ALL_OK)
                {
                    return DetectorResult.Failure($"设置增益模式失败 | Failed to set gain mode: {result}");
                }

                // 设置曝光时间 | Set exposure time
                uint exposureTime = _exposureTime;
                result = XISLApi.Acquisition_SetTimerSync(_hAcqDesc, ref exposureTime);
                if (result != XISLApi.HIS_RETURN.HIS_ALL_OK)
                {
                    return DetectorResult.Failure($"设置曝光时间失败 | Failed to set exposure time: {result}");
                }

                return DetectorResult.Success("配置应用成功 | Configuration applied successfully");
            }
            catch (Exception ex)
            {
                return DetectorResult.Failure($"应用配置异常 | Apply configuration exception: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 获取当前帧号 | Get current frame number
        /// </summary>
        private int GetCurrentFrameNumber()
        {
            uint dwActFrame, dwSecFrame;
            XISLApi.Acquisition_GetActFrame(_hAcqDesc, out dwActFrame, out dwSecFrame);
            return (int)dwActFrame;
        }


        /// <summary>
        /// 启动连续采集内部实现 | Start continuous acquisition internal implementation
        /// </summary>
        /// <summary>
        /// 采集前准备：获取配置、分配缓冲区、定义目标缓冲区、设置采集标志
        /// Prepare for acquisition: get config, allocate buffers, define dest buffers, set acq data
        /// </summary>
        private DetectorResult PrepareForAcquisition(uint acqDataFlag, int targetFrames, out uint dwRows, out uint dwColumns)
        {
            dwRows = 0;
            dwColumns = 0;

            // 1. 获取当前探测器配置（Binning 改变后分辨率会变）| Get current config (resolution changes with binning)
            uint dwFrames, dwDataType, dwSortFlags, dwAcqType, dwSystemID, dwSyncMode, dwHwAccess;
            int iIRQFlags;
            var result = XISLApi.Acquisition_GetConfiguration(
                _hAcqDesc, out dwFrames, out dwRows, out dwColumns,
                out dwDataType, out dwSortFlags, out iIRQFlags,
                out dwAcqType, out dwSystemID, out dwSyncMode, out dwHwAccess);
            if (result != XISLApi.HIS_RETURN.HIS_ALL_OK)
            {
                return DetectorResult.Failure($"获取探测器配置失败 | Failed to get detector configuration: {result}", null, (int)result);
            }
            _logger?.Debug($"采集前配置：分辨率 {dwColumns}x{dwRows} | Pre-acquisition config: resolution {dwColumns}x{dwRows}");

            // 缓存分辨率供回调使用 | Cache resolution for callback use
            _cachedRows = dwRows;
            _cachedColumns = dwColumns;

            // 2. 设置采集数据标志 | Set acquisition data flag
            uint acqData = acqDataFlag;
            result = XISLApi.Acquisition_SetAcqData(_hAcqDesc, ref acqData);
            if (result != XISLApi.HIS_RETURN.HIS_ALL_OK)
            {
                return DetectorResult.Failure($"设置采集数据标志失败 | Failed to set acquisition data flag: {result}", null, (int)result);
            }

            // 3. 重新分配采集缓冲区 | Reallocate acquisition buffer
            if (_pAcqBuffer != IntPtr.Zero)
            {
                Marshal.FreeHGlobal(_pAcqBuffer);
            }
            _pAcqBuffer = Marshal.AllocHGlobal(targetFrames * (int)dwRows * (int)dwColumns * sizeof(ushort));

            // 4. 定义目标缓冲区 | Define destination buffers
            result = XISLApi.Acquisition_DefineDestBuffers(_hAcqDesc, _pAcqBuffer, targetFrames, dwRows, dwColumns);
            if (result != XISLApi.HIS_RETURN.HIS_ALL_OK)
            {
                return DetectorResult.Failure($"定义目标缓冲区失败 | Failed to define destination buffers: {result}", null, (int)result);
            }

            return DetectorResult.Success();
        }

        protected override Task<DetectorResult> StartAcquisitionInternalAsync(CancellationToken cancellationToken)
        {
            return Task.Run(() =>
            {
                try
                {
                    _logger?.Info("开始启动连续采集 | Starting continuous acquisition");

                    // 检查取消令牌 | Check cancellation token
                    if (cancellationToken.IsCancellationRequested)
                    {
                        _logger?.Warn("启动采集操作已取消 | Start acquisition operation cancelled");
                        return DetectorResult.Failure("操作已取消 | Operation cancelled");
                    }

                    lock (_acquisitionLock)
                    {
                        // 防止重复启动 | Prevent duplicate start
                        if (_isAcquiring)
                        {
                            var errorMsg = "采集已在进行中，无法重复启动 | Acquisition already in progress, cannot start again";
                            _logger?.Warn(errorMsg);
                            return DetectorResult.Failure(errorMsg);
                        }

                        // 确保之前的 CancellationTokenSource 已清理 | Ensure previous CancellationTokenSource is cleaned up
                        if (_acquisitionCts != null)
                        {
                            _logger?.Debug("清理之前的 CancellationTokenSource | Cleaning up previous CancellationTokenSource");
                            try
                            {
                                _acquisitionCts.Cancel();
                                _acquisitionCts.Dispose();
                            }
                            catch (Exception ex)
                            {
                                _logger?.Warn($"清理 CancellationTokenSource 时发生异常 | Exception while cleaning CancellationTokenSource: {ex.Message}");
                            }
                            _acquisitionCts = null;
                        }

                        _isAcquiring = true;
                        _acquisitionCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
                    }

                    // 再次检查取消令牌 | Check cancellation token again
                    if (cancellationToken.IsCancellationRequested)
                    {
                        lock (_acquisitionLock)
                        {
                            _isAcquiring = false;
                            _acquisitionCts?.Dispose();
                            _acquisitionCts = null;
                        }
                        _logger?.Warn("启动采集操作已取消 | Start acquisition operation cancelled");
                        return DetectorResult.Failure("操作已取消 | Operation cancelled");
                    }

                    // 启动连续采集前准备 | Prepare before starting continuous acquisition
                    var prepResult = PrepareForAcquisition(XISLApi.ACQ_SNAP, 1, out uint dwRows, out uint dwColumns);
                    if (!prepResult.IsSuccess)
                    {
                        lock (_acquisitionLock)
                        {
                            _isAcquiring = false;
                            _acquisitionCts?.Dispose();
                            _acquisitionCts = null;
                        }
                        _logger?.Error(null, $"采集准备失败 | Acquisition preparation failed: {prepResult.ErrorMessage}");
                        return prepResult;
                    }

                    // 启动连续采集 | Start continuous acquisition
                    var result = XISLApi.Acquisition_Acquire_Image(
                        _hAcqDesc,
                        1, // 帧数 | Frame count
                        0, // 跳过帧数 | Skip frames
                        (uint)XISLApi.HIS_SEQ_CONTINUOUS,
                        _pOffsetBuffer,  // 未校正时为 IntPtr.Zero | IntPtr.Zero before calibration
                        _pGainAvgBuffer, // 未校正时为 IntPtr.Zero，校正后为增益映射 | IntPtr.Zero before calibration, gain map after
                        _pCorrList);     // 未校正时为 IntPtr.Zero | IntPtr.Zero before calibration

                    if (result != XISLApi.HIS_RETURN.HIS_ALL_OK)
                    {
                        lock (_acquisitionLock)
                        {
                            _isAcquiring = false;
                            _acquisitionCts?.Dispose();
                            _acquisitionCts = null;
                        }
                        var errorMsg = $"启动采集失败 | Failed to start acquisition: {result}";
                        _logger?.Error(null, errorMsg + $"，返回码：{(int)result}");
                        return DetectorResult.Failure(errorMsg, null, (int)result);
                    }

                    _logger?.Info("连续采集已启动 | Continuous acquisition started");
                    return DetectorResult.Success("采集已启动 | Acquisition started");
                }
                catch (OperationCanceledException)
                {
                    lock (_acquisitionLock)
                    {
                        _isAcquiring = false;
                        _acquisitionCts?.Dispose();
                        _acquisitionCts = null;
                    }
                    _logger?.Warn("启动采集操作已取消 | Start acquisition operation cancelled");
                    return DetectorResult.Failure("操作已取消 | Operation cancelled");
                }
                catch (Exception ex)
                {
                    lock (_acquisitionLock)
                    {
                        _isAcquiring = false;
                        _acquisitionCts?.Dispose();
                        _acquisitionCts = null;
                    }
                    var errorMsg = $"启动采集异常 | Start acquisition exception: {ex.Message}";
                    _logger?.Error(ex, errorMsg);
                    return DetectorResult.Failure(errorMsg, ex, -1);
                }
            }, cancellationToken);
        }

        /// <summary>
        /// 停止采集内部实现 | Stop acquisition internal implementation
        /// </summary>
        protected override Task<DetectorResult> StopAcquisitionInternalAsync(CancellationToken cancellationToken)
        {
            return Task.Run(() =>
            {
                try
                {
                    _logger?.Info("开始停止采集 | Starting to stop acquisition");

                    // 检查取消令牌 | Check cancellation token
                    if (cancellationToken.IsCancellationRequested)
                    {
                        _logger?.Warn("停止采集操作已取消 | Stop acquisition operation cancelled");
                        return DetectorResult.Failure("操作已取消 | Operation cancelled");
                    }

                    lock (_acquisitionLock)
                    {
                        // 幂等性检查：如果未在采集，直接返回成功 | Idempotency check: if not acquiring, return success
                        if (!_isAcquiring)
                        {
                            _logger?.Debug("采集未运行，无需停止 | Acquisition not running, no need to stop");
                            return DetectorResult.Success("采集未运行 | Acquisition not running");
                        }
                    }

                    // 停止采集 | Stop acquisition
                    var result = XISLApi.Acquisition_Abort(_hAcqDesc);
                    _logger?.Debug($"调用 Acquisition_Abort，返回码：{result} | Called Acquisition_Abort, return code: {result}");

                    // 等待采集结束事件，支持取消令牌 | Wait for acquisition end event, support cancellation token
                    const int timeoutMs = 5000; // 5 秒超时 | 5 seconds timeout
                    const int pollIntervalMs = 100; // 轮询间隔 | Poll interval
                    int elapsedMs = 0;

                    while (elapsedMs < timeoutMs)
                    {
                        // 检查取消令牌 | Check cancellation token
                        if (cancellationToken.IsCancellationRequested)
                        {
                            _logger?.Warn("停止采集操作已取消，但仍会清理资源 | Stop acquisition operation cancelled, but will still clean up resources");
                            break;
                        }

                        uint waitResult = XISLApi.WaitForSingleObject(_hevEndAcq, (uint)pollIntervalMs);
                        
                        if (waitResult == XISLApi.WAIT_OBJECT_0)
                        {
                            // 成功等到事件 | Successfully waited for event
                            break;
                        }

                        elapsedMs += pollIntervalMs;
                    }

                    // 清理资源 | Clean up resources
                    lock (_acquisitionLock)
                    {
                        _isAcquiring = false;
                        
                        if (_acquisitionCts != null)
                        {
                            try
                            {
                                _acquisitionCts.Cancel();
                                _acquisitionCts.Dispose();
                            }
                            catch (Exception ex)
                            {
                                _logger?.Warn($"清理 CancellationTokenSource 时发生异常 | Exception while cleaning CancellationTokenSource: {ex.Message}");
                            }
                            _acquisitionCts = null;
                        }
                    }

                    // 检查是否超时 | Check if timeout occurred
                    if (elapsedMs >= timeoutMs && !cancellationToken.IsCancellationRequested)
                    {
                        var errorMsg = $"停止采集超时（{timeoutMs}ms），但资源已清理 | Stop acquisition timeout ({timeoutMs}ms), but resources cleaned up";
                        _logger?.Warn(errorMsg);
                        return DetectorResult.Failure(errorMsg, null, -2);
                    }

                    if (cancellationToken.IsCancellationRequested)
                    {
                        _logger?.Info("停止采集操作已取消，资源已清理 | Stop acquisition operation cancelled, resources cleaned up");
                        return DetectorResult.Failure("操作已取消 | Operation cancelled");
                    }

                    // 等待硬件完全释放采集资源，避免后续操作出现 HIS_ERROR_TIMEOUT
                    // Wait for hardware to fully release acquisition resources to avoid HIS_ERROR_TIMEOUT on subsequent operations
                    Thread.Sleep(200);

                    _logger?.Info("采集已停止 | Acquisition stopped");
                    return DetectorResult.Success("采集已停止 | Acquisition stopped");
                }
                catch (OperationCanceledException)
                {
                    // 确保资源清理 | Ensure resource cleanup
                    lock (_acquisitionLock)
                    {
                        _isAcquiring = false;
                        _acquisitionCts?.Dispose();
                        _acquisitionCts = null;
                    }
                    _logger?.Warn("停止采集操作已取消 | Stop acquisition operation cancelled");
                    return DetectorResult.Failure("操作已取消 | Operation cancelled");
                }
                catch (Exception ex)
                {
                    // 确保资源清理 | Ensure resource cleanup
                    lock (_acquisitionLock)
                    {
                        _isAcquiring = false;
                        _acquisitionCts?.Dispose();
                        _acquisitionCts = null;
                    }
                    var errorMsg = $"停止采集异常 | Stop acquisition exception: {ex.Message}";
                    _logger?.Error(ex, errorMsg);
                    return DetectorResult.Failure(errorMsg, ex, -1);
                }
            }, cancellationToken);
        }

        /// <summary>
        /// 单帧采集内部实现 | Single frame acquisition internal implementation
        /// </summary>
        protected override Task<DetectorResult> AcquireSingleFrameInternalAsync(CancellationToken cancellationToken)
        {
            return Task.Run(() =>
            {
                try
                {
                    // 单帧采集前准备（含重试机制，防止连续采集停止后硬件未完全释放）
                    // Prepare before single frame acquisition (with retry to handle hardware not fully released after continuous acquisition)
                    DetectorResult prepResult = null;
                    const int maxRetries = 3;
                    const int retryDelayMs = 300;

                    for (int attempt = 1; attempt <= maxRetries; attempt++)
                    {
                        prepResult = PrepareForAcquisition(XISLApi.ACQ_SNAP, 1, out uint dwRows, out uint dwColumns);
                        if (prepResult.IsSuccess)
                        {
                            // 采集单帧 | Acquire single frame
                            var result = XISLApi.Acquisition_Acquire_Image(
                                _hAcqDesc,
                                1, // 采集 1 帧 | Acquire 1 frame
                                0, // 跳过帧数 | Skip frames
                                (uint)XISLApi.HIS_SEQ_ONE_BUFFER,
                                _pOffsetBuffer,
                                _pGainAvgBuffer,
                                _pCorrList);

                            if (result != XISLApi.HIS_RETURN.HIS_ALL_OK)
                            {
                                return DetectorResult.Failure($"单帧采集失败 | Failed to acquire single frame: {result}");
                            }

                            // 等待帧结束事件 | Wait for frame end event
                            uint waitResult = XISLApi.WaitForSingleObject(_hevEndFrame, 5000);

                            if (waitResult != XISLApi.WAIT_OBJECT_0)
                            {
                                return DetectorResult.Failure("单帧采集超时 | Single frame acquisition timeout");
                            }

                            return DetectorResult.Success("单帧采集成功 | Single frame acquired successfully");
                        }

                        // 准备失败，等待后重试 | Preparation failed, wait and retry
                        if (attempt < maxRetries)
                        {
                            _logger?.Warn($"单帧采集准备失败（第 {attempt} 次），{retryDelayMs}ms 后重试 | " +
                                          $"Single frame preparation failed (attempt {attempt}), retrying in {retryDelayMs}ms: {prepResult.ErrorMessage}");
                            Thread.Sleep(retryDelayMs);
                        }
                    }

                    // 所有重试均失败 | All retries failed
                    _logger?.Error(null, $"单帧采集准备失败（已重试 {maxRetries} 次）| Single frame preparation failed after {maxRetries} retries: {prepResult?.ErrorMessage}");
                    return prepResult ?? DetectorResult.Failure("单帧采集准备失败 | Single frame preparation failed");
                }
                catch (Exception ex)
                {
                    return DetectorResult.Failure($"单帧采集异常 | Single frame acquisition exception: {ex.Message}", ex);
                }
            }, cancellationToken);
        }

        /// <summary>
        /// 暗场校正内部实现 | Dark correction internal implementation
        /// </summary>
        protected override Task<DetectorResult> DarkCorrectionInternalAsync(int frameCount, CancellationToken cancellationToken)
        {
            return Task.Run(() =>
            {
                try
                {
                    _logger?.Info($"开始暗场校正，帧数：{frameCount} | Starting dark correction, frame count: {frameCount}");

                    // 1. 获取探测器配置信息 | Get detector configuration
                    uint dwFrames, dwRows, dwColumns, dwDataType, dwSortFlags;
                    uint dwAcqType, dwSystemID, dwSyncMode, dwHwAccess;
                    int iIRQFlags;
                    var result = XISLApi.Acquisition_GetConfiguration(
                        _hAcqDesc, out dwFrames, out dwRows, out dwColumns,
                        out dwDataType, out dwSortFlags, out iIRQFlags,
                        out dwAcqType, out dwSystemID, out dwSyncMode, out dwHwAccess);

                    if (result != XISLApi.HIS_RETURN.HIS_ALL_OK)
                    {
                        var errorMsg = $"获取探测器配置失败 | Failed to get detector configuration: {result}";
                        _logger?.Error(null, errorMsg + $"，返回码：{(int)result}");
                        return DetectorResult.Failure(errorMsg, null, (int)result);
                    }

                    // 2. 分配暗场缓冲区（如果尚未分配或大小不匹配）| Allocate offset buffer if not allocated or size mismatch
                    int requiredSize = (int)(dwRows * dwColumns) * sizeof(ushort);
                    if (_pOffsetBuffer == IntPtr.Zero)
                    {
                        _pOffsetBuffer = Marshal.AllocHGlobal(requiredSize);
                        _logger?.Debug($"已分配暗场缓冲区，大小：{requiredSize} 字节 | Allocated offset buffer, size: {requiredSize} bytes");
                    }

                    // 3. 调用 XISL API 采集暗场图像 | Call XISL API to acquire offset image
                    _logger?.Debug($"调用 Acquisition_Acquire_OffsetImage，分辨率：{dwColumns}x{dwRows} | Calling Acquisition_Acquire_OffsetImage, resolution: {dwColumns}x{dwRows}");
                    result = XISLApi.Acquisition_Acquire_OffsetImage(
                        _hAcqDesc, _pOffsetBuffer, dwRows, dwColumns, (uint)frameCount);

                    if (result != XISLApi.HIS_RETURN.HIS_ALL_OK)
                    {
                        var errorMsg = $"采集暗场图像失败 | Failed to acquire offset image: {result}";
                        _logger?.Error(null, errorMsg + $"，返回码：{(int)result}");
                        return DetectorResult.Failure(errorMsg, null, (int)result);
                    }

                    // 3. 等待采集完成 | Wait for acquisition to complete
                    uint waitResult = XISLApi.WaitForSingleObject(_hevEndAcq, 60000); // 60 秒超时
                    if (waitResult != XISLApi.WAIT_OBJECT_0)
                    {
                        var errorMsg = $"等待暗场采集完成超时 | Timeout waiting for offset acquisition: {waitResult}";
                        _logger?.Warn(errorMsg);
                        return DetectorResult.Failure(errorMsg, null, (int)waitResult);
                    }

                    // 4. 保存暗场数据到配置的存储路径 | Save offset data to configured storage path
                    if (_config.AutoSave && !string.IsNullOrEmpty(_config.SavePath))
                    {
                        try
                        {
                            string offsetFilePath = System.IO.Path.Combine(_config.SavePath, $"offset_{DateTime.Now:yyyyMMdd_HHmmss}.raw");
                            System.IO.Directory.CreateDirectory(_config.SavePath);
                            
                            int bufferSize = (int)(dwRows * dwColumns * sizeof(ushort));
                            byte[] offsetData = new byte[bufferSize];
                            Marshal.Copy(_pOffsetBuffer, offsetData, 0, bufferSize);
                            System.IO.File.WriteAllBytes(offsetFilePath, offsetData);
                            _logger?.Info($"暗场数据已保存到：{offsetFilePath} | Offset data saved to: {offsetFilePath}");
                        }
                        catch (Exception ex)
                        {
                            // 保存失败不影响校正结果，仅记录错误 | Save failure doesn't affect correction result, just log error
                            var errorMsg = $"保存暗场数据失败 | Failed to save offset data: {ex.Message}";
                            _logger?.Warn(errorMsg);
                            PublishError(DetectorResult.Failure(errorMsg, ex));
                        }
                    }

                    // 5. 发布校正完成事件 | Publish correction completed event
                    var correctionResult = DetectorResult.Success("暗场校正完成 | Dark correction completed");
                    PublishCorrectionCompleted(CorrectionType.Dark, correctionResult);
                    _logger?.Info("暗场校正完成 | Dark correction completed");

                    return correctionResult;
                }
                catch (Exception ex)
                {
                    var errorMsg = $"暗场校正异常 | Dark correction exception: {ex.Message}";
                    _logger?.Error(ex, errorMsg);
                    var errorResult = DetectorResult.Failure(errorMsg, ex, -1);
                    PublishError(errorResult);
                    return errorResult;
                }
            }, cancellationToken);
        }

        /// <summary>
        /// 增益校正内部实现 | Gain correction internal implementation
        /// </summary>
        protected override Task<DetectorResult> GainCorrectionInternalAsync(int frameCount, CancellationToken cancellationToken)
        {
            return Task.Run(() =>
            {
                try
                {
                    _logger?.Info($"开始增益校正，帧数：{frameCount} | Starting gain correction, frame count: {frameCount}");

                    // 1. 获取探测器配置信息 | Get detector configuration
                    uint dwFrames, dwRows, dwColumns, dwDataType, dwSortFlags;
                    uint dwAcqType, dwSystemID, dwSyncMode, dwHwAccess;
                    int iIRQFlags;
                    var result = XISLApi.Acquisition_GetConfiguration(
                        _hAcqDesc, out dwFrames, out dwRows, out dwColumns,
                        out dwDataType, out dwSortFlags, out iIRQFlags,
                        out dwAcqType, out dwSystemID, out dwSyncMode, out dwHwAccess);

                    if (result != XISLApi.HIS_RETURN.HIS_ALL_OK)
                    {
                        var errorMsg = $"获取探测器配置失败 | Failed to get detector configuration: {result}";
                        _logger?.Error(null, errorMsg + $"，返回码：{(int)result}");
                        return DetectorResult.Failure(errorMsg, null, (int)result);
                    }

                    // 2. 分配增益采集缓冲区（ushort，用于 Acquire_GainImage 输入）| Allocate gain acquisition buffer (ushort, for Acquire_GainImage)
                    int gainAcqSize = (int)(dwRows * dwColumns) * sizeof(ushort);
                    if (_pGainBuffer == IntPtr.Zero)
                    {
                        _pGainBuffer = Marshal.AllocHGlobal(gainAcqSize);
                        _logger?.Debug($"已分配增益采集缓冲区，大小：{gainAcqSize} 字节 | Allocated gain acquisition buffer, size: {gainAcqSize} bytes");
                    }

                    // 分配增益映射输出缓冲区（uint/DWORD，用于 CreateGainMap 输出）| Allocate gain map output buffer (uint/DWORD, for CreateGainMap)
                    int gainAvgSize = (int)(dwRows * dwColumns) * sizeof(uint);
                    if (_pGainAvgBuffer == IntPtr.Zero)
                    {
                        _pGainAvgBuffer = Marshal.AllocHGlobal(gainAvgSize);
                        _logger?.Debug($"已分配增益映射缓冲区，大小：{gainAvgSize} 字节 | Allocated gain map buffer, size: {gainAvgSize} bytes");
                    }

                    // 3. 调用 XISL API 采集增益图像 | Call XISL API to acquire gain image
                    _logger?.Debug($"调用 Acquisition_Acquire_GainImage，分辨率：{dwColumns}x{dwRows} | Calling Acquisition_Acquire_GainImage, resolution: {dwColumns}x{dwRows}");
                    result = XISLApi.Acquisition_Acquire_GainImage(
                        _hAcqDesc, _pOffsetBuffer, _pGainBuffer, dwRows, dwColumns, (uint)frameCount);

                    if (result != XISLApi.HIS_RETURN.HIS_ALL_OK)
                    {
                        var errorMsg = $"采集增益图像失败 | Failed to acquire gain image: {result}";
                        _logger?.Error(null, errorMsg + $"，返回码：{(int)result}");
                        return DetectorResult.Failure(errorMsg, null, (int)result);
                    }

                    // 3. 等待采集完成 | Wait for acquisition to complete
                    uint waitResult = XISLApi.WaitForSingleObject(_hevEndAcq, 60000); // 60 秒超时
                    if (waitResult != XISLApi.WAIT_OBJECT_0)
                    {
                        var errorMsg = $"等待增益采集完成超时 | Timeout waiting for gain acquisition: {waitResult}";
                        _logger?.Warn(errorMsg);
                        return DetectorResult.Failure(errorMsg, null, (int)waitResult);
                    }

                    // 4. 创建增益映射（输入为采集的 ushort 数据，输出为 DWORD 映射）| Create gain map (input: ushort data, output: DWORD map)
                    _logger?.Debug("创建增益映射 | Creating gain map");
                    result = XISLApi.Acquisition_CreateGainMap(_pGainBuffer, _pGainAvgBuffer, (int)(dwRows * dwColumns), frameCount);
                    if (result != XISLApi.HIS_RETURN.HIS_ALL_OK)
                    {
                        var errorMsg = $"创建增益映射失败 | Failed to create gain map: {result}";
                        _logger?.Error(null, errorMsg + $"，返回码：{(int)result}");
                        return DetectorResult.Failure(errorMsg, null, (int)result);
                    }

                    // 5. 保存增益数据到配置的存储路径 | Save gain data to configured storage path
                    if (_config.AutoSave && !string.IsNullOrEmpty(_config.SavePath))
                    {
                        try
                        {
                            string gainFilePath = System.IO.Path.Combine(_config.SavePath, $"gain_{DateTime.Now:yyyyMMdd_HHmmss}.raw");
                            System.IO.Directory.CreateDirectory(_config.SavePath);
                            
                            int bufferSize = (int)(dwRows * dwColumns * sizeof(uint));
                            byte[] gainData = new byte[bufferSize];
                            Marshal.Copy(_pGainAvgBuffer, gainData, 0, bufferSize);
                            System.IO.File.WriteAllBytes(gainFilePath, gainData);
                            _logger?.Info($"增益数据已保存到：{gainFilePath} | Gain data saved to: {gainFilePath}");
                        }
                        catch (Exception ex)
                        {
                            // 保存失败不影响校正结果，仅记录错误 | Save failure doesn't affect correction result, just log error
                            var errorMsg = $"保存增益数据失败 | Failed to save gain data: {ex.Message}";
                            _logger?.Warn(errorMsg);
                            PublishError(DetectorResult.Failure(errorMsg, ex));
                        }
                    }

                    // 6. 发布校正完成事件 | Publish correction completed event
                    var correctionResult = DetectorResult.Success("增益校正完成 | Gain correction completed");
                    PublishCorrectionCompleted(CorrectionType.Gain, correctionResult);
                    _logger?.Info("增益校正完成 | Gain correction completed");

                    return correctionResult;
                }
                catch (Exception ex)
                {
                    var errorMsg = $"增益校正异常 | Gain correction exception: {ex.Message}";
                    _logger?.Error(ex, errorMsg);
                    var errorResult = DetectorResult.Failure(errorMsg, ex, -1);
                    PublishError(errorResult);
                    return errorResult;
                }
            }, cancellationToken);
        }

        /// <summary>
        /// 自动校正内部实现 | Auto correction internal implementation
        /// </summary>
        protected override async Task<DetectorResult> AutoCorrectionInternalAsync(int frameCount, CancellationToken cancellationToken)
        {
            try
            {
                _logger?.Info($"开始自动校正，帧数：{frameCount} | Starting auto correction, frame count: {frameCount}");

                // 1. 执行暗场校正 | Execute dark correction
                _logger?.Debug("执行暗场校正 | Executing dark correction");
                var darkResult = await DarkCorrectionInternalAsync(frameCount, cancellationToken);
                if (!darkResult.IsSuccess)
                {
                    var errorMsg = $"自动校正失败：暗场校正失败 | Auto correction failed: dark correction failed - {darkResult.ErrorMessage}";
                    _logger?.Error(null, errorMsg);
                    return DetectorResult.Failure(errorMsg, darkResult.Exception, darkResult.ErrorCode);
                }

                // 2. 执行增益校正 | Execute gain correction
                _logger?.Debug("执行增益校正 | Executing gain correction");
                var gainResult = await GainCorrectionInternalAsync(frameCount, cancellationToken);
                if (!gainResult.IsSuccess)
                {
                    var errorMsg = $"自动校正失败：增益校正失败 | Auto correction failed: gain correction failed - {gainResult.ErrorMessage}";
                    _logger?.Error(null, errorMsg);
                    return DetectorResult.Failure(errorMsg, gainResult.Exception, gainResult.ErrorCode);
                }

                // 3. 执行坏像素校正 | Execute bad pixel correction
                _logger?.Debug("执行坏像素校正 | Executing bad pixel correction");
                var badPixelResult = await BadPixelCorrectionInternalAsync(cancellationToken);
                if (!badPixelResult.IsSuccess)
                {
                    var errorMsg = $"自动校正失败：坏像素校正失败 | Auto correction failed: bad pixel correction failed - {badPixelResult.ErrorMessage}";
                    _logger?.Error(null, errorMsg);
                    return DetectorResult.Failure(errorMsg, badPixelResult.Exception, badPixelResult.ErrorCode);
                }

                // 4. 发布自动校正完成事件 | Publish auto correction completed event
                var correctionResult = DetectorResult.Success("自动校正完成 | Auto correction completed");
                PublishCorrectionCompleted(CorrectionType.Auto, correctionResult);
                _logger?.Info("自动校正完成 | Auto correction completed");

                return correctionResult;
            }
            catch (Exception ex)
            {
                var errorMsg = $"自动校正异常 | Auto correction exception: {ex.Message}";
                _logger?.Error(ex, errorMsg);
                var errorResult = DetectorResult.Failure(errorMsg, ex, -1);
                PublishError(errorResult);
                return errorResult;
            }
        }

        /// <summary>
        /// 坏像素校正内部实现 | Bad pixel correction internal implementation
        /// </summary>
        protected override Task<DetectorResult> BadPixelCorrectionInternalAsync(CancellationToken cancellationToken)
        {
            return Task.Run(() =>
            {
                try
                {
                    // 1. 获取探测器配置信息 | Get detector configuration
                    uint dwFrames, dwRows, dwColumns, dwDataType, dwSortFlags;
                    uint dwAcqType, dwSystemID, dwSyncMode, dwHwAccess;
                    int iIRQFlags;
                    var result = XISLApi.Acquisition_GetConfiguration(
                        _hAcqDesc, out dwFrames, out dwRows, out dwColumns,
                        out dwDataType, out dwSortFlags, out iIRQFlags,
                        out dwAcqType, out dwSystemID, out dwSyncMode, out dwHwAccess);

                    if (result != XISLApi.HIS_RETURN.HIS_ALL_OK)
                    {
                        return DetectorResult.Failure($"获取探测器配置失败 | Failed to get detector configuration: {result}");
                    }

                    // 2. 分配坏像素映射数据缓冲区 | Allocate bad pixel map data buffer
                    int pixelMapSize = (int)(dwRows * dwColumns);
                    IntPtr pPixelMapData = Marshal.AllocHGlobal(pixelMapSize * sizeof(ushort));

                    try
                    {
                        // 3. 第一次调用获取列表大小 | First call to get list size
                        int corrListSize = 0;
                        result = XISLApi.Acquisition_CreatePixelMap(
                            pPixelMapData, (int)dwRows, (int)dwColumns, IntPtr.Zero, ref corrListSize);

                        if (result != XISLApi.HIS_RETURN.HIS_ALL_OK && corrListSize == 0)
                        {
                            Marshal.FreeHGlobal(pPixelMapData);
                            return DetectorResult.Failure($"获取坏像素列表大小失败 | Failed to get bad pixel list size: {result}");
                        }

                        // 4. 分配坏像素校正列表缓冲区 | Allocate bad pixel correction list buffer
                        if (_pCorrList != IntPtr.Zero)
                        {
                            Marshal.FreeHGlobal(_pCorrList);
                        }
                        _pCorrList = Marshal.AllocHGlobal(corrListSize);
                        _logger?.Debug($"已分配坏像素校正列表缓冲区，大小：{corrListSize} 字节 | Allocated bad pixel correction list buffer, size: {corrListSize} bytes");

                        // 5. 第二次调用创建坏像素列表 | Second call to create bad pixel list
                        result = XISLApi.Acquisition_CreatePixelMap(
                            pPixelMapData, (int)dwRows, (int)dwColumns, _pCorrList, ref corrListSize);

                        if (result != XISLApi.HIS_RETURN.HIS_ALL_OK)
                        {
                            Marshal.FreeHGlobal(pPixelMapData);
                            return DetectorResult.Failure($"创建坏像素列表失败 | Failed to create bad pixel list: {result}");
                        }

                        // 5. 保存坏像素数据到配置的存储路径 | Save bad pixel data to configured storage path
                        if (_config.AutoSave && !string.IsNullOrEmpty(_config.SavePath))
                        {
                            try
                            {
                                string badPixelFilePath = System.IO.Path.Combine(_config.SavePath, $"badpixel_{DateTime.Now:yyyyMMdd_HHmmss}.raw");
                                System.IO.Directory.CreateDirectory(_config.SavePath);
                                
                                byte[] badPixelData = new byte[corrListSize];
                                Marshal.Copy(_pCorrList, badPixelData, 0, corrListSize);
                                System.IO.File.WriteAllBytes(badPixelFilePath, badPixelData);
                            }
                            catch (Exception ex)
                            {
                                // 保存失败不影响校正结果，仅记录错误 | Save failure doesn't affect correction result, just log error
                                PublishError(DetectorResult.Failure($"保存坏像素数据失败 | Failed to save bad pixel data: {ex.Message}", ex));
                            }
                        }

                        // 6. 发布校正完成事件 | Publish correction completed event
                        var correctionResult = DetectorResult.Success($"坏像素校正完成，检测到 {corrListSize} 个坏像素 | Bad pixel correction completed, detected {corrListSize} bad pixels");
                        PublishCorrectionCompleted(CorrectionType.BadPixel, correctionResult);

                        return correctionResult;
                    }
                    finally
                    {
                        // 释放临时缓冲区 | Release temporary buffer
                        Marshal.FreeHGlobal(pPixelMapData);
                    }
                }
                catch (Exception ex)
                {
                    var errorResult = DetectorResult.Failure($"坏像素校正异常 | Bad pixel correction exception: {ex.Message}", ex);
                    PublishError(errorResult);
                    return errorResult;
                }
            }, cancellationToken);
        }

        /// <summary>
        /// 获取探测器信息 | Get detector information
        /// </summary>
        public override DetectorInfo GetInfo()
        {
            try
            {
                var info = new DetectorInfo
                {
                    Type = DetectorType.Varex,
                    Model = "Varex 4343N", // 默认型号 | Default model
                    SerialNumber = "Unknown", // 序列号需要从硬件查询 | Serial number needs to be queried from hardware
                    FirmwareVersion = "Unknown", // 固件版本需要从硬件查询 | Firmware version needs to be queried from hardware
                    BitDepth = 16 // Varex 探测器使用 16 位数据 | Varex detector uses 16-bit data
                };

                // 如果探测器已初始化，从 XISL API 获取配置信息 | If detector is initialized, get configuration from XISL API
                if (_hAcqDesc != IntPtr.Zero)
                {
                    uint dwFrames, dwRows, dwColumns, dwDataType, dwSortFlags;
                    uint dwAcqType, dwSystemID, dwSyncMode, dwHwAccess;
                    int iIRQFlags;

                    var result = XISLApi.Acquisition_GetConfiguration(
                        _hAcqDesc, out dwFrames, out dwRows, out dwColumns,
                        out dwDataType, out dwSortFlags, out iIRQFlags,
                        out dwAcqType, out dwSystemID, out dwSyncMode, out dwHwAccess);

                    if (result == XISLApi.HIS_RETURN.HIS_ALL_OK)
                    {
                        info.MaxWidth = dwColumns;
                        info.MaxHeight = dwRows;

                        // 根据型号设置像素尺寸 | Set pixel size based on model
                        // Varex 4343N 的像素尺寸为 139 微米 | Varex 4343N pixel size is 139 micrometers
                        info.PixelSize = 139.0;

                        // 根据 SystemID 确定具体型号 | Determine specific model based on SystemID
                        info.Model = dwSystemID switch
                        {
                            _ => "Varex 4343N" // 默认型号 | Default model
                        };
                    }
                    else
                    {
                        // 如果无法获取配置，使用默认值 | If configuration cannot be obtained, use default values
                        info.MaxWidth = 2880;
                        info.MaxHeight = 2880;
                        info.PixelSize = 139.0;
                    }
                }
                else
                {
                    // 探测器未初始化，使用默认值 | Detector not initialized, use default values
                    info.MaxWidth = 2880;
                    info.MaxHeight = 2880;
                    info.PixelSize = 139.0;
                }

                return info;
            }
            catch (Exception ex)
            {
                // 发生异常时返回基本信息 | Return basic information when exception occurs
                return new DetectorInfo
                {
                    Type = DetectorType.Varex,
                    Model = "Varex (Error)",
                    SerialNumber = $"Error: {ex.Message}",
                    FirmwareVersion = "Unknown",
                    MaxWidth = 2880,
                    MaxHeight = 2880,
                    PixelSize = 139.0,
                    BitDepth = 16
                };
            }
        }

        #endregion

        #region IVarexDetector 接口实现（占位符）| IVarexDetector Interface Implementations (Placeholders)

        /// <summary>
        /// 设置 Binning 模式 | Set binning mode
        /// </summary>
        public Task<DetectorResult> SetBinningModeAsync(BinningMode mode)
        {
            return Task.Run(() =>
            {
                try
                {
                    var result = XISLApi.Acquisition_SetCameraBinningMode(_hAcqDesc, (uint)mode + 1);
                    if (result == XISLApi.HIS_RETURN.HIS_ALL_OK)
                    {
                        _binningMode = mode;
                        return DetectorResult.Success($"Binning 模式已设置为 {mode} | Binning mode set to {mode}");
                    }
                    return DetectorResult.Failure($"设置 Binning 模式失败 | Failed to set binning mode: {result}");
                }
                catch (Exception ex)
                {
                    return DetectorResult.Failure($"设置 Binning 模式异常 | Set binning mode exception: {ex.Message}", ex);
                }
            });
        }

        /// <summary>
        /// 获取 Binning 模式 | Get binning mode
        /// </summary>
        public BinningMode GetBinningMode()
        {
            return _binningMode;
        }

        /// <summary>
        /// 设置增益模式 | Set gain mode
        /// </summary>
        public Task<DetectorResult> SetGainModeAsync(GainMode mode)
        {
            return Task.Run(() =>
            {
                try
                {
                    var result = XISLApi.Acquisition_SetCameraGain(_hAcqDesc, (uint)mode);
                    if (result == XISLApi.HIS_RETURN.HIS_ALL_OK)
                    {
                        _gainMode = mode;
                        return DetectorResult.Success($"增益模式已设置为 {mode} | Gain mode set to {mode}");
                    }
                    return DetectorResult.Failure($"设置增益模式失败 | Failed to set gain mode: {result}");
                }
                catch (Exception ex)
                {
                    return DetectorResult.Failure($"设置增益模式异常 | Set gain mode exception: {ex.Message}", ex);
                }
            });
        }

        /// <summary>
        /// 获取增益模式 | Get gain mode
        /// </summary>
        public GainMode GetGainMode()
        {
            return _gainMode;
        }

        /// <summary>
        /// 设置曝光时间 | Set exposure time
        /// </summary>
        public Task<DetectorResult> SetExposureTimeAsync(uint milliseconds)
        {
            return Task.Run(() =>
            {
                try
                {
                    uint exposureTime = milliseconds;
                    var result = XISLApi.Acquisition_SetTimerSync(_hAcqDesc, ref exposureTime);
                    if (result == XISLApi.HIS_RETURN.HIS_ALL_OK)
                    {
                        _exposureTime = milliseconds;
                        return DetectorResult.Success($"曝光时间已设置为 {milliseconds} ms | Exposure time set to {milliseconds} ms");
                    }
                    return DetectorResult.Failure($"设置曝光时间失败 | Failed to set exposure time: {result}");
                }
                catch (Exception ex)
                {
                    return DetectorResult.Failure($"设置曝光时间异常 | Set exposure time exception: {ex.Message}", ex);
                }
            });
        }

        /// <summary>
        /// 获取曝光时间 | Get exposure time
        /// </summary>
        public uint GetExposureTime()
        {
            return _exposureTime;
        }

        /// <summary>
        /// 设置 ROI 区域 | Set ROI region
        /// </summary>
        public Task<DetectorResult> SetROIAsync(uint x, uint y, uint width, uint height)
        {
            return Task.Run(() =>
            {
                try
                {
                    // 注意：XISL API 可能需要特定的 ROI 设置函数
                    // 这里暂时只更新内部状态，实际 API 调用需要根据 XISL 文档补充
                    // Note: XISL API may require specific ROI setting functions
                    // Currently only updating internal state, actual API call needs to be added based on XISL documentation
                    _roi = (x, y, width, height);
                    return DetectorResult.Success($"ROI 区域已设置 | ROI region set: ({x}, {y}, {width}x{height})");
                }
                catch (Exception ex)
                {
                    return DetectorResult.Failure($"设置 ROI 区域异常 | Set ROI region exception: {ex.Message}", ex);
                }
            });
        }

        /// <summary>
        /// 获取 ROI 区域 | Get ROI region
        /// </summary>
        public (uint x, uint y, uint width, uint height) GetROI()
        {
            return _roi;
        }

        #endregion

        #region 回调函数（占位符）| Callback Functions (Placeholders)

        /// <summary>
        /// 帧结束回调函数 | End frame callback
        /// </summary>
        /// <param name="hAcqDesc">采集描述符句柄 | Acquisition descriptor handle</param>
        private void OnEndFrameCallback(IntPtr hAcqDesc)
        {
            try
            {
                uint dwRows = _cachedRows;
                uint dwColumns = _cachedColumns;
                int imageSize = (int)(dwRows * dwColumns);

                if (imageSize <= 0) return;

                // 分配独立数组（由消费者负责生命周期，避免 ArrayPool 竞态）
                // Allocate independent array (consumer owns lifetime, avoids ArrayPool race condition)
                ushort[] buffer = new ushort[imageSize];

                // 拷贝图像数据 | Copy image data
                unsafe
                {
                    fixed (ushort* pDest = buffer)
                    {
                        Buffer.MemoryCopy(
                            (void*)_pAcqBuffer,
                            pDest,
                            imageSize * sizeof(ushort),
                            imageSize * sizeof(ushort));
                    }
                }

                // 获取当前帧号 | Get current frame number
                int frameNumber = GetCurrentFrameNumber();

                // 创建事件参数 | Create event arguments
                var eventArgs = new ImageCapturedEventArgs
                {
                    ImageData = buffer,
                    Width = dwColumns,
                    Height = dwRows,
                    FrameNumber = frameNumber,
                    CaptureTime = DateTime.Now,
                    ExposureTime = _exposureTime,
                    SavePath = _config.SavePath
                };

                // 发布图像采集事件 | Publish image captured event
                PublishImageCaptured(eventArgs);
                _logger?.Debug($"图像采集完成，帧号：{frameNumber}，分辨率：{dwColumns}x{dwRows} | Image captured, frame: {frameNumber}, resolution: {dwColumns}x{dwRows}");

                // 设置帧结束事件 | Set frame end event
                if (_hevEndFrame != IntPtr.Zero)
                {
                    XISLApi.SetEvent(_hevEndFrame);
                }
            }
            catch (Exception ex)
            {
                var errorMsg = $"回调函数异常 | Callback exception: {ex.Message}";
                _logger?.Error(ex, errorMsg);
                var errorResult = DetectorResult.Failure(errorMsg, ex, -1);
                PublishError(errorResult);
            }
        }

        /// <summary>
        /// 采集结束回调函数 | End acquisition callback
        /// </summary>
        /// <param name="hAcqDesc">采集描述符句柄 | Acquisition descriptor handle</param>
        private void OnEndAcqCallback(IntPtr hAcqDesc)
        {
            try
            {
                // 重置板载选项 | Reset onboard options
                XISLApi.Acquisition_Reset_OnboardOptions(hAcqDesc);

                // 设置采集结束事件 | Set acquisition end event
                if (_hevEndAcq != IntPtr.Zero)
                {
                    XISLApi.SetEvent(_hevEndAcq);
                }
            }
            catch (Exception ex)
            {
                var errorResult = DetectorResult.Failure($"采集结束回调异常 | End acquisition callback exception: {ex.Message}", ex);
                PublishError(errorResult);
            }
        }

        #endregion

        #region 资源释放 | Resource Disposal

        /// <summary>
        /// 释放资源 | Dispose resources
        /// </summary>
        /// <param name="disposing">是否释放托管资源 | Whether to dispose managed resources</param>
        protected override void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                _logger?.Info("开始释放 VarexDetector 资源 | Starting to dispose VarexDetector resources");

                if (disposing)
                {
                    // 释放托管资源 | Release managed resources
                    try
                    {
                        // 取消并释放采集取消令牌源 | Cancel and dispose acquisition cancellation token source
                        _acquisitionCts?.Cancel();
                        _acquisitionCts?.Dispose();
                        _acquisitionCts = null;
                        _logger?.Debug("采集取消令牌源已释放 | Acquisition cancellation token source disposed");
                    }
                    catch (Exception ex)
                    {
                        // 记录异常但继续释放其他资源 | Log exception but continue disposing other resources
                        _logger?.Warn($"释放 CancellationTokenSource 时发生异常 | Exception disposing CancellationTokenSource: {ex.Message}");
                        System.Diagnostics.Debug.WriteLine($"释放 CancellationTokenSource 时发生异常 | Exception disposing CancellationTokenSource: {ex.Message}");
                    }
                }

                // 释放非托管资源 | Release unmanaged resources
                try
                {
                    // 停止采集 | Stop acquisition
                    if (_hAcqDesc != IntPtr.Zero && _isAcquiring)
                    {
                        XISLApi.Acquisition_Abort(_hAcqDesc);
                        _isAcquiring = false;
                        _logger?.Debug("采集已停止 | Acquisition stopped");
                    }

                    // 关闭所有连接 | Close all connections
                    if (_hAcqDesc != IntPtr.Zero)
                    {
                        XISLApi.Acquisition_CloseAll();
                        _hAcqDesc = IntPtr.Zero;
                        _logger?.Debug("XISL 连接已关闭 | XISL connections closed");
                    }
                }
                catch (Exception ex)
                {
                    _logger?.Warn($"关闭 XISL 连接时发生异常 | Exception closing XISL connections: {ex.Message}");
                    System.Diagnostics.Debug.WriteLine($"关闭 XISL 连接时发生异常 | Exception closing XISL connections: {ex.Message}");
                }

                // 释放图像缓冲区 | Free image buffers
                try
                {
                    if (_pAcqBuffer != IntPtr.Zero)
                    {
                        Marshal.FreeHGlobal(_pAcqBuffer);
                        _pAcqBuffer = IntPtr.Zero;
                    }

                    if (_pOffsetBuffer != IntPtr.Zero)
                    {
                        Marshal.FreeHGlobal(_pOffsetBuffer);
                        _pOffsetBuffer = IntPtr.Zero;
                    }

                    if (_pGainBuffer != IntPtr.Zero)
                    {
                        Marshal.FreeHGlobal(_pGainBuffer);
                        _pGainBuffer = IntPtr.Zero;
                    }

                    if (_pGainAvgBuffer != IntPtr.Zero)
                    {
                        Marshal.FreeHGlobal(_pGainAvgBuffer);
                        _pGainAvgBuffer = IntPtr.Zero;
                    }

                    if (_pCorrList != IntPtr.Zero)
                    {
                        Marshal.FreeHGlobal(_pCorrList);
                        _pCorrList = IntPtr.Zero;
                    }
                    _logger?.Debug("图像缓冲区已释放 | Image buffers freed");
                }
                catch (Exception ex)
                {
                    _logger?.Warn($"释放缓冲区时发生异常 | Exception freeing buffers: {ex.Message}");
                    System.Diagnostics.Debug.WriteLine($"释放缓冲区时发生异常 | Exception freeing buffers: {ex.Message}");
                }

                // 释放事件句柄 | Free event handles
                try
                {
                    if (_hevEndFrame != IntPtr.Zero)
                    {
                        XISLApi.CloseHandle(_hevEndFrame);
                        _hevEndFrame = IntPtr.Zero;
                    }

                    if (_hevEndAcq != IntPtr.Zero)
                    {
                        XISLApi.CloseHandle(_hevEndAcq);
                        _hevEndAcq = IntPtr.Zero;
                    }
                    _logger?.Debug("事件句柄已释放 | Event handles freed");
                }
                catch (Exception ex)
                {
                    _logger?.Warn($"释放事件句柄时发生异常 | Exception freeing event handles: {ex.Message}");
                    System.Diagnostics.Debug.WriteLine($"释放事件句柄时发生异常 | Exception freeing event handles: {ex.Message}");
                }

                _logger?.Info("VarexDetector 资源释放完成 | VarexDetector resources disposed");

                // 调用基类的 Dispose 方法 | Call base class Dispose method
                base.Dispose(disposing);
            }
        }

        #endregion
    }
}