using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using OrpaonVision.Core.Results;
using OrpaonVision.SiteApp.Runtime.Contracts;
using OrpaonVision.SiteApp.Runtime.Services;
using System.Collections.Concurrent;
using System.Runtime.InteropServices;
using MvCamCtrl.NET;

namespace OrpaonVision.SiteApp.Runtime.Services;

/// <summary>
/// 海康相机服务实现（支持真实和模拟模式）。
/// </summary>
public sealed class RealHikCameraService : IHikCameraService, IDisposable
{
    private readonly ILogger<RealHikCameraService> _logger;
    private readonly HikCameraOptions _options;
    private readonly object _lockObject = new();
    private HikCameraDevice? _currentDevice;
    private bool _isConnected;
    private bool _isGrabbing;
    private Timer? _frameTimer;
    private readonly ConcurrentQueue<byte[]> _frameQueue = new();
    private MyCamera? _camera;
    private bool _sdkInitialized;
    private IntPtr _deviceHandle = IntPtr.Zero;
    private MyCamera.MV_CC_DEVICE_INFO? _deviceInfo;
    private int _reconnectAttempts = 0;

    /// <summary>
    /// 构造函数。
    /// </summary>
    public RealHikCameraService(ILogger<RealHikCameraService> logger, IOptions<HikCameraOptions> options)
    {
        _logger = logger;
        _options = options.Value;
        _logger.LogInformation("海康相机服务已初始化（模式: {RunMode}）", _options.RunMode);
        
        if (_options.RunMode == "Real")
        {
            InitializeSdk();
        }
    }

    /// <inheritdoc />
    public bool IsConnected => _isConnected;

    /// <inheritdoc />
    public HikCameraDevice? CurrentDevice => _currentDevice;

    /// <inheritdoc />
    public event Action<byte[], DateTime>? OnImageReceived;

    /// <inheritdoc />
    public event Action<bool, string>? OnConnectionStateChanged;

    /// <summary>
    /// 初始化海康SDK。
    /// </summary>
    private void InitializeSdk()
    {
        try
        {
            if (_sdkInitialized)
            {
                return;
            }

            _logger.LogInformation("正在初始化海康SDK...");

            // 初始化海康SDK
            var result = MyCamera.MV_CC_Initialize_NET();
            if (result != MyCamera.MV_OK)
            {
                _logger.LogError("海康SDK初始化失败，错误代码: {ErrorCode}", result);
                return;
            }

            _camera = new MyCamera();
            _sdkInitialized = true;
            _logger.LogInformation("海康SDK初始化成功");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "初始化海康SDK失败，将回退到模拟模式");
        }
    }

    /// <inheritdoc />
    public Result<IReadOnlyList<HikCameraDevice>> EnumerateDevices()
    {
        try
        {
            _logger.LogInformation("正在枚举海康相机设备...");

            if (_options.RunMode != "Real" || !_sdkInitialized || _camera == null)
            {
                _logger.LogWarning("真实模式未启用或SDK未初始化，返回模拟设备");
                return GetMockDevices();
            }

            // 使用海康SDK枚举设备
            var deviceList = new MyCamera.MV_CC_DEVICE_INFO_LIST();
            var result = _camera.MV_CC_EnumDevices_NET(MyCamera.MV_GIGE_DEVICE | MyCamera.MV_USB_DEVICE, ref deviceList);
            
            if (result != MyCamera.MV_OK)
            {
                _logger.LogError("枚举海康设备失败，错误代码: {ErrorCode}", result);
                return GetMockDevices();
            }

            var devices = new List<HikCameraDevice>();
            
            for (uint i = 0; i < deviceList.nDeviceNum; i++)
            {
                var deviceInfo = deviceList.MvDeviceInfo[i];
                var device = new HikCameraDevice
                {
                    SerialNumber = Marshal.PtrToStringAnsi(deviceInfo.SpecialInfo.stGigEInfo.chSerialNumber) ?? $"HK_DEVICE_{i}",
                    DeviceName = Marshal.PtrToStringAnsi(deviceInfo.SpecialInfo.stGigEInfo.chUserDefinedName) ?? $"海康相机_{i}",
                    IpAddress = Marshal.PtrToStringAnsi(deviceInfo.SpecialInfo.stGigEInfo.nCurrentIp) ?? "Unknown",
                    MacAddress = Marshal.PtrToStringAnsi(deviceInfo.SpecialInfo.stGigEInfo.nCurrentMac) ?? "Unknown",
                    IsConnected = true
                };
                
                devices.Add(device);
                _logger.LogInformation("发现海康设备: {DeviceName} ({SerialNumber})", device.DeviceName, device.SerialNumber);
            }

            if (devices.Count == 0)
            {
                _logger.LogInformation("未发现海康设备，返回模拟设备");
                return GetMockDevices();
            }

            _logger.LogInformation("成功枚举到 {Count} 个海康设备", devices.Count);
            return Result.Success<IReadOnlyList<HikCameraDevice>>(devices);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "枚举海康设备失败");
            return Result.Fail<IReadOnlyList<HikCameraDevice>>("HIK_ENUM_FAILED", "枚举海康设备失败");
        }
    }

    /// <inheritdoc />
    public Result ConnectToDevice(HikCameraDevice device)
    {
        if (device == null)
        {
            return Result.Fail("HIK_CAMERA_DEVICE_NULL", "相机设备不能为空。");
        }

        lock (_lockObject)
        {
            try
            {
                if (_isConnected)
                {
                    return Result.Fail("HIK_CAMERA_ALREADY_CONNECTED", "相机已连接，请先断开。");
                }

                _logger.LogInformation("正在连接相机设备: {SerialNumber}", device.SerialNumber);

                if (_options.RunMode != "Real" || !_sdkInitialized)
                {
                    _logger.LogWarning("真实模式未启用或SDK未初始化，使用模拟连接");
                    return MockConnect(device);
                }

                // 查找目标设备信息
                MyCamera.MV_CC_DEVICE_INFO targetDeviceInfo = default;
                bool foundDevice = false;
                
                var deviceList = new MyCamera.MV_CC_DEVICE_INFO_LIST();
                var enumResult = _camera.MV_CC_EnumDevices_NET(MyCamera.MV_GIGE_DEVICE | MyCamera.MV_USB_DEVICE, ref deviceList);
                
                if (enumResult == MyCamera.MV_OK)
                {
                    for (uint i = 0; i < deviceList.nDeviceNum; i++)
                    {
                        var deviceInfo = deviceList.MvDeviceInfo[i];
                        var serialNumber = Marshal.PtrToStringAnsi(deviceInfo.SpecialInfo.stGigEInfo.chSerialNumber) ?? "";
                        var ipAddress = Marshal.PtrToStringAnsi(deviceInfo.SpecialInfo.stGigEInfo.nCurrentIp) ?? "";
                        
                        if (serialNumber.Equals(device.SerialNumber, StringComparison.OrdinalIgnoreCase) ||
                            ipAddress.Equals(device.IpAddress, StringComparison.OrdinalIgnoreCase))
                        {
                            targetDeviceInfo = deviceInfo;
                            foundDevice = true;
                            break;
                        }
                    }
                }

                if (!foundDevice)
                {
                    _logger.LogError("未找到指定的相机设备: {SerialNumber}", device.SerialNumber);
                    return Result.Fail("HIK_DEVICE_NOT_FOUND", $"未找到指定的相机设备: {device.SerialNumber}");
                }

                // 创建设备句柄
                var createResult = _camera.MV_CC_CreateHandle_NET(ref targetDeviceInfo, out _deviceHandle);
                if (createResult != MyCamera.MV_OK)
                {
                    _logger.LogError("创建相机句柄失败，错误代码: {ErrorCode}", createResult);
                    return Result.Fail("HIK_CREATE_HANDLE_FAILED", $"创建相机句柄失败，错误代码: {createResult}");
                }

                // 打开设备
                var openResult = _camera.MV_CC_OpenDevice_NET(_deviceHandle, MyCamera.MV_ACCESS_Exclusive, 0);
                if (openResult != MyCamera.MV_OK)
                {
                    _logger.LogError("打开相机设备失败，错误代码: {ErrorCode}", openResult);
                    _camera.MV_CC_DestroyHandle_NET(_deviceHandle);
                    _deviceHandle = IntPtr.Zero;
                    return Result.Fail("HIK_OPEN_DEVICE_FAILED", $"打开相机设备失败，错误代码: {openResult}");
                }

                // 获取设备信息
                _deviceInfo = targetDeviceInfo;
                var deviceInfoResult = GetDeviceInfo();
                if (!deviceInfoResult.Succeeded)
                {
                    _camera.MV_CC_CloseDevice_NET(_deviceHandle);
                    _camera.MV_CC_DestroyHandle_NET(_deviceHandle);
                    _deviceHandle = IntPtr.Zero;
                    _deviceInfo = null;
                    return Result.Fail(deviceInfoResult.Code, deviceInfoResult.Message, deviceInfoResult.Errors.ToArray());
                }

                _currentDevice = new HikCameraDevice
                {
                    SerialNumber = device.SerialNumber,
                    DeviceName = device.DeviceName,
                    IpAddress = device.IpAddress,
                    SubnetMask = device.SubnetMask,
                    DefaultGateway = device.DefaultGateway,
                    MacAddress = device.MacAddress,
                    FirmwareVersion = device.FirmwareVersion,
                    IsConnected = true,
                    ConnectedAt = DateTime.UtcNow
                };
                _isConnected = true;
                _reconnectAttempts = 0;

                _logger.LogInformation("相机连接成功: {SerialNumber}", device.SerialNumber);
                OnConnectionStateChanged?.Invoke(true, $"已连接到 {device.DeviceName}");

                return Result.Success(message: $"相机 {device.DeviceName} 连接成功。");
            }
            catch (Exception ex)
            {
                var traceId = Guid.NewGuid().ToString("N");
                _logger.LogError(ex, "连接相机失败。TraceId: {TraceId}", traceId);
                var result = Result.FromException(ex, "HIK_CAMERA_CONNECT_FAILED", "连接相机失败。", traceId);
                return Result.FailWithTrace(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
            }
        }
    }

    /// <inheritdoc />
    public Result ConnectToDevice(string serialNumberOrIp)
    {
        var devicesResult = EnumerateDevices();
        if (!devicesResult.Succeeded)
        {
            return Result.Fail(devicesResult.Code, devicesResult.Message, devicesResult.Errors.ToArray());
        }

        var targetDevice = devicesResult.Data.FirstOrDefault(d => 
            d.SerialNumber.Equals(serialNumberOrIp, StringComparison.OrdinalIgnoreCase) ||
            d.IpAddress.Equals(serialNumberOrIp, StringComparison.OrdinalIgnoreCase));

        if (targetDevice == null)
        {
            return Result.Fail("HIK_CAMERA_NOT_FOUND", $"未找到序列号或IP为 {serialNumberOrIp} 的相机设备。");
        }

        return ConnectToDevice(targetDevice);
    }

    /// <inheritdoc />
    public Result Disconnect()
    {
        lock (_lockObject)
        {
            try
            {
                if (!_isConnected)
                {
                    return Result.Success(message: "相机未连接。");
                }

                _logger.LogInformation("正在断开相机连接...");

                // 停止采集
                if (_isGrabbing)
                {
                    StopGrabbing();
                }

                // 实际实现需要调用海康SDK的MV_CC_CloseDevice、MV_CC_DestroyHandle等函数
                if (_options.RunMode == "Real" && _deviceHandle != IntPtr.Zero && _camera != null)
                {
                    // 关闭设备
                    var closeResult = _camera.MV_CC_CloseDevice_NET(_deviceHandle);
                    if (closeResult != MyCamera.MV_OK)
                    {
                        _logger.LogWarning("关闭相机设备失败，错误代码: {ErrorCode}", closeResult);
                    }

                    // 销毁句柄
                    var destroyResult = _camera.MV_CC_DestroyHandle_NET(_deviceHandle);
                    if (destroyResult != MyCamera.MV_OK)
                    {
                        _logger.LogWarning("销毁相机句柄失败，错误代码: {ErrorCode}", destroyResult);
                    }

                    _deviceHandle = IntPtr.Zero;
                    _deviceInfo = null;
                }

                Thread.Sleep(100);

                var deviceName = _currentDevice?.DeviceName ?? "未知设备";
                _currentDevice = null;
                _isConnected = false;

                _logger.LogInformation("相机断开连接成功");
                OnConnectionStateChanged?.Invoke(false, $"已断开与 {deviceName} 的连接");

                return Result.Success(message: "相机断开连接成功。");
            }
            catch (Exception ex)
            {
                var traceId = Guid.NewGuid().ToString("N");
                _logger.LogError(ex, "断开相机连接失败。TraceId: {TraceId}", traceId);
                var result = Result.FromException(ex, "HIK_CAMERA_DISCONNECT_FAILED", "断开相机连接失败。", traceId);
                return Result.FailWithTrace(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
            }
        }
    }

    /// <inheritdoc />
    public Result SetCameraParameters(int width, int height, string pixelFormat, int triggerMode = 0)
    {
        lock (_lockObject)
        {
            try
            {
                if (!_isConnected)
                {
                    return Result.Fail("HIK_CAMERA_NOT_CONNECTED", "相机未连接。");
                }

                _logger.LogInformation("正在设置相机参数: {Width}x{Height}, {PixelFormat}, TriggerMode: {TriggerMode}", 
                    width, height, pixelFormat, triggerMode);

                if (_options.RunMode != "Real" || _deviceHandle == IntPtr.Zero || _camera == null)
                {
                    _logger.LogDebug("模拟模式：设置相机参数");
                    return Result.Success(message: "相机参数设置成功（模拟模式）。");
                }

                // 设置图像宽度
                var widthResult = _camera.MV_CC_SetIntValue_NET(_deviceHandle, "Width", width);
                if (widthResult != MyCamera.MV_OK)
                {
                    _logger.LogWarning("设置图像宽度失败，错误代码: {ErrorCode}", widthResult);
                }

                // 设置图像高度
                var heightResult = _camera.MV_CC_SetIntValue_NET(_deviceHandle, "Height", height);
                if (heightResult != MyCamera.MV_OK)
                {
                    _logger.LogWarning("设置图像高度失败，错误代码: {ErrorCode}", heightResult);
                }

                // 设置像素格式
                var pixelFormatResult = _camera.MV_CC_SetEnumValue_NET(_deviceHandle, "PixelFormat", GetPixelFormatValue(pixelFormat));
                if (pixelFormatResult != MyCamera.MV_OK)
                {
                    _logger.LogWarning("设置像素格式失败，错误代码: {ErrorCode}", pixelFormatResult);
                }

                // 设置触发模式
                var triggerModeResult = _camera.MV_CC_SetEnumValue_NET(_deviceHandle, "TriggerMode", triggerMode);
                if (triggerModeResult != MyCamera.MV_OK)
                {
                    _logger.LogWarning("设置触发模式失败，错误代码: {ErrorCode}", triggerModeResult);
                }

                Thread.Sleep(100); // 等待参数生效

                _logger.LogInformation("相机参数设置成功");
                return Result.Success(message: "相机参数设置成功。");
            }
            catch (Exception ex)
            {
                var traceId = Guid.NewGuid().ToString("N");
                _logger.LogError(ex, "设置相机参数失败。TraceId: {TraceId}", traceId);
                var result = Result.FromException(ex, "HIK_CAMERA_SET_PARAMS_FAILED", "设置相机参数失败。", traceId);
                return Result.FailWithTrace(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
            }
        }
    }

    /// <inheritdoc />
    public Result StartGrabbing()
    {
        lock (_lockObject)
        {
            try
            {
                if (!_isConnected)
                {
                    return Result.Fail("HIK_CAMERA_NOT_CONNECTED", "相机未连接。");
                }

                if (_isGrabbing)
                {
                    return Result.Success(message: "相机已在采集中。");
                }

                _logger.LogInformation("正在开始图像采集...");

                if (_options.RunMode != "Real" || _deviceHandle == IntPtr.Zero || _camera == null)
                {
                    _logger.LogDebug("模拟模式：开始图像采集");
                    _isGrabbing = true;
                    _frameQueue.Clear();
                    
                    // 启动定时器生成模拟帧
                    _frameTimer = new Timer(GenerateMockFrame, null, TimeSpan.Zero, TimeSpan.FromMilliseconds(33)); // 约30fps
                    
                    return Result.Success(message: "图像采集启动成功（模拟模式）。");
                }

                // 开始采集
                var startResult = _camera.MV_CC_StartGrabbing_NET(_deviceHandle);
                if (startResult != MyCamera.MV_OK)
                {
                    _logger.LogError("启动图像采集失败，错误代码: {ErrorCode}", startResult);
                    return Result.Fail("HIK_START_GRABBING_FAILED", $"启动图像采集失败，错误代码: {startResult}");
                }

                Thread.Sleep(100); // 等待采集启动

                _isGrabbing = true;
                _frameQueue.Clear();

                // 启动定时器获取图像帧
                _frameTimer = new Timer(GetFrameFromCamera, null, TimeSpan.Zero, TimeSpan.FromMilliseconds(33)); // 约30fps

                _logger.LogInformation("图像采集已启动");
                return Result.Success(message: "图像采集启动成功。");
            }
            catch (Exception ex)
            {
                var traceId = Guid.NewGuid().ToString("N");
                _logger.LogError(ex, "启动图像采集失败。TraceId: {TraceId}", traceId);
                var result = Result.FromException(ex, "HIK_CAMERA_START_GRAB_FAILED", "启动图像采集失败。", traceId);
                return Result.FailWithTrace(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
            }
        }
    }

    /// <inheritdoc />
    public Result StopGrabbing()
    {
        lock (_lockObject)
        {
            try
            {
                if (!_isGrabbing)
                {
                    return Result.Success(message: "相机未在采集状态。");
                }

                _logger.LogInformation("正在停止图像采集...");

                // 停止定时器
                _frameTimer?.Dispose();
                _frameTimer = null;

                if (_options.RunMode == "Real" && _deviceHandle != IntPtr.Zero && _camera != null)
                {
                    var stopResult = _camera.MV_CC_StopGrabbing_NET(_deviceHandle);
                    if (stopResult != MyCamera.MV_OK)
                    {
                        _logger.LogWarning("停止图像采集失败，错误代码: {ErrorCode}", stopResult);
                    }
                }

                Thread.Sleep(50); // 等待采集停止

                _isGrabbing = false;
                _frameQueue.Clear();

                _logger.LogInformation("图像采集已停止");
                return Result.Success(message: "图像采集停止成功。");
            }
            catch (Exception ex)
            {
                var traceId = Guid.NewGuid().ToString("N");
                _logger.LogError(ex, "停止图像采集失败。TraceId: {TraceId}", traceId);
                var result = Result.FromException(ex, "HIK_CAMERA_STOP_GRAB_FAILED", "停止图像采集失败。", traceId);
                return Result.FailWithTrace(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
            }
        }
    }

    /// <inheritdoc />
    public Result TriggerSoftware()
    {
        lock (_lockObject)
        {
            try
            {
                if (!_isConnected)
                {
                    return Result.Fail("HIK_CAMERA_NOT_CONNECTED", "相机未连接。");
                }

                if (!_isGrabbing)
                {
                    return Result.Fail("HIK_CAMERA_NOT_GRABBING", "相机未在采集状态。");
                }

                if (_options.RunMode == "Real" && _camera != null)
                {
                    _logger.LogDebug("执行软件触发");
                    var triggerResult = _camera.MV_CC_SetCommandValue_NET(_deviceHandle, "TriggerSoftware");
                    if (triggerResult != MyCamera.MV_OK)
                    {
                        _logger.LogWarning("软件触发失败，错误代码: {ErrorCode}", triggerResult);
                        return Result.Fail("HIK_CAMERA_TRIGGER_FAILED", $"软件触发失败，错误代码: {triggerResult}");
                    }
                }

                return Result.Success(message: "软件触发执行成功。");
            }
            catch (Exception ex)
            {
                var traceId = Guid.NewGuid().ToString("N");
                _logger.LogError(ex, "软件触发失败。TraceId: {TraceId}", traceId);
                var result = Result.FromException(ex, "HIK_CAMERA_TRIGGER_FAILED", "软件触发失败。", traceId);
                return Result.FailWithTrace(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
            }
        }
    }

    /// <inheritdoc />
    public Result<byte[]> GetLatestFrame()
    {
        try
        {
            if (!_isGrabbing)
            {
                return Result<byte[]>.Fail("HIK_CAMERA_NOT_GRABBING", "相机未在采集状态。");
            }

            if (_frameQueue.TryDequeue(out var frame))
            {
                return Result<byte[]>.Success(frame, message: "获取图像帧成功。");
            }

            return Result<byte[]>.Fail("HIK_CAMERA_NO_FRAME", "暂无可用图像帧。");
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "获取图像帧失败。TraceId: {TraceId}", traceId);
            var result = Result.FromException(ex, "HIK_CAMERA_GET_FRAME_FAILED", "获取图像帧失败。", traceId);
            return Result<byte[]>.FailWithTrace(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
        }
    }

    /// <inheritdoc />
    public Result<CameraFrameDto> GetLatestFrameWithTimestamp()
    {
        var frameResult = GetLatestFrame();
        if (!frameResult.Succeeded)
        {
            return Result<CameraFrameDto>.Fail(frameResult.Code, frameResult.Message, frameResult.Errors.ToArray());
        }

        var now = DateTime.UtcNow;
        return Result<CameraFrameDto>.Success(new CameraFrameDto
        {
            FrameId = Guid.NewGuid(),
            CapturedAtUtc = now,
            CameraId = _currentDevice?.SerialNumber ?? string.Empty,
            ImageData = frameResult.Data,
            Timestamp = now,
            Width = _options.ImageWidth,
            Height = _options.ImageHeight,
            PixelFormat = _options.PixelFormat
        }, message: "获取图像帧成功。");
    }

    /// <summary>
    /// 从相机获取图像帧。
    /// </summary>
    private void GetFrameFromCamera(object? state)
    {
        try
        {
            if (!_isGrabbing || _options.RunMode != "Real" || !_sdkInitialized)
            {
                return;
            }

            if (_deviceHandle == IntPtr.Zero || _camera == null)
            {
                return;
            }

            // 获取一帧图像数据
            var frame = new MyCamera.MV_FRAME_OUT_INFO_EX();
            var imageBuffer = IntPtr.Zero;
            var getFrameResult = _camera.MV_CC_GetOneFrameTimeout_NET(_deviceHandle, ref frame, 1000);
            
            if (getFrameResult == MyCamera.MV_OK)
            {
                try
                {
                    // 转换图像数据为BGR格式
                    var convertResult = _camera.MV_CC_ConvertPixelType_NET(_deviceHandle, frame, MyCamera.MV_Gvsp_RGB8_Packed, ref imageBuffer);
                    
                    if (convertResult == MyCamera.MV_OK && imageBuffer != IntPtr.Zero)
                    {
                        var frameSize = frame.nWidth * frame.nHeight * 3; // BGR8Packed
                        var frameData = new byte[frameSize];
                        Marshal.Copy(imageBuffer, frameData, 0, frameSize);
                        
                        var timestamp = DateTime.UtcNow;

                        // 添加到队列
                        if (_frameQueue.Count < 10) // 限制队列大小防止内存溢出
                        {
                            _frameQueue.Enqueue(frameData);
                        }

                        // 触发事件
                        OnImageReceived?.Invoke(frameData, timestamp);
                        
                        // 释放图像缓冲区
                        _camera.MV_CC_FreeImageBuffer_NET(_deviceHandle, ref frame);
                    }
                    else
                    {
                        // 转换失败，使用模拟数据
                        GenerateMockFrame(null);
                    }
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "处理图像帧数据时发生异常");
                }
                finally
                {
                    // 确保释放缓冲区
                    if (imageBuffer != IntPtr.Zero)
                    {
                        _camera.MV_CC_FreeImageBuffer_NET(_deviceHandle, ref frame);
                    }
                }
            }
            else
            {
                // 获取图像失败，使用模拟数据
                GenerateMockFrame(null);
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "从相机获取图像帧失败");
        }
    }

    /// <summary>
    /// 生成模拟图像帧。
    /// </summary>
    private void GenerateMockFrame(object? state)
    {
        try
        {
            var width = _options.ImageWidth;
            var height = _options.ImageHeight;
            var frameSize = width * height * 3; // BGR8Packed
            var frameData = new byte[frameSize];

            // 填充模拟图像数据（简单的渐变图案）
            var random = new Random();
            for (int i = 0; i < frameSize; i += 3)
            {
                frameData[i] = (byte)(i % 256);       // B
                frameData[i + 1] = (byte)((i / 3) % 256); // G  
                frameData[i + 2] = (byte)random.Next(256);  // R
            }

            var timestamp = DateTime.UtcNow;

            // 添加到队列
            if (_frameQueue.Count < 10)
            {
                _frameQueue.Enqueue(frameData);
            }

            // 触发事件
            OnImageReceived?.Invoke(frameData, timestamp);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "生成模拟图像帧失败");
        }
    }

    /// <summary>
    /// 获取设备详细信息。
    /// </summary>
    private Result GetDeviceInfo()
    {
        try
        {
            if (_deviceHandle == IntPtr.Zero || !_deviceInfo.HasValue)
            {
                return Result.Fail("HIK_DEVICE_NOT_CONNECTED", "设备未连接");
            }

            var info = _deviceInfo.Value;
            
            // 获取设备型号名称
            var modelName = Marshal.PtrToStringAnsi(info.SpecialInfo.stGigEInfo.chModelName) ?? "Unknown";
            
            // 获取设备序列号
            var serialNumber = Marshal.PtrToStringAnsi(info.SpecialInfo.stGigEInfo.chSerialNumber) ?? "Unknown";
            
            // 获取设备用户定义名称
            var userDefinedName = Marshal.PtrToStringAnsi(info.SpecialInfo.stGigEInfo.chUserDefinedName) ?? "Unknown";
            
            // 获取固件版本
            var firmwareVersion = Marshal.PtrToStringAnsi(info.SpecialInfo.stGigEInfo.chFirmwareVersion) ?? "Unknown";
            
            // 获取IP地址
            var ipAddress = Marshal.PtrToStringAnsi(info.SpecialInfo.stGigEInfo.nCurrentIp) ?? "Unknown";
            
            // 获取子网掩码
            var subnetMask = Marshal.PtrToStringAnsi(info.SpecialInfo.stGigEInfo.nCurrentSubNet) ?? "Unknown";
            
            // 获取默认网关
            var defaultGateway = Marshal.PtrToStringAnsi(info.SpecialInfo.stGigEInfo.nDefaultGate) ?? "Unknown";
            
            // 获取MAC地址
            var macAddress = Marshal.PtrToStringAnsi(info.SpecialInfo.stGigEInfo.nCurrentMac) ?? "Unknown";

            // 更新当前设备信息
            if (_currentDevice != null)
            {
                _currentDevice.DeviceName = userDefinedName;
                _currentDevice.FirmwareVersion = firmwareVersion;
                _currentDevice.SubnetMask = subnetMask;
                _currentDevice.DefaultGateway = defaultGateway;
                _currentDevice.MacAddress = macAddress;
            }

            _logger.LogDebug("设备信息: {ModelName}, {SerialNumber}, {IpAddress}", modelName, serialNumber, ipAddress);
            return Result.Success(message: "获取设备信息成功。");
        }
        catch (Exception ex)
        {
            var traceId = Guid.NewGuid().ToString("N");
            _logger.LogError(ex, "获取设备信息失败。TraceId: {TraceId}", traceId);
            var result = Result.FromException(ex, "HIK_GET_DEVICE_INFO_FAILED", "获取设备信息失败。", traceId);
            return Result.FailWithTrace(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
        }
    }

    /// <summary>
    /// 模拟连接。
    /// </summary>
    private Result MockConnect(HikCameraDevice device)
    {
        _currentDevice = new HikCameraDevice
        {
            SerialNumber = device.SerialNumber,
            DeviceName = device.DeviceName,
            IpAddress = device.IpAddress,
            MacAddress = device.MacAddress,
            IsConnected = true,
            ConnectedAt = DateTime.UtcNow
        };
        _isConnected = true;

        _logger.LogInformation("模拟连接成功: {SerialNumber}", device.SerialNumber);
        OnConnectionStateChanged?.Invoke(true, $"模拟连接到 {device.DeviceName}");

        return Result.Success(message: $"相机 {device.DeviceName} 模拟连接成功。");
    }

    /// <summary>
    /// 获取模拟设备。
    /// </summary>
    private Result<IReadOnlyList<HikCameraDevice>> GetMockDevices()
    {
        var mockDevices = new List<HikCameraDevice>
        {
            new()
            {
                SerialNumber = "MOCK_HIK_001",
                DeviceName = "模拟海康相机_001",
                IpAddress = "192.168.1.100",
                MacAddress = "00:11:22:33:44:55",
                IsConnected = true
            },
            new()
            {
                SerialNumber = "MOCK_HIK_002", 
                DeviceName = "模拟海康相机_002",
                IpAddress = "192.168.1.101",
                MacAddress = "00:11:22:33:44:56",
                IsConnected = true
            }
        };

        _logger.LogInformation("返回 {Count} 个模拟设备", mockDevices.Count);
        return Result.Success<IReadOnlyList<HikCameraDevice>>(mockDevices);
    }

    /// <summary>
    /// 获取像素格式值。
    /// </summary>
    private uint GetPixelFormatValue(string pixelFormat)
    {
        return pixelFormat.ToUpperInvariant() switch
        {
            "BGR8PACKED" => MyCamera.MV_Gvsp_RGB8_Packed,
            "RGB8PACKED" => MyCamera.MV_Gvsp_RGB8_Packed,
            "MONO8" => MyCamera.MV_Gvsp_Mono8,
            "MONO16" => MyCamera.MV_Gvsp_Mono16,
            _ => MyCamera.MV_Gvsp_RGB8_Packed
        };
    }

    /// <summary>
    /// 自动重连。
    /// </summary>
    private async Task AutoReconnectAsync()
    {
        if (_reconnectAttempts >= _options.AutoReconnectCount)
        {
            _logger.LogWarning("已达到最大重连次数，停止重连");
            return;
        }

        _reconnectAttempts++;
        _logger.LogInformation("执行第 {Attempt} 次自动重连", _reconnectAttempts);

        await Task.Delay(_options.AutoReconnectIntervalMs);

        if (_currentDevice != null)
        {
            var connectResult = ConnectToDevice(_currentDevice.SerialNumber);
            if (connectResult.Succeeded)
            {
                _logger.LogInformation("自动重连成功");
                _reconnectAttempts = 0;
            }
            else
            {
                _logger.LogWarning("自动重连失败: {Error}", connectResult.Message);
                await AutoReconnectAsync();
            }
        }
    }

    /// <summary>
    /// 释放资源。
    /// </summary>
    public void Dispose()
    {
        try
        {
            // 停止定时器
            _frameTimer?.Dispose();
            _frameTimer = null;

            // 断开连接
            Disconnect();

            // 释放SDK
            if (_sdkInitialized && _options.RunMode == "Real")
            {
                _camera?.MV_CC_Finalize_NET();
                _camera?.Dispose();
                _camera = null;
                _sdkInitialized = false;
            }

            _logger.LogInformation("海康相机服务已释放");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "释放海康相机服务资源时发生错误");
        }
    }
}