using Cognex.VisionPro.ToolBlock;
using Cognex.VisionPro;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using LampInspectionMachine.Views;
using Prism.Commands;
using System.Windows;
using LampInspectionMachine.Core;
using Prism.Events;
using Prism.Ioc;
using Prism.Regions;
using Prism.Mvvm;
using System.Configuration;
using System.Drawing.Design;
using System.Windows.Forms.Integration;
using System.Threading;
using System.Windows.Interop;
using LampInspectionMachine.Model;
using System.Globalization;
using LampInspectionMachine.Log4xml;
using System.Collections.ObjectModel;
using SqlSugar;
using Cognex.VisionPro.ImageFile;
using System.IO;
using System.Windows.Media.Media3D;
using OpenCvSharp.Flann;

namespace LampInspectionMachine.ViewModels
{
    public class CameraViewModel : BindableBase, IConfirmNavigationRequest
    {
        IContainerProvider _container;
        private Management management;
        private int index;

        public int Index { get => index; set { index = value; CanmeraName = "相机" + (index + 1); } }
        
        private string _CanmeraName = "";
        public string CanmeraName { get => _CanmeraName; set { SetProperty(ref _CanmeraName, value); } }

        public Management Management { get => management; set { SetProperty(ref management, value); } }


        private ObservableCollection<string> _Logs = new ObservableCollection<string>();
        public ObservableCollection<string> Logs { get => _Logs; set => _Logs = value; }

        public CameraViewModel(IContainerProvider container, IRegionManager regionManager, IEventAggregator eventAggregator)
        {
            _container = container;
            Management = _container.Resolve<Management>();
            if(!LogHelper.CheckLogChangHandler(ShowLog))
            LogHelper.logChangHandler += ShowLog;
        }


        private DelegateCommand _SoftTriggerCommand;
        /// <summary>
        /// 开始采集
        /// </summary>
        public DelegateCommand SoftTriggerCommand =>
            _SoftTriggerCommand ?? ( _SoftTriggerCommand = new DelegateCommand(OnSoftTrigger) );


        private DelegateCommand _SoftTrigger_ContinueCommand;
        /// <summary>
        /// 开始采集
        /// </summary>
        public DelegateCommand SoftTrigger_ContinueCommand =>
            _SoftTrigger_ContinueCommand ?? ( _SoftTrigger_ContinueCommand = new DelegateCommand(OnSoftTrigger__Continue) );



        private DelegateCommand _ImageTriggerCommand;
        /// <summary>
        /// 开始采集
        /// </summary>
        public DelegateCommand ImageTriggerCommand =>
            _ImageTriggerCommand ?? ( _ImageTriggerCommand = new DelegateCommand(OnImageTrigger) );


        private DelegateCommand _ImageTrigger_ContinueCommand;
        /// <summary>
        /// 开始采集
        /// </summary>
        public DelegateCommand ImageTrigger_ContinueCommand =>
            _ImageTrigger_ContinueCommand ?? ( _ImageTrigger_ContinueCommand = new DelegateCommand(OnImageTrigger__Continue) );





        private DelegateCommand _CameraInifCommand;
        /// <summary>
        /// 相机初始化
        /// </summary>
        public DelegateCommand CameraInifCommand =>
            _CameraInifCommand ?? ( _CameraInifCommand = new DelegateCommand(OnCameraInit) );


        private DelegateCommand _CameraCloseCommand;
        /// <summary>
        /// 相机关闭
        /// </summary>
        public DelegateCommand CameraCloseCommand =>
            _CameraCloseCommand ?? ( _CameraCloseCommand = new DelegateCommand(OnCameraClose) );


        private DelegateCommand _CameraExpouseTimeSetCommand;
        /// <summary>
        /// 相机曝光写入
        /// </summary>
        public DelegateCommand CameraExpouseTimeSetCommand =>
            _CameraExpouseTimeSetCommand ?? (_CameraExpouseTimeSetCommand = new DelegateCommand(OnCameraSetExposureTime));



        private void ShowLog(Log4xml.Log log)
        {
            System.Windows.Application.Current.Dispatcher.BeginInvoke(new Action(() =>
            {
                string str = log.Msg.Trim().Replace("相机",Resources.Language.Resources.相机);
                 Logs.Add(str);
                if (Logs.Count > 100)
                {
                    Logs.RemoveAt(0);
                }
            }));

        }


        private void OnSoftTrigger()
        {
            try
            {
                Task.Run(() =>
                {
                    Management.SoftTrigger();
                }
                );
            }
            catch
            {
                MessageBox.Show("手动单张采集出错");
            }
        }
        private void OnSoftTrigger__Continue()
        {
            try
            {
                Management.SoftTrigger__Continue();
            }
            catch
            {
                MessageBox.Show("开始采集出错");
            }
        }

        private void OnImageTrigger()
        {
            try
            {
                Management.ImageTrigger();
            }
            catch
            {
                MessageBox.Show("单张图片出错");
            }
        }
        private void OnImageTrigger__Continue()
        {
            try
            {
                Management.ImageTrigger__Continue();
            }
            catch
            {
                MessageBox.Show("图片轮询出错");
            }
        }
        private void OnCameraInit()
        {
            try
            {
                if ( Management.InitCamera() )
                {
                    LogHelper.Info("初始化完成");
                    Management.CamConfigs[Index] = Management.CurrCamConfig;
                    Management.SaveCameraDevice();
                }
            }
            catch 
            {
                MessageBox.Show("相机初始化出错");
            }

        }
        /// <summary>
        /// 接收参数
        /// </summary>
        /// <param name="navigationContext"></param>
        /// <exception cref="NotImplementedException"></exception>
        public void OnNavigatedTo(NavigationContext navigationContext)
        {

            try
            {
                if ( navigationContext.Parameters.ContainsKey("Index") )
                {
                    Index = Convert.ToInt32(navigationContext.Parameters.GetValue<string>("Index"));
                    if ( Management.VisionProManagers != null )
                    {
                        if ( Index < Management.VisionProManagers.Count )
                        {
                            if (Management.CurrCamera!=null&&Management.CurrCamera.IsGrabbing) 
                            {
                              //  Management.CurrCamera.StopGrabbing();
                            }
                            Management.CurrCamera = Management.VisionProManagers[ Index ].Camera;
                            Management.CurrCamConfig = Management.VisionProManagers[ Index ].CameraInfo.Copy();
                            Management.CurrCameraSn = Management.CurrCamConfig.SerialNumber;
                            Management.Currvision = Management.VisionProManagers[ Index ];
                            if (Management.CurrCamera != null)
                            {
                                Management.CurrCamConfig.ExpouseTime = (ulong)(Management.CurrCamera.GetExposureTime());
                            }
                            else 
                            {
                                OnCameraInit();
                            }
                        }
                    }
                }

                if (!LogHelper.CheckLogChangHandler(ShowLog))
                    LogHelper.logChangHandler += ShowLog;

            }
            catch
            {
                MessageBox.Show("切换视觉界面出错");
            }
        
        }
        private void OnCameraClose()
        {

            try
            {
                Management.CloseCamera();
            }
            catch 
            {
                MessageBox.Show("相机出错");
            }
        }
        private void OnCameraSetExposureTime()
        {

            try
            {
                Management.CurrCamera.SetExposureTime(Management.CurrCamConfig.ExpouseTime);
                Management.CamConfigs[Index].ExpouseTime = Management.CurrCamConfig.ExpouseTime;
                Management.SaveCameraDevice();
            }
            catch
            {
                MessageBox.Show("相机写入曝光出错");
            }
        }
        public void ConfirmNavigationRequest(NavigationContext navigationContext, Action<bool> continuationCallback)
        {
            if ( Management.CurrCamConfig != null )
            {
                Management.VisionProManagers[Index].Camera= Management.CurrCamera;
                Management.CurrCamConfig.SerialNumber = Management.CurrCameraSn;
                Management.VisionProManagers[Index].CameraInfo = Management.CurrCamConfig.Copy();

            }
            if (!LogHelper.CheckLogChangHandler(ShowLog))
                LogHelper.logChangHandler -= ShowLog;
            continuationCallback(true);
        }

        public bool IsNavigationTarget(NavigationContext navigationContext)
        {
            return true;
        }

        public void OnNavigatedFrom(NavigationContext navigationContext)
        {

        }
    }


    public static class CogDisplayBinder
    {
        public static readonly DependencyProperty ImageSourceProperty =
        DependencyProperty.RegisterAttached(
            "ImageSource",
            typeof(ShowRender),
            typeof(CogDisplayBinder),
            new FrameworkPropertyMetadata(
                null,
                FrameworkPropertyMetadataOptions.None,
                OnImageSourceChanged));


        public static ShowRender GetImageSource(WindowsFormsHost host) =>
            (ShowRender) host.GetValue(ImageSourceProperty);

        public static void SetImageSource(WindowsFormsHost host, ShowRender value) =>
            host.SetValue(ImageSourceProperty, value);

        public static void OnImageSourceChanged(
            DependencyObject d,
            DependencyPropertyChangedEventArgs e)
        {
            if ( d is WindowsFormsHost host &&
                host.Child is CogRecordDisplay display )
            {
                if ( e.NewValue is ShowRender newRender )
                {
                    // 跨线程安全更新
                    host.Dispatcher.Invoke(() =>
                    {
                        try
                        {
                            display.Image = newRender.Image;
                            display.StaticGraphics.Clear();
                            if (newRender.Graphic != null)
                                display.StaticGraphics.AddList(newRender.Graphic, "");
                            if (newRender.Record != null)
                                display.Record = newRender.Record;
                            if (!newRender.IsSaveImage)
                            {
                                if (newRender.Result)
                                {
                                    SaveImage($"D:\\{newRender.CameraName}检测图片\\OK\\" + DateTime.Now.ToString("yyyy_MM_dd_HH_mm_ss_FFF") + ".bmp", newRender.Image);
                                }
                                else 
                                {
                                    SaveImage($"D:\\{newRender.CameraName}检测图片\\NG\\" + DateTime.Now.ToString("yyyy_MM_dd_HH_mm_ss_FFF") + ".bmp", newRender.Image);
                                }
                            }
                            display.Fit(true);
                           
                        }
                        catch
                        {

                        }
                    });
                }
                else
                {
                    host.Dispatcher.Invoke(() => display.Image = null);
                }
            }
        }


        /// <summary>
        /// 保存图像
        /// </summary>
        private static void SaveImage(string path, ICogImage image)
        {
            Task.Run(() =>
            {
                try
                {
                    DateTime now = DateTime.Now;
                    if (!Directory.Exists(Path.GetDirectoryName(path)))   //判断文件夹是否存在
                    {
                        Directory.CreateDirectory(Path.GetDirectoryName(path));    //创建文件夹
                    }
                    using (CogImageFileBMP _cogImageFileTool = new CogImageFileBMP())
                    {
                        _cogImageFileTool.Open(path, CogImageFileModeConstants.Write);
                        _cogImageFileTool.Append(image);
                        _cogImageFileTool.Close();
                    }
                }
                catch (Exception ex)
                {
                    LogHelper.Error("保存流程运行结果的图片时出错！" + ex);
                }

            });
        }
    }

}