using Check.Main.Common;
using Check.Main.Infer;
using Check.Main.Result;
using Check.Main.UI;
using OpenCvSharp;
using SkiaSharp;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.Json.Serialization;
using System.Threading.Tasks;
using System.Timers;
using System.Windows.Forms;

namespace Check.Main.Camera
{
    /// <summary>
    /// 静态全局相机管理器，负责所有相机的生命周期、配置应用和多相机同步
    /// </summary>
    /// 
    public static class CameraManager
    {
        //1、相机与UI管理----管理每台相机对象和对应的图像显示窗口。
        // 活动的相机实例字典（键值对），键 (string)：使用相机的名称，值 (HikvisionCamera)：存储实际的相机实例，{ get; } 创建了一个只读的公共属性
        public static Dictionary<string, HikvisionCamera> ActiveCameras { get; } = new Dictionary<string, HikvisionCamera>();

        // 相机对应的图像显示窗口字典
        //public static Dictionary<string, FormImageDisplay> CameraDisplays { get; } = new Dictionary<string, FormImageDisplay>();

        public static Dictionary<string, FormImageDisplay> OriginalImageDisplays { get; } = new Dictionary<string, FormImageDisplay>();//原始图像窗口
        public static Dictionary<string, FormImageDisplay> ResultImageDisplays { get; } = new Dictionary<string, FormImageDisplay>();//结果图像窗口

        //2、多相机同步逻辑
        // 【队列】一个产品需要多台相机拍完，才算完整。
        private static readonly Queue<ProductResult> ProductQueue = new Queue<ProductResult>();
        // 【（队列）锁】保证队列在多线程下安全
        private static readonly object QueueLock = new object();
        // 当前启用的相机数量，用于判断产品是否检测完毕
        private static int EnabledCameraCount = 0;
        //public static event EventHandler<DetectionResultEventArgs> OnDetectionCompleted;
        // public static bool IsDetectionRunning { get; private set; } = false;
        // 产品ID【计数器】
        private static long _productCounter = 0;
        // 用于同步计数器访问的锁，虽然long的自增是原子操作，但为清晰和未来扩展，使用锁是好习惯
        private static readonly object _counterLock = new object();

        // 3、--- 新增：硬触发模拟器 ---
        private static readonly System.Timers.Timer _hardwareTriggerSimulator;
        /// <summary>
        /// 获取或设置模拟硬触发的间隔时间（毫秒）。
        /// </summary>
        public static double TriggerInterval { get; set; } = 1000; // 默认1秒触发一次

        /// <summary>
        /// 获取一个值，该值指示硬件触发模拟器当前是否正在运行。
        /// </summary>
        public static bool IsHardwareTriggerSimulating { get; private set; } = false;

        /// <summary>
        /// 静态构造函数，用于一次性初始化静态资源。
        /// </summary>
        static CameraManager()
        {
            //初始化硬触发模拟器
            _hardwareTriggerSimulator = new System.Timers.Timer();
            _hardwareTriggerSimulator.Elapsed += OnHardwareTriggerTimerElapsed;
            _hardwareTriggerSimulator.AutoReset = true; // 确保定时器持续触发
            _hardwareTriggerSimulator.Enabled = false; // 默认不启动
        }


        //// 事件：用于向UI发送日志消息
        //public static event Action<string> OnLogMessage;
        //// 用于写入日志文件的 StreamWriter
        //private static StreamWriter _logFileWriter;

        ////私有的、静态的、只读的对象，专门用作线程同步的“锁”。
        //private static readonly object _logLock = new object();

        /// <summary>
        /// 初始化文件日志记录器。应在程序启动时调用一次。
        /// </summary>
        //public static void InitializeLogger()
        //{
        //    try
        //    {
        //        string logDirectory = Path.Combine(Application.StartupPath, "Logs");
        //        Directory.CreateDirectory(logDirectory); // 确保Logs文件夹存在

        //        string logFileName = $"Log_{DateTime.Now:yyyy-MM-dd_HH-mm-ss}.txt";
        //        string logFilePath = Path.Combine(logDirectory, logFileName);

        //        // 创建StreamWriter，设置为追加模式和自动刷新
        //        _logFileWriter = new StreamWriter(logFilePath, append: true, encoding: System.Text.Encoding.UTF8)
        //        {
        //            AutoFlush = true
        //        };

        //        Log("文件日志记录器已初始化。");
        //    }
        //    catch (Exception ex)
        //    {
        //        // 如果文件日志初始化失败，在UI上报告错误
        //        OnLogMessage?.Invoke($"[CRITICAL] 文件日志初始化失败: {ex.Message}");
        //    }
        //}

        /// <summary>
        /// 【新增】一个完整的业务流程方法：
        /// 1. 根据配置初始化所有相机并显示它们的窗口。
        /// 2. 在所有窗口都显示后，命令所有相机开始采集。
        /// 这个方法是响应“开启设备”或“应用配置并启动”按钮的理想入口点。
        /// </summary>
        /// <param name="settingsList">要应用的相机配置列表。</param>
        /// <param name="mainForm">主窗体，用于停靠显示窗口。</param>
        //public static void ApplyConfigurationAndStartGrabbing(List<CameraSettings> settingsList, FrmMain mainForm)
        //{
        //    ThreadSafeLogger.Log("开始执行“开启设备”流程...");

        //    // 步骤 1: 初始化所有相机和UI窗口
        //    // Initialize 方法会负责 Shutdown 旧实例、创建新实例、打开硬件、显示窗口等。
        //    // 因为 Initialize 方法中的 displayForm.Show() 是非阻塞的，它会立即返回，
        //    // 窗体的创建和显示过程会被调度到UI线程的消息队列中。
        //    Initialize(settingsList, mainForm);

        //    // 检查是否有任何相机成功初始化
        //    if (ActiveCameras.Count == 0)
        //    {
        //        ThreadSafeLogger.Log("“开启设备”流程中止，因为没有相机被成功初始化。");
        //        return;
        //    }

        //    // 步骤 2: 在 Initialize 完成后（意味着所有窗口都已创建并 Show），开始采集
        //    // 这个调用会紧接着 Initialize 执行，此时窗体可能还在绘制过程中，但这没关系。
        //    // StartAll() 会启动后台线程开始拉取图像，一旦图像到达，就会通过事件推送到已经存在的窗体上。
        //    ThreadSafeLogger.Log("所有相机窗口已创建，现在开始采集图像...");
        //    StartAll();

        //    ThreadSafeLogger.Log("“开启设备”流程已完成。相机正在采集中。");
        //}

        ///// <summary>
        ///// 根据配置列表初始化或更新所有相机
        ///// </summary>
        //public static void Initialize(List<CameraSettings> settingsList, FrmMain mainForm)
        //{

        //    // 先停止并释放所有旧的相机
        //    Shutdown();
        //    ThreadSafeLogger.Log("开始应用新的相机配置...");

        //    EnabledCameraCount = settingsList.Count(s => s.IsEnabled);
        //    if (EnabledCameraCount == 0)
        //    {
        //        ThreadSafeLogger.Log("没有启用的相机。");
        //        return;
        //    }

        //    var deviceList = new HikvisionCamera().FindDevices(); 
        //    if (deviceList.Count == 0)
        //    {
        //        ThreadSafeLogger.Log("错误：未找到任何相机设备！");
        //        return;
        //    }

        //    int deviceIndex = 0;
        //    foreach (var setting in settingsList)
        //    {
        //        if (!setting.IsEnabled) continue;

        //        if (deviceIndex >= deviceList.Count)
        //        {
        //            ThreadSafeLogger.Log($"警告：相机配置'{setting.Name}'无法分配物理设备，因为设备数量不足。");
        //            continue;
        //        }

        //        // --- 创建相机实例 ---
        //        var cam = new HikvisionCamera { Name = setting.Name };
        //        cam.TriggerMode = setting.TriggerMode;
        //        if (!cam.Open(setting))
        //        {
        //            ThreadSafeLogger.Log($"错误：打开相机'{setting.Name}'失败。");
        //            cam.Dispose();
        //            continue;
        //        }
        //        // --- 设置触发模式 ---
        //        switch (setting.TriggerMode)
        //        {
        //            case TriggerModeType.Continuous:
        //                cam.SetContinuousMode();
        //                break;
        //            case TriggerModeType.Software:
        //                cam.SetTriggerMode(true);
        //                break;
        //            case TriggerModeType.Hardware:
        //                cam.SetTriggerMode(false);
        //                break;
        //        }

        //        // --- 订阅事件 ---
        //        cam.ImageAcquired += OnCameraImageAcquired;
        //        cam.CameraMessage += (sender, msg, err) => ThreadSafeLogger.Log($"{(sender as HikvisionCamera).Name}: {msg}");

        //        // --- 创建显示窗口 ---
        //        var displayForm = new FormImageDisplay { Text = setting.Name, CameraName = setting.Name };
        //        displayForm.OnDisplayEvent += ThreadSafeLogger.Log;
        //        displayForm.Show(mainForm.MainDockPanel, WeifenLuo.WinFormsUI.Docking.DockState.Document);


        //        ActiveCameras.Add(setting.Name, cam);
        //        CameraDisplays.Add(setting.Name, displayForm);
        //        mainForm.AddCameraToStatusStrip(setting.Name);
        //        ThreadSafeLogger.Log($"相机'{setting.Name}'初始化成功，分配到物理设备 {deviceIndex}。");
        //        deviceIndex++;
        //    }
        //}

        //********************初始化和启动流程*******************
        /// <summary>
        /// 准备所有相机硬件、UI窗口和后台处理器，但不开始采集。
        /// 这是“启动设备”的第一阶段。
        /// </summary>
        public static void PrepareAll(ProcessConfig config, FrmMain mainForm)//①准备所有相机和模型
        {
            // 1. 清理旧资源和UI
            mainForm.ClearStatusStrip();
            Shutdown();
            ThreadSafeLogger.Log("开始准备设备和模型...");

            // 2. 初始化检测协调器和AI模型
            // 注意：YoloModelManager 的 Initialize 现在也应在这里被调用，以确保逻辑集中
            YoloModelManager.Initialize(config.ModelSettings);
            DetectionCoordinator.Initialize(config.CameraSettings, config.ModelSettings);

            // 3. 创建相机硬件实例和UI窗口------
            var deviceList = new HikvisionCamera().FindDevices();
            if (deviceList.Count == 0)
            {
                ThreadSafeLogger.Log("错误：未找到任何相机设备！");
                return;
            }

            foreach (var setting in config.CameraSettings.Where(s => s.IsEnabled))//打开相机 → 设置触发模式 → 绑定事件（图像采集、检测完成）。
            {
                var cam = new HikvisionCamera { Name = setting.Name, CameraIndex = setting.CameraIndex };
                cam.TriggerMode = setting.TriggerMode;
                if (!cam.Open(setting))
                {
                    ThreadSafeLogger.Log($"错误：打开相机'{setting.Name}'失败。");
                    cam.Dispose();
                    continue;
                }
                // --- 设置触发模式 ---
                switch (setting.TriggerMode)
                {
                    case TriggerModeType.Continuous:
                        cam.SetContinuousMode();
                        break;
                    case TriggerModeType.Software:
                        cam.SetTriggerMode(true);
                        break;
                    case TriggerModeType.Hardware:
                        cam.SetTriggerMode(false);
                        break;
                }

                // --- 订阅事件 ---
                cam.ImageAcquired += OnCameraImageAcquired;
                var processor = DetectionCoordinator.GetProcessor(cam.CameraIndex);
                if (processor != null) { processor.OnProcessingCompleted += Processor_OnProcessingCompleted; }

                // --- 创建【但不显示】图像的UI窗口 ---
                var originalDisplay = new FormImageDisplay { Text = $"{setting.Name} - 原图", CameraName = setting.Name };
                var resultDisplay = new FormImageDisplay { Text = $"{setting.Name} - 结果", CameraName = setting.Name };
                originalDisplay.Show(mainForm.MainDockPanel, WeifenLuo.WinFormsUI.Docking.DockState.Document);
                resultDisplay.Show(mainForm.MainDockPanel, WeifenLuo.WinFormsUI.Docking.DockState.Document);

                // --- 保存引用 ---
                ActiveCameras.Add(setting.Name, cam);
                OriginalImageDisplays.Add(setting.Name, originalDisplay);
                ResultImageDisplays.Add(setting.Name, resultDisplay);
                mainForm.AddCameraToStatusStrip(setting.Name);
            }
            ThreadSafeLogger.Log("所有设备和模型已准备就绪。");
        }


        /// <summary>
        /// 根据配置列表初始化或更新所有相机
        /// 类似 PrepareAll，但更侧重于更新配置，会检查物理设备数量，不足时报 warning。
        /// </summary>
        public static void Initialize(ProcessConfig config, FrmMain mainForm)
        {
            mainForm?.ClearStatusStrip();

            // 先停止并释放所有旧的相机
            Shutdown();
            ThreadSafeLogger.Log("开始应用新的相机配置...");
            // 2. 初始化新的检测协调器
            DetectionCoordinator.Initialize(config.CameraSettings, config.ModelSettings);

            var deviceList = new HikvisionCamera().FindDevices();
            if (deviceList.Count == 0)
            {
                ThreadSafeLogger.Log("错误：未找到任何相机设备！");
                return;
            }
            int deviceIndex = 0;
            foreach (var device in config.ModelSettings.Where(s => s.IsEnabled))
            {
                if (!device.IsEnabled) continue;
                mainForm.AddCameraToStatusStrip(device.Name);
            }
            foreach (var setting in config.CameraSettings.Where(s => s.IsEnabled))
            {
                if (!setting.IsEnabled) continue;

                if (deviceIndex >= deviceList.Count)
                {
                    ThreadSafeLogger.Log($"警告：相机配置'{setting.Name}'无法分配物理设备，因为设备数量不足。");
                    continue;
                }
                // --- 创建相机实例 ---
                var cam = new HikvisionCamera { Name = setting.Name, CameraIndex = setting.CameraIndex };
                cam.TriggerMode = setting.TriggerMode;
                if (!cam.Open(setting))
                {
                    ThreadSafeLogger.Log($"错误：打开相机'{setting.Name}'失败。");
                    cam.Dispose();
                    continue;
                }
                // --- 设置触发模式 ---
                switch (setting.TriggerMode)
                {
                    case TriggerModeType.Continuous:
                        cam.SetContinuousMode();
                        break;
                    case TriggerModeType.Software:
                        cam.SetTriggerMode(true);
                        break;
                    case TriggerModeType.Hardware:
                        cam.SetTriggerMode(false);
                        break;
                }

                // --- 订阅事件 ---
                cam.ImageAcquired += OnCameraImageAcquired;
                cam.CameraMessage += (sender, msg, err) => ThreadSafeLogger.Log($"{(sender as HikvisionCamera).Name}: {msg}");
                ActiveCameras.Add(setting.Name, cam);
                // --- 创建显示窗口 ---
                var displayForm = new FormImageDisplay { Text = $"{setting.Name} - 原图", CameraName = setting.Name };
                var checkFrm = new FormImageDisplay { Text = $"{setting.Name} - 结果", CameraName = setting.Name };
                displayForm.OnDisplayEvent += ThreadSafeLogger.Log;
                displayForm.Show(mainForm.MainDockPanel, WeifenLuo.WinFormsUI.Docking.DockState.Document);
                checkFrm.Show(mainForm.MainDockPanel, WeifenLuo.WinFormsUI.Docking.DockState.Document);

                OriginalImageDisplays.Add(setting.Name, displayForm);
                ResultImageDisplays.Add(setting.Name, checkFrm);
                mainForm.AddCameraToStatusStrip(setting.Name);
                var processor = DetectionCoordinator.GetProcessor(cam.CameraIndex);
                if (processor != null)
                {
                    processor.OnProcessingCompleted += Processor_OnProcessingCompleted;
                }
                ThreadSafeLogger.Log($"相机'{setting.Name}'初始化成功，分配到物理设备 {deviceIndex}。");
                deviceIndex++;
            }
        }

        /// <summary>
        /// 启动硬件触发模拟器。
        /// </summary>
        public static void StartHardwareTriggerSimulator()
        {
            if (IsHardwareTriggerSimulating) return;

            _hardwareTriggerSimulator.Interval = TriggerInterval;
            _hardwareTriggerSimulator.Start();
            IsHardwareTriggerSimulating = true;
            ThreadSafeLogger.Log($"硬件触发模拟器已启动，触发间隔: {TriggerInterval} ms。");
        }

        /// <summary>
        /// 停止硬件触发模拟器。
        /// </summary>
        public static void StopHardwareTriggerSimulator()
        {
            if (!IsHardwareTriggerSimulating) return;

            _hardwareTriggerSimulator.Stop();
            IsHardwareTriggerSimulating = false;
            ThreadSafeLogger.Log("硬件触发模拟器已停止。");
        }

        /// <summary>
        /// 定时器触发事件。（定时器 OnHardwareTriggerTimerElapsed 会遍历相机，对处于软件触发模式的相机执行 SoftwareTrigger()。）
        /// </summary>
        private static void OnHardwareTriggerTimerElapsed(object sender, ElapsedEventArgs e)
        {
            // 遍历所有活动的相机
            foreach (var cam in ActiveCameras.Values)
            {
                // 仅对配置为“硬件触发”模式的相机执行操作
                // 重要：我们使用软触发命令(SoftwareTrigger)来“模拟”一个外部硬件信号的到达。
                if (cam.TriggerMode == TriggerModeType.Software && cam.IsGrabbing)
                {
                    // ThreadSafeLogger.Log($"模拟硬触发信号，触发相机: {cam.Name}"); // 如果需要详细日志可以取消注释
                    cam.SoftwareTrigger();
                }
            }
        }


        /// <summary>
        /// 所有启用的相机开始采集
        /// </summary>
        public static void StartAll()
        {
            foreach (var cam in ActiveCameras.Values)
            {
                cam.StartGrabbing();
            }
            ThreadSafeLogger.Log("所有相机已开始采集。");
        }

        //public static void StartDetection()
        //{
        //    if (!IsDetectionRunning)
        //    {
        //        IsDetectionRunning = true;
        //        ThreadSafeLogger.Log("检测已启动，开始统计数据。");
        //    }
        //}
        //public static void StopDetection()
        //{
        //    if (IsDetectionRunning)
        //    {
        //        IsDetectionRunning = false;
        //        ThreadSafeLogger.Log("检测已停止。");
        //    }
        //}

        /// <summary>
        /// 所有启用的相机停止采集
        /// </summary>
        public static void StopAll()
        {
            foreach (var cam in ActiveCameras.Values)
            {
                cam.StopGrabbing();
            }
            ThreadSafeLogger.Log("所有相机已停止采集。");
        }

        ///// <summary>
        ///// 停止并释放所有相机资源
        ///// </summary>
        //public static void Shutdown()
        //{
        //    // --- 新增：确保在关闭时停止模拟器并释放资源 ---
        //    StopHardwareTriggerSimulator();
        //    //_hardwareTriggerSimulator?.Dispose();

        //    StopAll();
        //    foreach (var cam in ActiveCameras.Values)
        //    {
        //        cam.Dispose();
        //    }
        //    foreach (var display in CameraDisplays.Values)
        //    {
        //        display.Close();
        //    }
        //    lock (QueueLock)
        //    {
        //        while (ProductQueue.Count > 0)
        //        {
        //            ProductQueue.Dequeue()?.Dispose();
        //        }
        //    }
        //    ResetProductCounter();
        //    ActiveCameras.Clear();
        //    CameraDisplays.Clear();
        //    ThreadSafeLogger.Log("正在关闭文件日志记录器...");
        //    ThreadSafeLogger.Log("所有相机资源已释放。");

        //}

        /// <summary>
        /// 停止所有相机 + 关闭窗口 + 清空字典 + 关闭检测协调器 + 销毁模型
        /// </summary>
        public static void Shutdown()
        {
            // 1. 停止硬件和模拟器
            StopAll();
            StopHardwareTriggerSimulator();
            // 2. 关闭相机实例和窗口
            foreach (var cam in ActiveCameras.Values) { cam.Dispose(); }
            foreach (var display in OriginalImageDisplays.Values) { display.Close(); }
            foreach (var display in ResultImageDisplays.Values) { display.Close(); }
            ActiveCameras.Clear();
            OriginalImageDisplays.Clear();
            ResultImageDisplays.Clear();
            // 3. 关闭检测协调器，它会负责清理所有后台线程和队列
            DetectionCoordinator.Shutdown();

            YoloModelManager.Shutdown();

            ThreadSafeLogger.Log("所有相机及协调器资源已释放。");
        }

        /// <summary>
        /// 重置产品计数器的公共方法
        /// </summary>
        public static void ResetProductCounter()
        {
            lock (_counterLock)
            {
                _productCounter = 0;
            }
            ThreadSafeLogger.Log("产品计数器已重置。");
        }

        /// <summary>
        /// 接收到相机图像时的核心处理逻辑
        /// </summary>
        //private static void OnCameraImageAcquired(HikvisionCamera sender, Bitmap bmp)
        //{

        //    Bitmap bmpForDisplay =null;
        //    Bitmap bmpForQueue = null;
        //    try
        //    {
        //        bmpForDisplay?.Dispose();
        //        bmpForQueue?.Dispose();
        //        // 1. 为“显示”和“处理队列”创建独立的深克隆副本
        //        bmpForDisplay = DeepCloneBitmap(bmp, "Display");
        //        bmpForQueue = DeepCloneBitmap(bmp, "Queue");
        //    }
        //    finally
        //    {
        //        // 【关键】无论克隆成功与否，都必须立即释放事件传递过来的原始bmp。
        //        // 这是保证没有泄漏的第一道防线。
        //        bmp?.Dispose();
        //    }
        //    // --- 现在我们使用完全独立的副本进行后续操作 ---

        //    // 4. 将显示副本传递给UI
        //    if (bmpForDisplay != null && CameraDisplays.TryGetValue(sender.Name, out var display))
        //    {
        //        display.UpdateImage(bmpForDisplay);
        //    }
        //    else
        //    {
        //        // 如果不需要显示，或者显示失败，必须释放掉为它创建的副本
        //        bmpForDisplay?.Dispose();
        //    }
        //    // 5. 将队列副本添加到产品中
        //    if (bmpForQueue != null)
        //    {
        //        lock (QueueLock)
        //        {
        //            ProductResult currentProduct;
        //            bool isNewProductCycle = ProductQueue.Count == 0 || ProductQueue.Last().CapturedImages.ContainsKey(sender.Name);
        //            if (isNewProductCycle)
        //            {
        //                if (ProductQueue.Count > 0 && !ProductQueue.Peek().IsComplete(EnabledCameraCount))
        //                {
        //                    var orphanedProduct = ProductQueue.Dequeue(); // 从队列头部移除这个不完整的产品
        //                    ThreadSafeLogger.Log($"[警告] 产品 #{orphanedProduct.ProductID} 未能集齐所有相机图像而被丢弃，以防止内存泄漏。");
        //                    orphanedProduct.Dispose(); // 确保释放其占用的所有资源
        //                }
        //                long newProductId;
        //                lock (_counterLock)
        //                {
        //                    _productCounter++;
        //                    newProductId = _productCounter;
        //                }
        //                currentProduct = new ProductResult(newProductId);
        //                ProductQueue.Enqueue(currentProduct);
        //            }
        //            else
        //            {
        //                currentProduct = ProductQueue.Last();
        //            }

        //            currentProduct.AddImage(sender.Name, bmpForQueue); // bmpForQueue的所有权转移给了产品队列

        //            while (ProductQueue.Count > 0 && ProductQueue.Peek().IsComplete(EnabledCameraCount))
        //            {
        //                // Peek() 查看队头元素但不移除它
        //                var finishedProduct = ProductQueue.Dequeue(); // Dequeue() 移除队头元素
        //                ThreadSafeLogger.Log($"产品 #{finishedProduct.ProductID} 已完整，出队处理。");

        //                // --- 这是您已有的处理逻辑 ---
        //                bool isOk = new Random().NextDouble() > 0.1;
        //                string finalResult = isOk ? "OK" : "NG";
        //                ThreadSafeLogger.Log($"产品 #{finishedProduct.ProductID} 检测结果: {finalResult}");

        //                if (IsDetectionRunning)
        //                {
        //                    OnDetectionCompleted?.Invoke(null, new DetectionResultEventArgs(isOk));
        //                }

        //                try
        //                {
        //                    // 确保完成的产品被完全释放
        //                    finishedProduct.Dispose();
        //                }
        //                catch (Exception ex)
        //                {
        //                    ThreadSafeLogger.Log($"[ERROR] 释放产品 #{finishedProduct.ProductID} 资源时出错: {ex.Message}");
        //                }
        //            }
        //        }
        //    }
        //}

        //【相机回调】
        private static void OnCameraImageAcquired(HikvisionCamera sender, Bitmap bmp)
        {
            Bitmap bmpForDisplay = null;
            Bitmap bmpForProcessing = null;

            try
            {
                // 1. 深度克隆 Bitmap → 分成 显示副本 和 处理副本。
                bmpForDisplay = DeepCloneBitmap(bmp, "Display");
                bmpForProcessing = DeepCloneBitmap(bmp, "Processing");
            }
            finally
            {
                // 2.无论克隆成功与否，都必须立即释放事件传递过来的原始bmp，防止泄漏。
                bmp?.Dispose();//空条件运算符 ?.-----在访问对象成员前检查对象是否为 null，如果 bmp 不是 null，则正常调用 Dispose() 方法，替代传统的 if (bmp != null) 检查
            }
            // 分支 A: 显示副本 → 交给 FormImageDisplay.UpdateImage()。
            if (bmpForDisplay != null && OriginalImageDisplays.TryGetValue(sender.Name, out var displayWindow))
            {
                // displayWindow.UpdateImage 会处理线程安全问题
                displayWindow.UpdateImage(bmpForDisplay);
            }
            else
            {
                // 如果没有对应的显示窗口，或克隆失败，必须释放为显示创建的副本
                bmpForDisplay?.Dispose();
            }
            // 分支 B: 处理副本 → 交给 DetectionCoordinator.EnqueueImage() 进行检测。
            if (bmpForProcessing != null)
            {
                // bmpForProcessing 的所有权在这里被转移给了协调器
                DetectionCoordinator.EnqueueImage(sender.CameraIndex, bmpForProcessing);
            }
            //// 深度克隆图像以确保线程安全
            //Bitmap bmpForProcessing = DeepCloneBitmap(bmp, "Processing");
            //bmp?.Dispose(); // 立即释放原始图

            //// 直接将图像和相机编号交给协调器，无需任何本地处理
            //DetectionCoordinator.EnqueueImage(sender.CameraIndex, bmpForProcessing);
        }
        // 事件处理器
        private static void Processor_OnProcessingCompleted(object sender, ProcessingCompletedEventArgs e)
        {

            // 1. 找到与此相机匹配的相机名称
            var cameraEntry = ActiveCameras.FirstOrDefault(kvp => kvp.Value.CameraIndex == e.CameraIndex);
            if (cameraEntry.Key == null)
            {
                e.Dispose(); // 如果找不到接收者，必须释放事件参数中的图像
                return;
            }
            // 2. 找到此相机的结果显示窗口
            if (ResultImageDisplays.TryGetValue(cameraEntry.Key, out var resultDisplay))
            {
                //var bmp = ConvertSKImageToBitmap(e.ResultImage);
                if (e.ResultImage != null)
                {
                    // UpdateImage 会负责克隆并显示，所以这里传递 bmp 即可
                    resultDisplay.UpdateImage(e.ResultImage);
                }
            }
            else
            {
                // 如果找到了相机但没有对应的结果窗口，也要释放图像
                e.Dispose();
            }

        }

        /// <summary>
        /// 【将 SkiaSharp.SKImage 安全地转换为 System.Drawing.Bitmap。
        /// </summary>
        private static Bitmap ConvertSKImageToBitmap(SKImage skImage)
        {
            if (skImage == null) return null;

            try
            {
                // SKImage -> SKBitmap -> System.Drawing.Bitmap
                using (var skBitmap = SKBitmap.FromImage(skImage))
                {
                    // SKBitmap.ToBitmap() 会创建一个新的 Bitmap 对象
                    return SKBitmapToGdiBitmapFast(skBitmap);
                }
            }
            catch (Exception ex)
            {
                ThreadSafeLogger.Log($"[错误] SKImage to Bitmap 转换失败: {ex.Message}");
                return null;
            }
        }
        public static Bitmap SKBitmapToGdiBitmapFast(SKBitmap skBitmap)
        {
            if (skBitmap == null) throw new ArgumentNullException(nameof(skBitmap));
            if (skBitmap.ColorType != SKColorType.Bgra8888 || skBitmap.AlphaType != SKAlphaType.Premul)
                throw new ArgumentException("skBitmap must be Bgra8888 + Premul for the fast path.");

            int w = skBitmap.Width;
            int h = skBitmap.Height;

            Bitmap bmp = new Bitmap(w, h, PixelFormat.Format32bppArgb);
            var rect = new Rectangle(0, 0, w, h);
            var bmpData = bmp.LockBits(rect, ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
            try
            {
                IntPtr srcPtr = skBitmap.GetPixels();
                int srcRowBytes = skBitmap.RowBytes;
                int dstRowBytes = bmpData.Stride;
                int copyBytesPerRow = Math.Min(srcRowBytes, dstRowBytes);

                byte[] row = new byte[copyBytesPerRow]; // 复用同一行缓冲区，避免每行分配
                for (int y = 0; y < h; y++)
                {
                    IntPtr s = IntPtr.Add(srcPtr, y * srcRowBytes);
                    IntPtr d = IntPtr.Add(bmpData.Scan0, y * dstRowBytes);

                    Marshal.Copy(s, row, 0, copyBytesPerRow);
                    Marshal.Copy(row, 0, d, copyBytesPerRow);
                }
            }
            finally
            {
                bmp.UnlockBits(bmpData);
            }

            return bmp;
        }
        /// <summary>
        /// 对Bitmap进行真正的深度克隆，确保内存完全独立。
        /// 这是解决跨线程GDI+问题的最可靠方法。
        /// </summary>
        /// <param name="source">源Bitmap对象。</param>
        /// <returns>一个与源图像在内存上完全独立的全新Bitmap对象。</returns>
        private static Bitmap DeepCloneBitmap(Bitmap source, string cloneFor)
        {
            if (source == null) return null;

            // 创建一个新的Bitmap对象，具有与源相同的尺寸和像素格式
            Bitmap clone = new Bitmap(source.Width, source.Height, source.PixelFormat);

            // 如果有调色板，复制调色板
            if (source.Palette.Entries.Length > 0)
            {
                clone.Palette = source.Palette;
            }

            // 锁定源和目标Bitmap的内存区域
            var rect = new Rectangle(0, 0, source.Width, source.Height);
            BitmapData sourceData = null; //source.LockBits(rect, ImageLockMode.ReadOnly, source.PixelFormat);
            BitmapData cloneData = null;//clone.LockBits(rect, ImageLockMode.WriteOnly, clone.PixelFormat);

            try
            {
                sourceData = source.LockBits(rect, ImageLockMode.ReadOnly, source.PixelFormat);
                cloneData = clone.LockBits(rect, ImageLockMode.WriteOnly, clone.PixelFormat);
                // 计算需要拷贝的字节数
                int byteCount = Math.Abs(sourceData.Stride) * source.Height;
                byte[] buffer = new byte[byteCount];

                // 从源图像拷贝数据到字节数组
                Marshal.Copy(sourceData.Scan0, buffer, 0, byteCount);

                // 从字节数组拷贝数据到目标图像
                Marshal.Copy(buffer, 0, cloneData.Scan0, byteCount);
            }
            catch (Exception ex)
            {
                ThreadSafeLogger.Log($"[克隆错误] 在 DeepCloneBitmap ({cloneFor}) 中发生异常: {ex.Message}");
                // 如果发生错误，确保返回null，并且释放可能已经创建的clone对象
                clone?.Dispose();
                return null;
            }
            finally
            {
                // 确保即使在发生错误时也能尝试解锁
                if (sourceData != null)
                {
                    source.UnlockBits(sourceData);
                }
                if (cloneData != null)
                {
                    clone.UnlockBits(cloneData);
                }
                //ThreadSafeLogger.Log($"[克隆完成] 解锁并完成克隆 ({cloneFor}).");
            }

            return clone;
        }

        // 触发日志事件的辅助方法
        //public static void Log(string message)
        //{
        //    string formattedMessage = $"[{DateTime.Now:HH:mm:ss.fff}] {message}";

        //    // 1. 触发事件，更新UI
        //    OnLogMessage?.Invoke(formattedMessage);

        //    // 2. 【关键修改】在写入文件前，先获取锁。
        //    // lock 语句块确保了花括号内的代码在同一时间只能被一个线程执行。
        //    // 如果另一个线程也想执行这段代码，它必须等待前一个线程执行完毕并释放锁。
        //    lock (_logLock)
        //    {
        //        try
        //        {
        //            _logFileWriter?.WriteLine(formattedMessage);
        //        }
        //        catch (Exception)
        //        {
        //            // 即使有锁，也保留try-catch以防万一（如磁盘满了等IO问题）。
        //            // 可以在这里决定是否要在UI上显示警告。
        //        }
        //    }
        //}

    }

}