using System;
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.Hardware.Detector.Factories;
using XP.Common.Logging.Interfaces;

namespace XP.Hardware.Detector.Services
{
    /// <summary>
    /// 探测器服务实现 | Detector service implementation
    /// 单例模式，封装业务逻辑，屏蔽厂商差异
    /// </summary>
    public class DetectorService : IDetectorService, IDisposable
    {
        private readonly IDetectorFactory _factory;
        private readonly IEventAggregator _eventAggregator;
        private readonly ILoggerService _logger;
        private readonly object _lock = new object();
        private IAreaDetector _detector;
        private DetectorConfig _config;
        private DetectorResult _lastError;
        private bool _disposed = false;

        /// <summary>
        /// 当前探测器状态 | Current detector status
        /// </summary>
        public DetectorStatus Status
        {
            get
            {
                lock (_lock)
                {
                    return _detector?.Status ?? DetectorStatus.Uninitialized;
                }
            }
        }

        /// <summary>
        /// 当前探测器类型 | Current detector type
        /// </summary>
        public DetectorType? Type
        {
            get
            {
                lock (_lock)
                {
                    return _detector?.Type;
                }
            }
        }

        /// <summary>
        /// 探测器是否已连接 | Whether detector is connected
        /// </summary>
        public bool IsConnected
        {
            get
            {
                lock (_lock)
                {
                    if (_detector == null) return false;
                    var status = _detector.Status;
                    return status == DetectorStatus.Ready
                        || status == DetectorStatus.Acquiring
                        || status == DetectorStatus.Correcting;
                }
            }
        }

        /// <summary>
        /// 构造函数 | Constructor
        /// </summary>
        /// <param name="factory">探测器工厂 | Detector factory</param>
        /// <param name="eventAggregator">事件聚合器 | Event aggregator</param>
        /// <param name="logger">日志服务 | Logger service</param>
        public DetectorService(IDetectorFactory factory, IEventAggregator eventAggregator, ILoggerService logger = null)
        {
            _factory = factory ?? throw new ArgumentNullException(nameof(factory));
            _eventAggregator = eventAggregator ?? throw new ArgumentNullException(nameof(eventAggregator));
            _logger = logger?.ForModule("DetectorService");
            _logger?.Info("DetectorService 实例已创建 | DetectorService instance created");
        }

        /// <summary>
        /// 初始化探测器 | Initialize detector
        /// </summary>
        /// <param name="cancellationToken">取消令牌 | Cancellation token</param>
        /// <returns>操作结果 | Operation result</returns>
        public async Task<DetectorResult> InitializeAsync(CancellationToken cancellationToken = default)
        {
            // 若已连接，先断开再重连 | If already connected, disconnect first then reconnect
            bool alreadyConnected;
            lock (_lock) { alreadyConnected = _detector != null; }
            if (alreadyConnected)
            {
                _logger?.Info("探测器已连接，先断开再重新初始化 | Detector already connected, disconnecting before reinitializing");
                await DisconnectAsync();
            }

            try
            {
                _logger?.Info("开始初始化探测器服务 | Starting to initialize detector service");

                // 加载配置 | Load configuration
                _logger?.Debug("加载配置文件 | Loading configuration file");
                var configResult = ConfigLoader.LoadConfiguration();
                if (!configResult.IsSuccess)
                {
                    _lastError = configResult;
                    _logger?.Error(null, $"加载配置失败 | Failed to load configuration: {configResult.ErrorMessage}");
                    return configResult;
                }
                _logger?.Info($"配置加载成功，探测器类型：{configResult.Data.Type} | Configuration loaded successfully, detector type: {configResult.Data.Type}");

                // 保存配置引用 | Save config reference
                _config = configResult.Data;

                // 创建探测器实例 | Create detector instance
                _logger?.Debug("创建探测器实例 | Creating detector instance");
                var createResult = _factory.CreateDetector(configResult.Data);
                if (!createResult.IsSuccess)
                {
                    _lastError = createResult;
                    _logger?.Error(createResult.Exception, $"创建探测器实例失败 | Failed to create detector instance: {createResult.ErrorMessage}");
                    return DetectorResult.Failure(createResult.ErrorMessage, createResult.Exception, createResult.ErrorCode);
                }

                lock (_lock)
                {
                    _detector = createResult.Data;
                }

                // 初始化探测器 | Initialize detector
                _logger?.Debug("初始化探测器硬件 | Initializing detector hardware");
                var initResult = await _detector.InitializeAsync(cancellationToken);
                if (!initResult.IsSuccess)
                {
                    _lastError = initResult;
                    _logger?.Error(initResult.Exception, $"初始化探测器硬件失败 | Failed to initialize detector hardware: {initResult.ErrorMessage}");
                }
                else
                {
                    _logger?.Info("探测器服务初始化成功 | Detector service initialized successfully");
                }

                return initResult;
            }
            catch (Exception ex)
            {
                var errorMsg = $"初始化服务失败 | Failed to initialize service: {ex.Message}";
                _logger?.Error(ex, errorMsg);
                var errorResult = DetectorResult.Failure(errorMsg, ex, -1);
                _lastError = errorResult;
                return errorResult;
            }
        }

        /// <summary>
        /// 断开探测器连接 | Disconnect detector
        /// </summary>
        public async Task<DetectorResult> DisconnectAsync()
        {
            try
            {
                IAreaDetector detector;
                lock (_lock)
                {
                    detector = _detector;
                    if (detector == null)
                    {
                        _logger?.Warn("探测器未连接，无需断开 | Detector not connected, no need to disconnect");
                        return DetectorResult.Success("探测器未连接 | Detector not connected");
                    }
                }

                _logger?.Info("开始断开探测器连接 | Starting to disconnect detector");

                // 如果正在采集，先停止 | If acquiring, stop first
                if (detector.Status == DetectorStatus.Acquiring)
                {
                    _logger?.Info("探测器正在采集，先停止采集 | Detector is acquiring, stopping first");
                    await detector.StopAcquisitionAsync();
                }

                // 释放探测器资源 | Dispose detector resources
                lock (_lock)
                {
                    _detector?.Dispose();
                    _detector = null;
                }

                _config = null;
                _logger?.Info("探测器已断开连接 | Detector disconnected");
                return DetectorResult.Success("探测器已断开连接 | Detector disconnected");
            }
            catch (Exception ex)
            {
                var errorMsg = $"断开探测器连接异常 | Disconnect detector exception: {ex.Message}";
                _logger?.Error(ex, errorMsg);
                // 强制清理 | Force cleanup
                lock (_lock)
                {
                    _detector?.Dispose();
                    _detector = null;
                }
                _config = null;
                var errorResult = DetectorResult.Failure(errorMsg, ex, -1);
                _lastError = errorResult;
                return errorResult;
            }
        }

        /// <summary>
        /// 启动连续采集 | Start continuous acquisition
        /// </summary>
        /// <param name="cancellationToken">取消令牌 | Cancellation token</param>
        /// <returns>操作结果 | Operation result</returns>
        public async Task<DetectorResult> StartAcquisitionAsync(CancellationToken cancellationToken = default)
        {
            try
            {
                _logger?.Info("服务层：启动连续采集 | Service layer: Starting continuous acquisition");
                var detector = GetDetectorOrThrow();
                var result = await detector.StartAcquisitionAsync(cancellationToken);
                if (!result.IsSuccess)
                {
                    _lastError = result;
                    _logger?.Error(result.Exception, $"启动采集失败 | Failed to start acquisition: {result.ErrorMessage}");
                }
                return result;
            }
            catch (Exception ex)
            {
                var errorMsg = $"服务层启动采集异常 | Service layer start acquisition exception: {ex.Message}";
                _logger?.Error(ex, errorMsg);
                var errorResult = DetectorResult.Failure(errorMsg, ex, -1);
                _lastError = errorResult;
                return errorResult;
            }
        }

        /// <summary>
        /// 停止采集 | Stop acquisition
        /// </summary>
        /// <param name="cancellationToken">取消令牌 | Cancellation token</param>
        /// <returns>操作结果 | Operation result</returns>
        public async Task<DetectorResult> StopAcquisitionAsync(CancellationToken cancellationToken = default)
        {
            try
            {
                _logger?.Info("服务层：停止采集 | Service layer: Stopping acquisition");
                var detector = GetDetectorOrThrow();
                var result = await detector.StopAcquisitionAsync(cancellationToken);
                if (!result.IsSuccess)
                {
                    _lastError = result;
                    _logger?.Error(result.Exception, $"停止采集失败 | Failed to stop acquisition: {result.ErrorMessage}");
                }
                return result;
            }
            catch (Exception ex)
            {
                var errorMsg = $"服务层停止采集异常 | Service layer stop acquisition exception: {ex.Message}";
                _logger?.Error(ex, errorMsg);
                var errorResult = DetectorResult.Failure(errorMsg, ex, -1);
                _lastError = errorResult;
                return errorResult;
            }
        }

        /// <summary>
        /// 单帧采集 | Single frame acquisition
        /// </summary>
        /// <param name="cancellationToken">取消令牌 | Cancellation token</param>
        /// <returns>操作结果 | Operation result</returns>
        public async Task<DetectorResult> AcquireSingleFrameAsync(CancellationToken cancellationToken = default)
        {
            try
            {
                _logger?.Debug("服务层：单帧采集 | Service layer: Single frame acquisition");
                var detector = GetDetectorOrThrow();
                var result = await detector.AcquireSingleFrameAsync(cancellationToken);
                if (!result.IsSuccess)
                {
                    _lastError = result;
                    _logger?.Error(result.Exception, $"单帧采集失败 | Failed to acquire single frame: {result.ErrorMessage}");
                }
                return result;
            }
            catch (Exception ex)
            {
                var errorMsg = $"服务层单帧采集异常 | Service layer single frame acquisition exception: {ex.Message}";
                _logger?.Error(ex, errorMsg);
                var errorResult = DetectorResult.Failure(errorMsg, ex, -1);
                _lastError = errorResult;
                return errorResult;
            }
        }

        /// <summary>
        /// 暗场校正 | Dark field correction
        /// </summary>
        /// <param name="frameCount">采集帧数 | Frame count</param>
        /// <param name="cancellationToken">取消令牌 | Cancellation token</param>
        /// <returns>操作结果 | Operation result</returns>
        public async Task<DetectorResult> DarkCorrectionAsync(int frameCount = 10, CancellationToken cancellationToken = default)
        {
            try
            {
                _logger?.Info("服务层：执行暗场校正，帧数：{FrameCount} | Service layer: Executing dark correction, frame count: {FrameCount}", frameCount);
                var detector = GetDetectorOrThrow();

                // 如果正在采集，先停止（XISL SDK 不允许采集中执行校正）| Stop acquisition first if running
                bool wasAcquiring = detector.Status == DetectorStatus.Acquiring;
                if (wasAcquiring)
                {
                    _logger?.Info("探测器正在采集，先停止采集再执行暗场校正 | Detector is acquiring, stopping before dark correction");
                    var stopResult = await detector.StopAcquisitionAsync(cancellationToken);
                    if (!stopResult.IsSuccess)
                    {
                        _lastError = stopResult;
                        _logger?.Error(stopResult.Exception, "停止采集失败，无法执行暗场校正：{Message} | Failed to stop acquisition, cannot perform dark correction: {Message}", stopResult.ErrorMessage);
                        return DetectorResult.Failure($"停止采集失败，无法执行暗场校正 | Failed to stop acquisition: {stopResult.ErrorMessage}");
                    }
                }

                var result = await detector.DarkCorrectionAsync(frameCount, cancellationToken);
                if (!result.IsSuccess)
                {
                    _lastError = result;
                    _logger?.Error(result.Exception, "暗场校正失败：{Message} | Dark correction failed: {Message}", result.ErrorMessage);
                }

                // 如果之前在采集，恢复采集 | Resume acquisition if it was running before
                if (wasAcquiring)
                {
                    _logger?.Info("暗场校正完成，恢复连续采集 | Dark correction done, resuming continuous acquisition");
                    var startResult = await detector.StartAcquisitionAsync(cancellationToken);
                    if (!startResult.IsSuccess)
                    {
                        _logger?.Warn("恢复采集失败：{Message} | Failed to resume acquisition: {Message}", startResult.ErrorMessage);
                    }
                }

                return result;
            }
            catch (Exception ex)
            {
                var errorMsg = $"服务层暗场校正异常 | Service layer dark correction exception: {ex.Message}";
                _logger?.Error(ex, errorMsg);
                var errorResult = DetectorResult.Failure(errorMsg, ex, -1);
                _lastError = errorResult;
                return errorResult;
            }
        }

        /// <summary>
        /// 增益校正（亮场校正）| Gain correction (bright field correction)
        /// </summary>
        /// <param name="frameCount">采集帧数 | Frame count</param>
        /// <param name="cancellationToken">取消令牌 | Cancellation token</param>
        /// <returns>操作结果 | Operation result</returns>
        public async Task<DetectorResult> GainCorrectionAsync(int frameCount = 10, CancellationToken cancellationToken = default)
        {
            try
            {
                _logger?.Info("服务层：执行亮场校正，帧数：{FrameCount} | Service layer: Executing gain correction, frame count: {FrameCount}", frameCount);
                var detector = GetDetectorOrThrow();

                // 如果正在采集，先停止（XISL SDK 不允许采集中执行校正）| Stop acquisition first if running
                bool wasAcquiring = detector.Status == DetectorStatus.Acquiring;
                if (wasAcquiring)
                {
                    _logger?.Info("探测器正在采集，先停止采集再执行亮场校正 | Detector is acquiring, stopping before gain correction");
                    var stopResult = await detector.StopAcquisitionAsync(cancellationToken);
                    if (!stopResult.IsSuccess)
                    {
                        _lastError = stopResult;
                        _logger?.Error(stopResult.Exception, "停止采集失败，无法执行亮场校正：{Message} | Failed to stop acquisition, cannot perform gain correction: {Message}", stopResult.ErrorMessage);
                        return DetectorResult.Failure($"停止采集失败，无法执行亮场校正 | Failed to stop acquisition: {stopResult.ErrorMessage}");
                    }
                }

                var result = await detector.GainCorrectionAsync(frameCount, cancellationToken);
                if (!result.IsSuccess)
                {
                    _lastError = result;
                    _logger?.Error(result.Exception, "亮场校正失败：{Message} | Gain correction failed: {Message}", result.ErrorMessage);
                }

                // 如果之前在采集，恢复采集 | Resume acquisition if it was running before
                if (wasAcquiring)
                {
                    _logger?.Info("亮场校正完成，恢复连续采集 | Gain correction done, resuming continuous acquisition");
                    var startResult = await detector.StartAcquisitionAsync(cancellationToken);
                    if (!startResult.IsSuccess)
                    {
                        _logger?.Warn("恢复采集失败：{Message} | Failed to resume acquisition: {Message}", startResult.ErrorMessage);
                    }
                }

                return result;
            }
            catch (Exception ex)
            {
                var errorMsg = $"服务层亮场校正异常 | Service layer gain correction exception: {ex.Message}";
                _logger?.Error(ex, errorMsg);
                var errorResult = DetectorResult.Failure(errorMsg, ex, -1);
                _lastError = errorResult;
                return errorResult;
            }
        }

        /// <summary>
        /// 坏像素校正 | Bad pixel correction
        /// </summary>
        /// <param name="cancellationToken">取消令牌 | Cancellation token</param>
        /// <returns>操作结果 | Operation result</returns>
        public async Task<DetectorResult> BadPixelCorrectionAsync(CancellationToken cancellationToken = default)
        {
            try
            {
                _logger?.Info("服务层：执行坏像素校正 | Service layer: Executing bad pixel correction");
                var detector = GetDetectorOrThrow();

                // 如果正在采集，先停止（XISL SDK 不允许采集中执行校正）| Stop acquisition first if running
                bool wasAcquiring = detector.Status == DetectorStatus.Acquiring;
                if (wasAcquiring)
                {
                    _logger?.Info("探测器正在采集，先停止采集再执行坏像素校正 | Detector is acquiring, stopping before bad pixel correction");
                    var stopResult = await detector.StopAcquisitionAsync(cancellationToken);
                    if (!stopResult.IsSuccess)
                    {
                        _lastError = stopResult;
                        _logger?.Error(stopResult.Exception, "停止采集失败，无法执行坏像素校正：{Message} | Failed to stop acquisition, cannot perform bad pixel correction: {Message}", stopResult.ErrorMessage);
                        return DetectorResult.Failure($"停止采集失败，无法执行坏像素校正 | Failed to stop acquisition: {stopResult.ErrorMessage}");
                    }
                }

                var result = await detector.BadPixelCorrectionAsync(cancellationToken);
                if (!result.IsSuccess)
                {
                    _lastError = result;
                    _logger?.Error(result.Exception, "坏像素校正失败：{Message} | Bad pixel correction failed: {Message}", result.ErrorMessage);
                }

                // 如果之前在采集，恢复采集 | Resume acquisition if it was running before
                if (wasAcquiring)
                {
                    _logger?.Info("坏像素校正完成，恢复连续采集 | Bad pixel correction done, resuming continuous acquisition");
                    var startResult = await detector.StartAcquisitionAsync(cancellationToken);
                    if (!startResult.IsSuccess)
                    {
                        _logger?.Warn("恢复采集失败：{Message} | Failed to resume acquisition: {Message}", startResult.ErrorMessage);
                    }
                }

                return result;
            }
            catch (Exception ex)
            {
                var errorMsg = $"服务层坏像素校正异常 | Service layer bad pixel correction exception: {ex.Message}";
                _logger?.Error(ex, errorMsg);
                var errorResult = DetectorResult.Failure(errorMsg, ex, -1);
                _lastError = errorResult;
                return errorResult;
            }
        }

        /// <summary>
        /// 执行自动校正（暗场+增益+坏像素）| Execute auto correction (dark + gain + bad pixel)
        /// </summary>
        /// <param name="frameCount">采集帧数 | Frame count</param>
        /// <param name="cancellationToken">取消令牌 | Cancellation token</param>
        /// <returns>操作结果 | Operation result</returns>
        public async Task<DetectorResult> AutoCorrectionAsync(int frameCount = 10, CancellationToken cancellationToken = default)
        {
            try
            {
                _logger?.Info("服务层：执行自动校正，帧数：{FrameCount} | Service layer: Executing auto correction, frame count: {FrameCount}", frameCount);
                var detector = GetDetectorOrThrow();
                var result = await detector.AutoCorrectionAsync(frameCount, cancellationToken);
                if (!result.IsSuccess)
                {
                    _lastError = result;
                    _logger?.Error(result.Exception, "自动校正失败：{Message} | Auto correction failed: {Message}", result.ErrorMessage);
                }
                return result;
            }
            catch (Exception ex)
            {
                var errorMsg = $"服务层自动校正异常 | Service layer auto correction exception: {ex.Message}";
                _logger?.Error(ex, errorMsg);
                var errorResult = DetectorResult.Failure(errorMsg, ex, -1);
                _lastError = errorResult;
                return errorResult;
            }
        }

        /// <summary>
        /// 应用探测器参数（Binning/PGA/帧率统一下发）| Apply detector parameters (Binning/PGA/FrameRate)
        /// </summary>
        public async Task<DetectorResult> ApplyParametersAsync(int binningIndex, int pga, decimal frameRate, CancellationToken cancellationToken = default)
        {
            try
            {
                _logger?.Info("服务层：应用参数，Binning={Binning}，PGA={PGA}，帧率={FrameRate} | Service layer: Applying parameters",
                    binningIndex, pga, frameRate);

                var detector = GetDetectorOrThrow();

                // 如果正在采集，先停止 | Stop acquisition first if running
                bool wasAcquiring = detector.Status == DetectorStatus.Acquiring;
                if (wasAcquiring)
                {
                    _logger?.Info("探测器正在采集，先停止采集再应用参数 | Detector is acquiring, stopping before applying parameters");
                    var stopResult = await detector.StopAcquisitionAsync(cancellationToken);
                    if (!stopResult.IsSuccess)
                    {
                        _lastError = stopResult;
                        _logger?.Error(stopResult.Exception, "停止采集失败，无法应用参数：{Message} | Failed to stop acquisition, cannot apply parameters: {Message}", stopResult.ErrorMessage);
                        return DetectorResult.Failure($"停止采集失败，无法应用参数 | Failed to stop acquisition, cannot apply parameters: {stopResult.ErrorMessage}");
                    }
                }

                // 通过统一接口下发参数（不依赖具体探测器类型）| Apply parameters via unified interface (no dependency on specific detector type)
                var result = await detector.ApplyParametersAsync(binningIndex, pga, frameRate, cancellationToken);
                if (!result.IsSuccess)
                {
                    _lastError = result;
                    _logger?.Error(result.Exception, "应用参数失败：{Message} | Apply parameters failed: {Message}", result.ErrorMessage);
                }
                else
                {
                    _logger?.Info("参数应用成功 | Parameters applied successfully");
                }

                // 如果之前在采集，恢复采集 | Resume acquisition if it was running before
                if (wasAcquiring)
                {
                    _logger?.Info("参数应用完成，恢复连续采集 | Parameters applied, resuming continuous acquisition");
                    var startResult = await detector.StartAcquisitionAsync(cancellationToken);
                    if (!startResult.IsSuccess)
                    {
                        _logger?.Warn("恢复采集失败：{Message}（参数已成功应用）| Failed to resume acquisition: {Message} (parameters were applied successfully)", startResult.ErrorMessage);
                    }
                }

                return result;
            }
            catch (Exception ex)
            {
                var errorMsg = $"服务层应用参数异常 | Service layer apply parameters exception: {ex.Message}";
                _logger?.Error(ex, errorMsg);
                var errorResult = DetectorResult.Failure(errorMsg, ex, -1);
                _lastError = errorResult;
                return errorResult;
            }
        }

        /// <summary>
        /// 保存当前配置到文件 | Save current configuration to file
        /// </summary>
        public void SaveParameters(int binningIndex, int pga, decimal frameRate, int avgFrames)
        {
            try
            {
                _logger?.Info("保存探测器参数，Binning={Binning}，PGA={PGA}，帧率={FrameRate}，帧合并={AvgFrames} | Saving detector parameters",
                    binningIndex, pga, frameRate, avgFrames);
                ConfigLoader.SaveParameters(binningIndex, pga, frameRate, avgFrames);
                _logger?.Info("探测器参数保存成功 | Detector parameters saved successfully");
            }
            catch (Exception ex)
            {
                _logger?.Error(ex, "保存探测器参数失败：{Message} | Failed to save detector parameters: {Message}", ex.Message);
            }
        }

        /// <summary>
        /// 获取探测器信息 | Get detector information
        /// </summary>
        /// <returns>探测器信息 | Detector information</returns>
        public DetectorInfo GetInfo()
        {
            var detector = GetDetectorOrThrow();
            return detector.GetInfo();
        }

        /// <summary>
        /// 获取最后的错误信息 | Get last error information
        /// </summary>
        /// <returns>错误结果 | Error result</returns>
        public DetectorResult GetLastError()
        {
            return _lastError ?? DetectorResult.Success();
        }

        /// <summary>
        /// 获取当前探测器配置 | Get current detector configuration
        /// 未初始化时尝试从配置文件加载（仅读取配置，不创建探测器实例）
        /// </summary>
        public DetectorConfig GetCurrentConfig()
        {
            if (_config != null) return _config;

            // 未初始化时，尝试从配置文件加载以提供 UI 选项 | If not initialized, try loading from config for UI options
            try
            {
                var configResult = ConfigLoader.LoadConfiguration();
                if (configResult.IsSuccess)
                {
                    _config = configResult.Data;
                    return _config;
                }
            }
            catch
            {
                // 忽略加载异常，返回 null | Ignore load exception, return null
            }
            return null;
        }

        /// <summary>
        /// 获取当前探测器的校正能力描述 | Get correction capabilities of current detector
        /// 未初始化时返回基于配置文件的默认值
        /// </summary>
        public CorrectionCapabilities GetCorrectionCapabilities()
        {
            lock (_lock)
            {
                if (_detector != null)
                {
                    return _detector.GetCorrectionCapabilities();
                }
            }

            // 未初始化时从配置文件构建默认值 | Build default from config when not initialized
            var config = GetCurrentConfig();
            return new CorrectionCapabilities
            {
                DarkFrameCount = config?.DarkCorrectionFrameCount ?? 64,
                GainFrameCount = config?.GainCorrectionFrameCount ?? 64
            };
        }

        /// <summary>
        /// 获取探测器实例或抛出异常 | Get detector instance or throw exception
        /// </summary>
        /// <returns>探测器实例 | Detector instance</returns>
        /// <exception cref="InvalidOperationException">探测器未初始化 | Detector not initialized</exception>
        private IAreaDetector GetDetectorOrThrow()
        {
            lock (_lock)
            {
                if (_detector == null)
                {
                    throw new InvalidOperationException("探测器未初始化，请先调用 InitializeAsync | Detector not initialized, please call InitializeAsync first");
                }
                return _detector;
            }
        }

        /// <summary>
        /// 释放资源 | Dispose resources
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// 释放资源 | Dispose resources
        /// </summary>
        /// <param name="disposing">是否释放托管资源 | Whether to dispose managed resources</param>
        protected virtual void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                if (disposing)
                {
                    // 带超时保护的资源释放，避免退出时无限阻塞
                    // Dispose with timeout protection to avoid infinite blocking on exit
                    const int disposeTimeoutMs = 5000; // 5 秒总超时 | 5 seconds total timeout

                    try
                    {
                        IAreaDetector detector;
                        lock (_lock)
                        {
                            detector = _detector;
                        }

                        if (detector != null)
                        {
                            // 仅在正在采集时才停止采集 | Only stop acquisition if currently acquiring
                            if (detector.Status == DetectorStatus.Acquiring)
                            {
                                _logger?.Info("Dispose：探测器正在采集，尝试停止 | Dispose: Detector is acquiring, attempting to stop");
                                using var cts = new CancellationTokenSource(disposeTimeoutMs);
                                var stopTask = Task.Run(async () => await detector.StopAcquisitionAsync(cts.Token), cts.Token);
                                if (!stopTask.Wait(disposeTimeoutMs))
                                {
                                    _logger?.Warn("Dispose：停止采集超时，强制继续释放 | Dispose: Stop acquisition timeout, forcing cleanup");
                                }
                            }

                            // 直接释放探测器资源（不再调用 DisconnectAsync 避免重复停止）
                            // Directly dispose detector resources (skip DisconnectAsync to avoid redundant stop)
                            lock (_lock)
                            {
                                _detector?.Dispose();
                                _detector = null;
                            }
                            _config = null;
                            _logger?.Info("Dispose：探测器资源已释放 | Dispose: Detector resources disposed");
                        }
                    }
                    catch (OperationCanceledException)
                    {
                        _logger?.Warn("Dispose：操作已取消，强制释放资源 | Dispose: Operation cancelled, forcing resource cleanup");
                        lock (_lock)
                        {
                            _detector?.Dispose();
                            _detector = null;
                        }
                        _config = null;
                    }
                    catch (AggregateException ex)
                    {
                        _logger?.Warn($"Dispose：聚合异常，强制释放资源 | Dispose: Aggregate exception, forcing cleanup: {ex.InnerException?.Message ?? ex.Message}");
                        lock (_lock)
                        {
                            _detector?.Dispose();
                            _detector = null;
                        }
                        _config = null;
                    }
                    catch (Exception ex)
                    {
                        _logger?.Error(ex, "Dispose：释放探测器资源异常 | Dispose: Exception disposing detector resources");
                        lock (_lock)
                        {
                            try { _detector?.Dispose(); } catch { /* 忽略 | Ignore */ }
                            _detector = null;
                        }
                        _config = null;
                    }
                }
                _disposed = true;
            }
        }
    }
}