// 应用CLAHE
private Mat ApplyCLAHE(Mat input)
{
    Mat output = new Mat();
    
    // 转换到LAB颜色空间
    Cv2.CvtColor(input, output, ColorConversionCodes.BGR2Lab);

    // 分离通道
    Mat[] channels = Cv2.Split(output);

    // 对L通道应用CLAHE
    var clahe = Cv2.CreateCLAHE(2.0, new OpenCvSharp.Size(8, 8));
    Mat enhancedL = new Mat();
    clahe.Apply(channels[0], enhancedL);

    // 创建一个与原始L通道大小相同的Mat
    Mat resizedL = new Mat();
    Cv2.Resize(enhancedL, resizedL, channels[0].Size(), 0, 0, InterpolationFlags.Linear);

    // 使用双线性插值混合原始L通道和增强后的L通道
    Mat blendedL = new Mat();
    Cv2.AddWeighted(channels[0], 0.5, resizedL, 0.5, 0, blendedL);

    // 用混合后的L通道替换原始L通道
    channels[0] = blendedL;

    // 合并通道
    Cv2.Merge(channels, output);

    // 转换回BGR颜色空间
    Cv2.CvtColor(output, output, ColorConversionCodes.Lab2BGR);

    return output;
}

/// <summary>
        /// 刷新Frame帧
        /// </summary>
        private void RefreshFrame()
        {
            isCapture = true;
            _lastSaveTime = DateTime.Now;
            InitializeVideoWriter();

            Task.Run(() =>
            {
                Stopwatch stopwatch = new Stopwatch();
                long frameInterval = (long)(1000.0 / Fps * TimeSpan.TicksPerMillisecond);
                long nextFrameTime = 0;

                while (isCapture)
                {
                    stopwatch.Start();
                    try
                    {
                        Mat tempFrame = new Mat();
                        if (!cap.Read(tempFrame))
                        {
                            Debug.WriteLine("无法读取帧");
                            continue;
                        }
                        if (tempFrame.Empty())
                        {
                            Debug.WriteLine("帧为空");
                            continue;
                        }

                        FrameChanged?.Invoke(tempFrame);
                        lock (_lockObject)
                        {
                            tempFrame.CopyTo(_BufferFrame);
                        }
                        if (isSave)
                        {
                            SaveFrame(tempFrame);
                        }

                        if (Application.Current == null)
                            break;
                        Application.Current.Dispatcher.Invoke(() =>
                        {
                            Frame = _BufferFrame.Clone();
                        });

                        long elapsedTicks = stopwatch.ElapsedTicks;
                        if (elapsedTicks < frameInterval)
                        {
                            long sleepTime = (frameInterval - elapsedTicks) / TimeSpan.TicksPerMillisecond;
                            if (sleepTime > 1)
                                Thread.Sleep((int)sleepTime - 1);
                        }

                        nextFrameTime += frameInterval;
                        while (stopwatch.ElapsedTicks < nextFrameTime)
                        {
                            Thread.Sleep(0);
                        }
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine($"捕获帧时发生错误: {ex.Message}");
                        break;
                    }
                }
                CloseVideoWriter();
            });
        }

using OpenCvSharp;
using OpenCvSharp.Flann;
using OpenCvSharp.WpfExtensions;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Configuration;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Media.Imaging;
using System.Windows.Threading;

namespace camera
{
    public class CameraService : BindableBase
    {
        VideoCapture cap;
        VideoWriter capWriter;
        double FpsOrigin;
        double WidthOrigin;
        double HeightOrigin;
        bool isCapture = false;//是否退出捕获线程
        bool isSave = true;//是否保存

        private Mat _BufferFrame = new();

        private object _lockObject = new object();

        private double _Fps;
        public double Fps
        {
            get { return _Fps; }
            set { SetProperty(ref _Fps, value); }
        }

        private double _Width;
        public double Width
        {
            get { return _Width; }
            set { SetProperty(ref _Width, value); }
        }

        private double _Height;
        public double Height
        {
            get { return _Height; }
            set { SetProperty(ref _Height, value); }
        }

        //帧对外开放读取
        private Mat _Frame = new();
        public Mat Frame
        {
            get { return _Frame; }
            set { SetProperty(ref _Frame, value); }
        }

        private VideoWriter _videoWriter;
        private DateTime _lastSaveTime;
        private TimeSpan _saveInterval = TimeSpan.FromMinutes(1); // 默认5分钟保存一次
        private string _saveDirectory = "SavedVideos"; // 保存视频的目录

        public TimeSpan SaveInterval
        {
            get { return _saveInterval; }
            set { SetProperty(ref _saveInterval, value); }
        }

        #region 委托与事件

        public delegate void FrameChangedEventHandler(Mat frame);
        public event FrameChangedEventHandler FrameChanged;

        #endregion

        public CameraService()
        {
            FrameChanged += AddOverlayTime;
        }

        public int getCameraNum()
        {
            return 1;
        }

        private void ShowVideoInfo()
        {
            FpsOrigin = cap.Get(VideoCaptureProperties.Fps);
            WidthOrigin = cap.Get(VideoCaptureProperties.FrameWidth);
            HeightOrigin = cap.Get(VideoCaptureProperties.FrameHeight);
            Debug.WriteLine($"原始数据格式:{WidthOrigin}*{HeightOrigin} {FpsOrigin}Hz");
            //估算码率
            // long totalBytes = 0;
            // totalBytes+= Frame.Total() * Frame.ElemSize();
            // double bitrate = (totalBytes * 8) / elapsedSeconds; // 比特/秒
            // Debug.WriteLine($"估算比特率: {bitrate / 1000000:F2} Mbps");
        }

        /// <summary>
        /// 开始捕获摄像
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public bool StartCapture(int index = 0)
        {
            try
            {
                cap = new VideoCapture(index);
                if (!cap.IsOpened())
                    return false;

                //获取视频本身的各种数据
                ShowVideoInfo();
                Fps = FpsOrigin;
                Width = WidthOrigin;
                Height = HeightOrigin;
                RefreshFrame();
                return true;
            }
            catch (Exception ex)
            {
                Debug.WriteLine($"启动摄像头时发生错误: {ex.Message}");
                return false;
            }
        }

        /// <summary>
        /// 刷新Frame帧的线程,使用isCapture控制是否跳出循环,跳出循环时执行关闭写入并压缩覆盖
        /// </summary>
        private void RefreshFrame()
        {
            isCapture = true;
            _lastSaveTime = DateTime.Now;
            InitializeVideoWriter();

            Task.Run(() =>
            {
                Stopwatch stopwatch = new Stopwatch();
                long frameInterval = (long)(1000.0 / Fps * TimeSpan.TicksPerMillisecond);
                long nextFrameTime = 0;

                while (isCapture)
                {
                    stopwatch.Start();
                    try
                    {
                        Mat tempFrame = new Mat();
                        if (!cap.Read(tempFrame))
                        {
                            Debug.WriteLine("无法读取帧");
                            continue;
                        }
                        if (tempFrame.Empty())
                        {
                            Debug.WriteLine("帧为空");
                            continue;
                        }

                        FrameChanged?.Invoke(tempFrame);
                        lock (_lockObject)
                        {
                            tempFrame.CopyTo(_BufferFrame);
                        }

                        if (isSave)
                        {
                            SaveFrame(tempFrame);
                        }

                        if (Application.Current == null)
                            break;
                        Application.Current.Dispatcher.Invoke(() =>
                        {
                            Frame = _BufferFrame.Clone();
                        });

                        long elapsedTicks = stopwatch.ElapsedTicks;
                        if (elapsedTicks < frameInterval)
                        {
                            long sleepTime = (frameInterval - elapsedTicks) / TimeSpan.TicksPerMillisecond;
                            if (sleepTime > 1)
                                Thread.Sleep((int)sleepTime - 1);
                        }

                        nextFrameTime += frameInterval;
                        while (stopwatch.ElapsedTicks < nextFrameTime)
                        {
                            Thread.Sleep(0);
                        }
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine($"捕获帧时发生错误: {ex.Message}");
                        return;
                    }
                }
                //跳出循环的时候压缩视频文件
                CloseVideoWriter();

            });
        }
        string fileName = "";
        string filePath = "";
        private void InitializeVideoWriter()
        {
            if (!Directory.Exists(_saveDirectory))
            {
                Directory.CreateDirectory(_saveDirectory);
            }

            fileName = $"{DateTime.Now:yyyyMMdd_HHmmss}.mp4";
            filePath = Path.Combine(_saveDirectory, fileName);

            //_videoWriter = new VideoWriter(filePath, FourCC.MP4V, Fps, new OpenCvSharp.Size(Width, Height));
            _videoWriter = new VideoWriter(filePath, FourCC.XVID, Fps, new OpenCvSharp.Size(Width, Height));
        }

        private void SaveFrame(Mat frame)
        {
            _videoWriter.Write(frame);

            if (DateTime.Now - _lastSaveTime >= SaveInterval)
            {
                CloseVideoWriter();
                InitializeVideoWriter();
                _lastSaveTime = DateTime.Now;
            }
        }

        string _ffmpegPath = @"D:\ffmpeg-7.0.2-full_build\bin\ffmpeg.exe";
        // 启动FFmpeg进程
        private void StartFFmpegProcess(string absolutePath)
        {
            string directory = Path.GetDirectoryName(absolutePath);
            string fileName = Path.GetFileNameWithoutExtension(absolutePath);
            string tempOutputPath = Path.Combine(directory, $"{fileName}_temp.mp4");

            var arguments = $"-i \"{absolutePath}\" -c:v libx264 -preset slow -crf 26 -an \"{tempOutputPath}\"";

            var processStartInfo = new ProcessStartInfo
            {
                FileName = _ffmpegPath,
                Arguments = arguments,
                RedirectStandardOutput = true,
                RedirectStandardError = true,
                UseShellExecute = false,
                CreateNoWindow = true,
                WorkingDirectory = directory
            };

            using (Process process = new Process { StartInfo = processStartInfo })
            {
                process.Start();
                string error = process.StandardError.ReadToEnd();
                process.WaitForExit();

                if (process.ExitCode != 0)
                {
                    Debug.WriteLine($"FFmpeg 执行失败。错误：{error}");
                }
                else
                {
                    if (File.Exists(tempOutputPath))
                    {
                        File.Delete(absolutePath);
                        File.Move(tempOutputPath, absolutePath);
                        Debug.WriteLine("文件压缩并替换成功");
                    }
                    else
                    {
                        Debug.WriteLine("临时输出文件未找到");
                    }
                }
            }
        }



        private void CloseVideoWriter()
        {
            _videoWriter?.Release();
            _videoWriter?.Dispose();
            //压缩视频
            string absolutePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, filePath);
            Task.Run(() => StartFFmpegProcess(absolutePath)).Wait();

        }

        public void ChangeCameraInfo()
        {
            isCapture = false;
            // 设置分辨率
            cap.Set(VideoCaptureProperties.FrameWidth, Width);
            cap.Set(VideoCaptureProperties.FrameHeight, Height);

            // 设置帧率
            cap.Set(VideoCaptureProperties.Fps, Fps);
            // 验证设置是否成功
            double actualWidth = cap.Get(VideoCaptureProperties.FrameWidth);
            double actualHeight = cap.Get(VideoCaptureProperties.FrameHeight);
            double actualFps = cap.Get(VideoCaptureProperties.Fps);
            Debug.WriteLine($"设置的分辨率: {Width}x{Height}, 实际分辨率: {actualWidth}x{actualHeight}");
            Debug.WriteLine($"设置的帧率: {Fps}, 实际帧率: {actualFps}");
            cap.Release();
            cap = new VideoCapture(0);
            if (!cap.IsOpened())
            {
                Debug.WriteLine("重新打开摄像头失败");
                return;
            }
            RefreshFrame();
        }

        /// <summary>
        /// 添加时间文字信息
        /// </summary>
        /// <param name="frame"></param>
        private void AddOverlayTime(Mat frame)
        {
            String nowStr = DateTime.Now.ToString();
            // 设置文本参数
            double fontScale = 0.7;
            int thickness = 2;
            HersheyFonts font = HersheyFonts.HersheySimplex;

            // 计算文本大小
            OpenCvSharp.Size textSize = Cv2.GetTextSize(nowStr, font, fontScale, thickness, out int baseline);

            // 计算文本位置（右上角，留出10像素的边距）
            OpenCvSharp.Point textOrg = new OpenCvSharp.Point(frame.Width - textSize.Width - 10, textSize.Height + 10);

            // 创建一个与原始帧相同大小和类型的覆盖层
            Mat overlay = new Mat(frame.Size(), frame.Type());
            overlay.SetTo(new Scalar(0, 0, 0, 0)); // 完全透明

            // 绘制半透明背景
            OpenCvSharp.Rect bgRect = new OpenCvSharp.Rect(textOrg.X - 5, textOrg.Y - textSize.Height - 5, textSize.Width + 10, textSize.Height + 10);
            Cv2.Rectangle(overlay, bgRect, new Scalar(0, 0, 0, 0), -1);

            // 将背景叠加到原始帧上
            Cv2.AddWeighted(overlay, 0.5, frame, 1.0, 0, frame);

            // 绘制透明背景文本(但必须在带有alpha的RGBA图像上)
            // OpenCvSharp.Rect bgRect = new OpenCvSharp.Rect(textOrg.X - 5, textOrg.Y - textSize.Height - 5, textSize.Width + 10, textSize.Height + 10);
            // Cv2.Rectangle(frame, bgRect, new Scalar(0, 0, 0, 0), -1);

            // 绘制文本
            Cv2.PutText(frame, nowStr, textOrg, font, fontScale, new Scalar(255, 255, 255), thickness, LineTypes.AntiAlias);
        }

        public void UpdateOverlayDate()
        {

        }

        public void StopCapture()
        {
            isCapture = false;
            cap.Release();
            CloseVideoWriter();
            ////压缩视频
            //string absolutePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, filePath);
            //Task.Run(() => StartFFmpegProcess(absolutePath));
        }
    }
}