using Cognex.VisionPro;
using Cognex.VisionPro.QuickBuild;
using LampInspectionMachine.Cameralibs;
using LampInspectionMachine.Model;
using MvCamCtrl.NET;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Prism.Mvvm;
using LampInspectionMachine.Log4xml;
using Cognex.VisionPro.ImageFile;
using System.Drawing;
using System.Windows.Forms;
using System.Web;
using System.ComponentModel;
using System.Windows.Media.Media3D;
using LampInspectionMachine.ViewModels;
using System.Collections.Concurrent;
using System.Threading;
using System.Windows.Controls;
using LampInspectionMachine.Views;
using System.Windows.Media.Imaging;
using System.Windows.Media;
using System.Windows;
using System.Runtime.InteropServices;
using SqlSugar.DistributedSystem.Snowflake;
using System.Windows.Threading;
using System.Windows.Ink;
using System.Data.SqlClient;
using System.Xml.Linq;
using System.Drawing.Imaging;
using System.IO.Packaging;
using Cognex.VisionPro.ToolBlock;
using System.Windows.Markup;
using System.Diagnostics;
using LampInspectionMachine.Cameralibs.HKCamera;
using Newtonsoft.Json.Linq;
using OpenCvSharp.Dnn;
using LampInspectionMachine.Interfaces;
using System.IO;
using LampInspectionMachine.KHLplc;
using LampInspectionMachine.Cameralibs.OPTCamera;

namespace LampInspectionMachine.Core
{
    public class Management : BindableBase
    {




        private CameraView cameraView;
        private ShowRender render = new ShowRender();
        public ShowRender Render
        {
            get => render;
            set
            {
                SetProperty(ref render, value);
            }
        }
        private KHLCommunicate _kHLCommunicate;
        public KHLCommunicate KHLCommunicate { get => _kHLCommunicate; set => _kHLCommunicate = value; }

        public CameraService CameraService { get; set; }


        /// <summary>
        /// 相机列表
        /// </summary>
        public ObservableCollection<string> CameraList { get => _CameraList; set { SetProperty(ref _CameraList, value); } }


        /// <summary>
        /// 当前相机配置
        /// </summary>
       public CameraInfo CurrCamConfig { get => _CurrCamConfig;
            set { SetProperty(ref _CurrCamConfig, value); } }

        /// <summary>
        /// 相机配置列表
        /// </summary>
        public List<CameraInfo> CamConfigs { get => _CamConfigs; set { SetProperty(ref _CamConfigs, value); } }

      //  public bool IsTriggerModel { get => _isTriggerModel; set { SetProperty(ref _isTriggerModel, value); } }

        public ICamera CurrCamera { get => myCamera; set { SetProperty(ref myCamera, value); } }

        /// <summary>
        /// 相机对应模板工具
        /// </summary>
     //   public List<CogToolBlock> CamTemplateS { get => _CamTemplateS; set => _CamTemplateS = value; }

        public event Action<int> ToolBlockSwitched;

        public event Action<int> ToolBlockCatched;


        private int _CurrIndex=0;
        /// <summary>
        /// 当前选中的视觉方案id
        /// </summary>
        public int CurrIndex { get => _CurrIndex; set => _CurrIndex = value; }
        /// <summary>
        /// 当前选中相机的SN
        /// </summary>
        public string CurrCameraSn { get => _CurrCameraSn; 
            set { SetProperty(ref _CurrCameraSn, value); } }

        public ObservableCollection<VisionProManager> VisionProManagers { get => _visionProManagers; set { SetProperty(ref _visionProManagers, value); } }

        public VisionProManager Currvision { get => _Currvision; set => _Currvision =  value ; }
  

        private List<CameraInfo> _CamConfigs = new List<CameraInfo>();

        private ObservableCollection<VisionProManager>  _visionProManagers=new ObservableCollection<VisionProManager>();

      //  private List<CogToolBlock> _CamTemplateS = new List<CogToolBlock>();

        private CogToolBlock cogToolBlock1;
        private VisionProManager _Currvision;
        private CameraInfo _CurrCamConfig = null;
        private ICamera myCamera;
        //private bool _isTriggerModel = false;


   

        private ObservableCollection<string> _CameraList = new ObservableCollection<string>();

        private string _CurrCameraSn = "";

        public Stopwatch stopwatch = new Stopwatch();

        public Management()
        {

        }

        Thread PlcConnChangThread ;
        public async void ConnectPlc() 
        {
            KHLCommunicate = new KHLCommunicate();
            await KHLCommunicate.ConnPlc();
            if (KHLCommunicate.IsConnected)
            {
                PlcConnChangThread = new Thread(RefPlcConnect);
                PlcConnChangThread.IsBackground = true;
                PlcConnChangThread.Start();
            }
        }

        public async void RefPlcConnect() 
        {
            while (true)
            {
                if(!KHLCommunicate.IsConnected)
                await  KHLCommunicate.ConnPlc();
                Thread.Sleep(1000);
            }
        }


        /// <summary>
        /// 获取相机列表
        /// </summary>
        public void LoadCameraDevice()
        {
            CameraService = new CameraService();
            CamConfigs = FileHelper.ReadApplicationConfiguration();
            CameraList = FindLoadCamera();

            if ( CamConfigs.Count == 0 )
            {
                CamConfigs.Add(new CameraInfo() { CameraName = "相机1", Id = new Guid(), SerialNumber = "", VppIndex = 0, VppFileName = "Cam1.vpp" });
                CamConfigs.Add(new CameraInfo() { CameraName = "相机2", Id = new Guid(), SerialNumber = "", VppIndex = 1, VppFileName = "Cam2.vpp" });
                CamConfigs.Add(new CameraInfo() { CameraName = "相机3", Id = new Guid(), SerialNumber = "", VppIndex = 2, VppFileName = "Cam3.vpp" });
                CamConfigs.Add(new CameraInfo() { CameraName = "相机4", Id = new Guid(), SerialNumber = "", VppIndex = 3, VppFileName = "Cam4.vpp" });
                CamConfigs.Add(new CameraInfo() { CameraName = "相机5", Id = new Guid(), SerialNumber = "", VppIndex = 4, VppFileName = "Cam5.vpp" });
                CamConfigs.Add(new CameraInfo() { CameraName = "相机6", Id = new Guid(), SerialNumber = "", VppIndex = 5, VppFileName = "Cam6.vpp" });
                CamConfigs.Add(new CameraInfo() { CameraName = "相机7", Id = new Guid(), SerialNumber = "", VppIndex = 6, VppFileName = "Cam7.vpp" });
                CamConfigs.Add(new CameraInfo() { CameraName = "相机8", Id = new Guid(), SerialNumber = "", VppIndex = 7, VppFileName = "Cam8.vpp" });
            }
            LogHelper.Info(Resources.Language.Resources.加载配置文件完成);
        }


        public void SaveCameraDevice()
        {
            FileHelper.SaveApplicationConfiguration(CamConfigs);
            LogHelper.Info(Resources.Language.Resources.保存配置完成);
        }
        /// <summary>
        /// 初始化相机管理
        /// </summary>
        public void InitTemplates(TipService tipService, Management management)
        {
            tipService.ShowMsg($"{Resources.Language.Resources.相机模板加载}2 %");
            for ( int i = 0; i < CamConfigs.Count; i++ )
            {

                CogToolBlock cogToolBlock = (CogToolBlock)CogSerializer.LoadObjectFromFile(Environment.CurrentDirectory + $"\\Vpp\\{CamConfigs[i].VppFileName}");
                VisionProManager vision=new VisionProManager();
                ICamera myCamera;
                myCamera = CreateCamera(CamConfigs[ i ]);
                if ( myCamera != null && myCamera.IsConnected )
                {

                    if ( myCamera.CheckImageCallbackEventIsHas(vision.CamCallBack) )
                        myCamera.ImageCallbackEvent -= vision.CamCallBack;
                    if ( !myCamera.CheckGrabImageCallbackEventIsHas(vision.ImageCallback) )
                        myCamera.GrabImageCallbackEvent += vision.ImageCallback;
                    myCamera.CameraConnectChangedEvent += vision.CameraConnectChangedEvent;
                    vision.IsConnected = true;
                    myCamera.SetTriggerMode(true, 0);
                    myCamera.StartTriggerGrabbing();
                }
                vision.Camera = myCamera;
                vision.PlcData.PlcToPcCodeIndex = ( uint ) ( 100 + i );
                vision.PlcData.PcToPlcCompleted = ( uint ) ( 200 + i );
                vision.PlcData.PcToPlcResult = ( uint ) ( 300 + i );
                vision.PlcData.PcToPlcCodeIndex = ( uint ) ( 400 + i );
                vision.CogToolBlock = cogToolBlock;
                vision.CameraInfo = CamConfigs[ i ];
                vision.Management = management;
                VisionProManagers.Add(vision);
                tipService.ShowMsg($"{Resources.Language.Resources.相机模板加载}{( i + 1 ) * 10 + 2}%");
            }
            LogHelper.Info(Resources.Language.Resources.模板加载完成);
            tipService.Tcolse();

        
        }

        /// <summary>
        /// 单张采集
        /// </summary>
        public void SoftTrigger()
        {
            if ( CurrCamera.IsConnected )
            {
                CurrCamera.StopGrabbing();
                LogHelper.Info(Resources.Language.Resources.软触发配置写入);
                CurrCamera.SetTriggerMode(false, 7);
                if ( !CurrCamera.CheckImageCallbackEventIsHas(Currvision.CamCallBack) )
                    CurrCamera.ImageCallbackEvent += Currvision.CamCallBack;
                CurrCamConfig.TriggerMode = false;
                LogHelper.Info(Resources.Language.Resources.软触发取图);
                CurrCamera.Grab();
            }
            else 
            {
                System.Windows.Forms.MessageBox.Show(Resources.Language.Resources.相机未打开);
            }
        }


        /// <summary>
        /// 连续采集写入
        /// </summary>
        public void SoftTrigger__Continue()
        {
            if ( CurrCamera!=null&& CurrCamera.IsConnected )
            {
                CurrCamera.StopGrabbing();
                CurrCamera.SetTriggerMode(false, 7);
                CurrCamConfig.TriggerMode = false;
                if ( !CurrCamera.CheckImageCallbackEventIsHas(Currvision.CamCallBack) )
                    CurrCamera.ImageCallbackEvent += Currvision.CamCallBack;

                if (myCamera.CheckGrabImageCallbackEventIsHas(Currvision.ImageCallback))
                    myCamera.GrabImageCallbackEvent -= Currvision.ImageCallback;
                LogHelper.Info(Resources.Language.Resources.连续采集启动);
                CurrCamera.StartGrabbing();
            }
            else
            {
                System.Windows.Forms.MessageBox.Show(Resources.Language.Resources.相机未打开);
            }
        }


        /// <summary>
        /// 单张图片测试
        /// </summary>
        public void ImageTrigger()
        {
            OpenFileDialog openFileDialog = new OpenFileDialog();
            if ( openFileDialog.ShowDialog() == DialogResult.OK )
            {
                // 加载图像文件
                using ( var bitmap = new Bitmap(openFileDialog.FileName) )
                {
                    // 转换为VisionPro图像格式
                    ICogImage icogImage = new CogImage8Grey(bitmap);

                    // 设置输入参数
                   Currvision.CogToolBlock.Inputs["Image"].Value = icogImage;

                    //执行处理
                    Currvision.CogToolBlock.Run();

                    //获取输出结果
                    if (Currvision.CogToolBlock.RunStatus.Result == CogToolResultConstants.Accept)
                    {

                        CogToolBlockTerminalCollection outputCollection = Currvision.CogToolBlock.Outputs;
                        ICogRecord record = null;
                        foreach (CogToolBlockTerminal item in outputCollection)
                        {
                            if (item.Value is ICogRecord)
                                record = item.Value as ICogRecord;
                        }
                        ICogImage cogImage = (ICogImage)Currvision.CogToolBlock.Inputs["Image"].Value;
                        if (cogImage != null)
                        {

                            Render = new ShowRender()
                            {
                                //Graphic = outputCollection["Graphic"].Value as CogGraphicCollection,
                                Image = icogImage,
                                Record = record
                            };
                        }
                    }
                    else
                    {
                        Render = new ShowRender()
                        {

                            Image = icogImage

                        };
                    }


                }
            }
        }


        /// <summary>
        /// 图片轮询测试
        /// </summary>
        public async Task ImageTrigger__Continue()
        {
            try
            {
                FolderBrowserDialog openFileDialog = new FolderBrowserDialog();
                if ( openFileDialog.ShowDialog() == DialogResult.OK )
                {
                    DirectoryInfo folder = new DirectoryInfo(openFileDialog.SelectedPath);
                    FileInfo[] files = folder.GetFiles("*.bmp", SearchOption.AllDirectories);

                    Task.Run(() =>
                    {
                        foreach ( FileInfo file in files )
                        {
                            // 加载图像文件
                            using ( var bitmap = new Bitmap(file.FullName) )
                            {
                                // 转换为VisionPro图像格式
                                ICogImage cogImage = new CogImage8Grey(bitmap);

                                Currvision.ImageCallback(cogImage);
                            }
                        }

                    });
                   
                }
            }
            catch 
            {
            
            
            }

           
        }
        

        public void SetHardTrigger_CallBack()
        {
            if ( CurrCamera != null && CurrCamera.IsConnected )
            {
                LogHelper.Info(Resources.Language.Resources.硬触发模式启动);
                CurrCamera.ImageCallbackEvent -= Currvision.CamCallBack;
                CurrCamera.SetTriggerMode(true, 0);
                CurrCamConfig.TriggerMode = true;
                CurrCamera.StartGrabbing();
            }
            else 
            {

                System.Windows.Forms.MessageBox.Show(Resources.Language.Resources.相机未打开);
            }
        }
        /// <summary>
        /// 查找相机
        /// </summary>
        public ObservableCollection<string> FindLoadCamera()
        {
            ObservableCollection<string> strings = new ObservableCollection<string>();
            if (CamConfigs.Count!=0) 
            {
               
                switch (CamConfigs[0].CameraBrand)
                {
                    case CameraBrand.HikRobot_MVS:
                        var listsn = MvCamera.GetDevices();
                        if (listsn.Length > 0)
                        {

                           
                            strings.Add("");
                            for (int i = 0; i < listsn.Length; i++)
                            {
                                strings.Add(listsn[i].SerialNumber);
                            }
                            return strings;
                        }
                        break;
                    case CameraBrand.Basler_Pylon:
                        break;
                    case CameraBrand.SciCamera_Opt:
                        var listsn2 = MVOptCamera.GetDevices();
                        if (listsn2.Length > 0)
                        {


                            strings.Add("");
                            for (int i = 0; i < listsn2.Length; i++)
                            {
                                strings.Add(listsn2[i].SerialNumber);
                            }
                            return strings;
                        }
                        break;
                    default:
                        break;
                }
            }
           
            if (strings.Count > 0)
            {
               
                return strings;
            }
            else
            {

                System.Windows.Forms.MessageBox.Show(Resources.Language.Resources.未查询到设备, Resources.Language.Resources.提示, MessageBoxButtons.OK);
                return null;
            }
        }

        public bool InitCamera()
        {
            try
            {
                ICamera myCamera;
                if ( CurrCamera != null && CurrCamera.IsConnected )
                {
                    CurrCamera.CloseDevice();
                    myCamera = CameraService.GetCamera(CurrCamera.ID);
                    bool res = myCamera.OpenDevice();

                    if ( !res )
                    {
                        myCamera.CloseDevice();
                        myCamera = null;
                        return false;
                    }
                    else
                    {
                        CurrCamera = myCamera;
                        CurrCamConfig.SerialNumber = myCamera.SerialNumber;
                        if ( myCamera.IsConnected )
                        {
                            if ( !myCamera.CheckImageCallbackEventIsHas(Currvision.CamCallBack) )
                                myCamera.ImageCallbackEvent += Currvision.CamCallBack;
                            if ( !myCamera.CheckGrabImageCallbackEventIsHas(Currvision.ImageCallback) )
                                myCamera.GrabImageCallbackEvent += Currvision.ImageCallback;
                            if ( !myCamera.CheckCameraConnectChangedEventIsHas(Currvision.CameraConnectChangedEvent) )
                                myCamera.CameraConnectChangedEvent += Currvision.CameraConnectChangedEvent;
                            
                        }
                        return true;
                    }
                }
                else
                {
                    CurrCamera = null;
                    myCamera = CreateCamera(new CameraInfo() { SerialNumber = CurrCameraSn });
                    CurrCamera = myCamera;
                    if(myCamera!=null)
                    CurrCamConfig.SerialNumber = myCamera.SerialNumber;
                    if ( myCamera != null&&  myCamera.IsConnected )
                    {
                        if ( !myCamera.CheckImageCallbackEventIsHas(Currvision.CamCallBack) )
                            myCamera.ImageCallbackEvent += Currvision.CamCallBack;
                        if ( !myCamera.CheckGrabImageCallbackEventIsHas(Currvision.ImageCallback) )
                            myCamera.GrabImageCallbackEvent += Currvision.ImageCallback;
                        if ( !myCamera.CheckCameraConnectChangedEventIsHas(Currvision.CameraConnectChangedEvent) )
                            myCamera.CameraConnectChangedEvent += Currvision.CameraConnectChangedEvent;
                        Currvision.IsConnected = true;
                        return true;
                    }
                    return false;
                }
            }
            catch 
            {
                CurrCamera?.CloseDevice();
                CurrCamera = null;
            return false;
            }

        }

        public ICamera CreateCamera(CameraInfo  cameraInfo) 
        {
            Guid guid = Guid.NewGuid();
            CameraService.CreateCamera(guid, cameraInfo);
            ICamera myCamera = CameraService.GetCamera(guid);
            if ( myCamera != null )
            {
                try
                {
                    bool res = myCamera.OpenDevice();
                    if ( !res )
                    {
                        myCamera.CloseDevice();
                        myCamera = null;
                        return null;
                    }
                    else
                    {
                        myCamera.SetExposureTime(cameraInfo.ExpouseTime);
                        return myCamera;
                    }
                }
                catch 
                {
                
                }
            }
            return myCamera;
        }





        public void CloseCamera()
        {
            CurrCamera?.StopGrabbing();
            CurrCamera?.CloseDevice();
            CurrCamera = null;

        }


      

        //    // 将海康相机帧数据转换为CogImage8Grey灰度图像
        //    public static ICogImage ConvertToCogImage(IntPtr pData, ref MyCamera.MV_FRAME_OUT_INFO_EX pFrameInfo)
        //    {

        //        // 验证像素格式（支持MONO8/RGB8转灰度）
        //        if (pFrameInfo.enPixelType != MvCamCtrl.NET.MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono8 &&
        //            pFrameInfo.enPixelType != MvCamCtrl.NET.MyCamera.MvGvspPixelType.PixelType_Gvsp_RGB8_Packed)
        //        {
        //            throw new ArgumentException("Unsupported pixel format");
        //        }

        //        // 创建CogImage8Grey对象
        //        CogImage8Grey cogImage = new CogImage8Grey();
        //        int width = (int)pFrameInfo.nWidth;
        //        int height = (int)pFrameInfo.nHeight;

        //        // 分配内存并复制数据
        //        cogImage.Allocate(width, height);

        //        // 获取8位灰度图像像素内存区域
        //        ICogImage8PixelMemory pixelMemory = (cogImage).Get8GreyPixelMemory(
        //CogImageDataModeConstants.ReadWrite,
        //0, 0,
        //cogImage.Width, cogImage.Height);
        //        IntPtr destPtr = pixelMemory.Scan0;  // 获取像素数据指针

        //        // IntPtr destPtr = cogImage.GetPixelData(CogImageDataModeConstants.ReadWrite);

        //        if (pFrameInfo.enPixelType == MvCamCtrl.NET.MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono8)
        //        {
        //            // 直接拷贝MONO8数据
        //            SafeMemoryCopy(destPtr, pData, width * height);
        //        }
        //        else // RGB转灰度
        //        {
        //            byte[] rgbBuffer = new byte[width * height * 3];
        //            Marshal.Copy(pData, rgbBuffer, 0, rgbBuffer.Length);

        //            unsafe
        //            {
        //                byte* pDest = (byte*)destPtr.ToPointer();
        //                for (int i = 0; i < rgbBuffer.Length; i += 3)
        //                {
        //                    // RGB转灰度公式：0.299*R + 0.587*G + 0.114*B
        //                    *pDest++ = (byte)(0.299 * rgbBuffer[i] +
        //                                     0.587 * rgbBuffer[i + 1] +
        //                                     0.114 * rgbBuffer[i + 2]);
        //                }
        //            }
        //        }
        //        return cogImage;
        //    }

        //    // 将海康相机帧数据转换为CogImage24PlanarColor彩色图像
        //    public static ICogImage ConvertToColorCogImage(IntPtr pData, ref MyCamera.MV_FRAME_OUT_INFO_EX pFrameInfo)
        //    {
        //        if (pFrameInfo.enPixelType != MvCamCtrl.NET.MyCamera.MvGvspPixelType.PixelType_Gvsp_RGB8_Packed)
        //        {
        //            throw new ArgumentException("Only RGB8 format supported for color conversion");
        //        }

        //        CogImage24PlanarColor cogColorImage = new CogImage24PlanarColor();
        //        int width = (int)pFrameInfo.nWidth;
        //        int height = (int)pFrameInfo.nHeight;

        //        // 分配内存
        //        cogColorImage.Allocate(width, height);

        //        // 获取三个颜色平面指针

        //        CogImage8Grey red = cogColorImage.GetPlane(CogImagePlaneConstants.Red);
        //        CogImage8Grey green = cogColorImage.GetPlane(CogImagePlaneConstants.Green);
        //        CogImage8Grey blue = cogColorImage.GetPlane(CogImagePlaneConstants.Blue);



        //        IntPtr redPtr = cogColorImage.GetPlane(CogImagePlaneConstants.Red).Get8GreyPixelMemory(
        //CogImageDataModeConstants.ReadWrite,
        //0, 0,
        //red.Width, red.Height).Scan0;  // 获取像素数据指针
        //        IntPtr greenPtr = cogColorImage.GetPlane(CogImagePlaneConstants.Green).Get8GreyPixelMemory(
        //CogImageDataModeConstants.ReadWrite,
        //0, 0,
        //red.Width, red.Height).Scan0; ;
        //        IntPtr bluePtr = cogColorImage.GetPlane(CogImagePlaneConstants.Blue).Get8GreyPixelMemory(
        //CogImageDataModeConstants.ReadWrite,
        //0, 0,
        //red.Width, red.Height).Scan0; ;

        //        // 转换RGB数据到平面格式
        //        byte[] rgbBuffer = new byte[width * height * 3];
        //        Marshal.Copy(pData, rgbBuffer, 0, rgbBuffer.Length);

        //        unsafe
        //        {
        //            byte* pRed = (byte*)redPtr.ToPointer();
        //            byte* pGreen = (byte*)greenPtr.ToPointer();
        //            byte* pBlue = (byte*)bluePtr.ToPointer();

        //            for (int i = 0; i < rgbBuffer.Length; i += 3)
        //            {
        //                *pRed++ = rgbBuffer[i];     // R
        //                *pGreen++ = rgbBuffer[i + 1]; // G
        //                *pBlue++ = rgbBuffer[i + 2];  // B
        //            }
        //        }
        //        return cogColorImage;
        //    }


        public void OnSwitchToolBlock(int index)
        {
            cogToolBlock1 = VisionProManagers[index].CogToolBlock;
            CurrCamera= VisionProManagers[ index ].Camera;
            CurrCamConfig = VisionProManagers[ index ].CameraInfo;
            ToolBlockSwitched?.Invoke(index); // 触发事件，传递索引参数。
        }
        public void OnSaveSwitchToolBlock(int index)
        {
            ToolBlockCatched?.Invoke(index);
        }




    }





}