using Bro.Common.Factory;
using Bro.Common.Helper;
using Bro.Common.Interface;
using Bro.Common.Model.Interface;
using HalconDotNet;
using Newtonsoft.Json;
//using MvCamCtrl.NET;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Configuration;
using System.Drawing;
using System.Drawing.Design;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Windows.Forms.Design;
using static Bro.Common.Helper.EnumHelper;

namespace Bro.Common.Base
{
    public delegate void OnUpdateCameraImageDelegate(CameraBase camera, Bitmap image, string imagePath);
    public abstract class CameraBase : DeviceBase
    {
        #region DeviceBase
        protected override void Start()
        {
            if (clearImageTimer == null)
            {
                clearImageTimer = new System.Threading.Timer((o) => { ClearImage(); }, null, 0, 1000 * 60 * 120);
            }
        }

        protected override void Stop()
        {
            if (clearImageTimer != null)
            {
                clearImageTimer.Change(-1, -1);
                clearImageTimer.Dispose();
                clearImageTimer = null;
            }
        }
        #endregion

        //public Action<string, string> OnLog;

        /// <summary>
        /// 运行模式 扫描or拍照
        /// </summary>
        public EnumHelper.CameraOpMode OpMode { get; set; } = EnumHelper.CameraOpMode.Snapshot;

        /// <summary>
        /// 扫描到的图片
        /// </summary>
        public virtual object ImageObj { get; set; } = null;

        public AutoResetEvent ImageGetHandle = new AutoResetEvent(false);
        public AutoResetEvent ImageSaveDoneHandle = new AutoResetEvent(false);

        private Bitmap showImage;
        /// <summary>
        /// 输出显示的图片
        /// </summary>
        public virtual Bitmap ShowImage
        {
            get
            {
                return showImage;
            }
            set
            {
                try
                {
                    showImage = value;

                    if (showImage != null)
                    {
                        UpdateShowImage?.Invoke(this, new Bitmap(showImage), null);
                    }

                    if (OpMode == EnumHelper.CameraOpMode.Snapshot)
                    {
                        ImageGetHandle.Set();
                    }
                }
                catch (Exception ex)
                {
                    OnLog?.Invoke(DateTime.Now, this, $"相机异常信息:{ex.GetExceptionMessage()}");
                }
            }
        }

        #region 使用指针操作图像的必须信息
        ///// <summary>
        ///// 图片内容的指针
        ///// </summary>
        //public IntPtr ImagePtr { get; set; } = IntPtr.Zero;

        //public int ImagePtrSize { get; set; } = 0;

        //public int? ImageWidth
        //{
        //    get
        //    {
        //        return ShowImage?.Width;
        //    }
        //}

        //public int? ImageHeight
        //{
        //    get
        //    {
        //        return ShowImage?.Height;
        //    }
        //}

        #endregion

        private string imageFilePath;
        /// <summary>
        /// 扫描图片保存文件路径
        /// </summary>
        public string ImageFilePath
        {
            get
            {
                return imageFilePath;
            }
            set
            {

                if (imageFilePath != value)
                {
                    imageFilePath = value;
                }
            }
        }


        /// <summary>
        /// 一次性抓拍
        /// </summary>
        /// <returns></returns>
        public abstract void Snapshot();

        public abstract void Snapshot(out HObject hImage);

        public abstract void Snapshot(IOperationConfig config, out HObject hImage);

        /// <summary>
        /// 开始扫描
        /// </summary>
        /// <returns></returns>
        public abstract void StartScan();

        /// <summary>
        /// 结束扫描
        /// </summary>
        public abstract void StopScan();


        /// <summary>
        /// 释放图片数据
        /// </summary>
        protected virtual void FreeImage()
        {
            if (ShowImage != null)
            {
                ShowImage.Dispose();
            }
        }

        /// <summary>
        /// 从设备硬件信息获取设备设置参数
        /// </summary>
        /// <returns></returns>
        public abstract IDeviceConfig GetDeviceConfigFromDevice();

        public abstract IOperationConfig GetOperationConfigFromDevice();

        public abstract void UploadOperationConfig(IOperationConfig config);

        public event OnUpdateCameraImageDelegate UpdateShowImage;

        public abstract HalconRelatedCameraInitialConfigBase IConfig { get; }

        protected virtual async void SaveImage(Bitmap map, HalconRelatedCameraOprerationConfigBase opConfig = null)
        {
            await Task.Run(() =>
            {
                if ((opConfig?.IsSaveImage) ?? false)
                {
                    string subDir = (opConfig ?? new HalconRelatedCameraOprerationConfigBase()).ImageSaveSubDirectory;
                    if (string.IsNullOrWhiteSpace(subDir))
                    {
                        subDir = DateTime.Now.ToString("yyyyMMdd");
                    }
                    else
                    {
                        subDir = Path.Combine(DateTime.Now.ToString("yyyyMMdd"), subDir);
                    }

                    string imgDir = Path.Combine(IConfig.ImgDirectory, subDir);

                    DirectoryInfo dir = new DirectoryInfo(imgDir);
                    if (!dir.Exists)
                    {
                        dir.Create();
                    }

                    try
                    {
                        //if ((opConfig?.IsSaveImage) ?? false)
                        {
                            //ImageSaveDoneHandle.Reset();

                            string fileName = DateTime.Now.ToString("HHmmssfff");

                            if (opConfig.ImageType == ImageType.Bmp)
                            {
                                ImageFilePath = Path.Combine(imgDir, $"{fileName}.bmp");
                                map.Save(ImageFilePath, ImageFormat.Bmp);
                            }
                            else
                            {
                                ImageFilePath = Path.Combine(imgDir, $"{fileName}.jpg");
                                map.Save(ImageFilePath, ImageFormat.Jpeg);
                            }

                            ImageSaveDoneHandle.Set();
                        }
                    }
                    catch (Exception ex)
                    {
                    }
                }
            });
        }

        #region 定时清理图片
        static object _clearImageLock = new object();

        protected void ClearImage()
        {
            if (IConfig.SaveImageDayLimit > 0)
            {
                lock (_clearImageLock)
                {
                    OnLog?.Invoke(DateTime.Now, this, $"ClearImage Start。 {this.IConfig.CameraIP}");

                    try
                    {
                        DirectoryInfo dirImage = new DirectoryInfo(IConfig.ImgDirectory);
                        if (dirImage.Exists)
                        {
                            DateTime dtNow = DateTime.Now;

                            var folderList = dirImage.GetDirectories().ToList();

                            folderList = folderList.Where(f =>
                               {
                                   if (f.Name.Length < 8)
                                       return false;

                                   DateTime dt = DateTime.Now;
                                   string name = f.Name.Substring(0, 4) + "/" + f.Name.Substring(4, 2) + "/" + f.Name.Substring(6);
                                   return DateTime.TryParse(name, out dt);
                               }).OrderBy(u => u.Name).ToList();

                            if (folderList.Count > IConfig.SaveImageDayLimit)
                            {
                                folderList.Take(folderList.Count - IConfig.SaveImageDayLimit).ToList().ForEach(f =>
                                    {
                                        f.Delete(true);
                                    });
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        OnLog?.Invoke(DateTime.Now, this, $"ClearImage Exception\r\n{ex.GetExceptionMessage()}");
                    }

                    OnLog?.Invoke(DateTime.Now, this, $"ClearImage Done\r\n {this.IConfig.CameraIP}");
                }
            }
        }

        private System.Threading.Timer clearImageTimer = null;
        #endregion
    }

    public class CameraOperationConfigBase : OperationConfigBase, IComparer<CameraOperationConfigBase>, IComparable<CameraOperationConfigBase>
    {
        /// <summary>
        /// 运行模式
        /// </summary>
        public EnumHelper.CameraOpMode OpMode { get; set; } = EnumHelper.CameraOpMode.Snapshot;

        #region 运行参数
        /// <summary>
        /// 该参数表示哪些值参与设置
        /// </summary>
        public string ConfigItems { get; set; } = "[]"; //= "['BalanceRed','BalanceGreen','BalanceBlue','Exposure','Saturation','Gain','WhiteBalance']";

        [CameraPara("红平衡", "BalanceRed", 2, 1, 1000)]
        public double BalanceRed { get; set; } = 1;

        [CameraPara("绿平衡", "BalanceGreen", 2, 1, 1000)]
        public double BalanceGreen { get; set; } = 1;

        [CameraPara("蓝平衡", "BalanceBlue", 2, 1, 1000)]
        public double BalanceBlue { get; set; } = 1;

        [CameraPara("白平衡", "WhiteBalance", 2, 0, 1000)]
        public double WhiteBalance { get; set; } = 1;

        [CameraPara("曝光时间", "Exposure", 60000, 1, 1)]
        public double Exposure { get; set; } = 10;

        [CameraPara("饱和度", "Saturation", 2, 1, 1000)]
        public double Saturation { get; set; } = 1;

        [CameraPara("增益补偿", "Gain", 200, 0, 1)]
        public double Gain { get; set; } = 1;

        [CameraPara("采像宽度", "Width", 10000, 0, 1)]
        public int Width { get; set; } = 0;

        [CameraPara("采像高度", "Height", 10000, 0, 1)]
        public int Height { get; set; } = 0;

        [ConfigOutputResource("OutputResultCommon")]
        public override int ResultOutput { get; set; }

        public int Compare(CameraOperationConfigBase x, CameraOperationConfigBase y)
        {
            //List<string> yItems = JsonConvert.DeserializeObject<List<string>>(y.ConfigItems);
            string yItems = y.ConfigItems.Trim(new char[] { '[', ']' });

            if (string.IsNullOrWhiteSpace(yItems))
            {
                return 0;
            }
            else
            {
                if (yItems.Contains("BalanceBlue"))
                {
                    if (x.BalanceBlue != y.BalanceBlue)
                    {
                        return 1;
                    }
                }

                if (yItems.Contains("BalanceGreen"))
                {
                    if (x.BalanceGreen != y.BalanceGreen)
                    {
                        return 1;
                    }
                }

                if (yItems.Contains("BalanceRed"))
                {
                    if (x.BalanceRed != y.BalanceRed)
                    {
                        return 1;
                    }
                }

                if (yItems.Contains("WhiteBalance"))
                {
                    if (x.WhiteBalance != y.WhiteBalance)
                    {
                        return 1;
                    }
                }

                if (yItems.Contains("Exposure"))
                {
                    if (x.Exposure != y.Exposure)
                    {
                        return 1;
                    }
                }

                if (yItems.Contains("Saturation"))
                {
                    if (x.Saturation != y.Saturation)
                    {
                        return 1;
                    }
                }

                if (yItems.Contains("Gain"))
                {
                    if (x.Gain != y.Gain)
                    {
                        return 1;
                    }
                }

                if (yItems.Contains("Width"))
                {
                    if (x.Width != y.Width)
                    {
                        return 1;
                    }
                }

                if (yItems.Contains("Height"))
                {
                    if (x.Height != y.Height)
                    {
                        return 1;
                    }
                }

                return 0;
            }
        }

        /// <summary>
        /// y作为原始数据 当前数据如果ConfigItem为空时，默认无变化
        /// </summary>
        /// <param name="y">原始数据</param>
        /// <returns></returns>
        public int CompareTo(CameraOperationConfigBase y)
        {
            string xItems = ConfigItems.Trim(new char[] { '[', ']' });

            if (string.IsNullOrWhiteSpace(xItems))
            {
                return 0;
            }
            else
            {
                if (xItems.Contains("BalanceBlue"))
                {
                    if (BalanceBlue != y.BalanceBlue)
                    {
                        return 1;
                    }
                }

                if (xItems.Contains("BalanceGreen"))
                {
                    if (BalanceGreen != y.BalanceGreen)
                    {
                        return 1;
                    }
                }

                if (xItems.Contains("BalanceRed"))
                {
                    if (BalanceRed != y.BalanceRed)
                    {
                        return 1;
                    }
                }

                if (xItems.Contains("WhiteBalance"))
                {
                    if (WhiteBalance != y.WhiteBalance)
                    {
                        return 1;
                    }
                }

                if (xItems.Contains("Exposure"))
                {
                    if (Exposure != y.Exposure)
                    {
                        return 1;
                    }
                }

                if (xItems.Contains("Saturation"))
                {
                    if (Saturation != y.Saturation)
                    {
                        return 1;
                    }
                }

                if (xItems.Contains("Gain"))
                {
                    if (Gain != y.Gain)
                    {
                        return 1;
                    }
                }

                if (xItems.Contains("Width"))
                {
                    if (Width != y.Width)
                    {
                        return 1;
                    }
                }

                if (xItems.Contains("Height"))
                {
                    if (Height != y.Height)
                    {
                        return 1;
                    }
                }

                return 0;
            }
        }

        public override bool Equals(object obj)
        {
            CameraOperationConfigBase cocb = obj as CameraOperationConfigBase;
            if (cocb == null)
            {
                return false;
            }

            return CompareTo(cocb) == 0;
        }

        #endregion
    }

    public class CameraDeviceConfigBase : DeviceConfigBase
    {
        [DefaultValue("['MaxNumBuffer','GammaValue','ReverseX','ReverseY']")]
        public string ConfigItems { get; set; } = "['MaxNumBuffer','GammaValue','ReverseX','ReverseY']";

        public long MaxNumBuffer { get; set; }

        public double GammaValue { get; set; } = double.MinValue;

        public bool ReverseX { get; set; }

        public bool ReverseY { get; set; }
    }

    public class CameraInitialConfigBase : InitialConfigBase
    {
        /// <summary>
        /// 该参数表示哪些参数值对本相机有效
        /// </summary>
        public string EnableItems { get; set; }
    }

    public class CameraInputConfigBase : InputConfigBase
    {
    }

    #region HalconRelatedCameara

    public class HalconRelatedCameraOprerationConfigBase : OperationConfigBase, INotifyPropertyChanged, IComplexDisplay, IHalconToolPath
    {
        private float exposure = 0;
        /// <summary>
        /// 曝光
        /// </summary>
        [Category("取像配置")]
        [Description("曝光")]
        public float Exposure
        {
            get => exposure;
            set
            {
                if (exposure != value)
                {
                    exposure = value;
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Exposure"));
                }
            }
        }

        /// <summary>
        /// 增益
        /// </summary>
        [Category("取像配置")]
        [Description("增益")]
        public float Gain { get; set; }

        [Category("取像配置")]
        [Description("曝光修改后等待时间，单位ms。针对部分场景确保曝光修改及时生效。")]
        public int ExposureWaitTime { get; set; }

        [Category("取像配置")]
        [Description("拍摄后曝光值。可在一次拍摄后将曝光修改为下次拍摄的曝光值，节约曝光生效时间。")]
        public float ExposureAfterSnap { get; set; }

        [Browsable(false)]
        public override int ResultOutput { get; set; }

        [Category("算法配置")]
        [Description("算法路径")]
        [Editor(typeof(FileDialogEditor), typeof(UITypeEditor))]
        public string AlgorithemPath { get; set; }

        [Category("延时配置")]
        [Description("拍照前延时")]
        public int DelayBefore { get; set; } = 0;

        [Category("延时配置")]
        [Description("拍照后延时")]
        public int DelayAfter { get; set; } = 0;

        [Category("图片保存")]
        [Description("图片保存文件夹分路径")]
        public string ImageSaveSubDirectory { get; set; }

        [Category("图片保存")]
        [Description("是否保存图片")]
        public bool IsSaveImage { get; set; } = true;

        [Category("图片保存")]
        [Description("图片保存格式")]
        public ImageType ImageType { get; set; } = ImageType.Jpeg;

        [Category("图片保存")]
        [Description("是否保存拟合/结果图片")]
        public bool IsSaveFitImage { get; set; } = false;

        [Category("图片保存")]
        [Description("是否保存NG图片")]
        public bool IsSaveNGImage { get; set; } = false;

        [Category("图片保存")]
        [Description("拟合/结果图片保存路径")]
        [Editor(typeof(FoldDialogEditor), typeof(UITypeEditor))]
        public string FitImagePath { get; set; }

        public event PropertyChangedEventHandler PropertyChanged;

        public string GetDisplayText()
        {
            return $"{(IsEnabled ? "" : "停用 ")}曝光：{Exposure.ToString("f2")}";
        }

        public List<string> GetHalconToolPathList()
        {
            return new List<string>() { AlgorithemPath };
        }
    }

    public class HalconRelatedCameraInitialConfigBase : InitialConfigBase
    {
        [Category("相机设置")]
        [Description("驱动类型")]
        [TypeConverter(typeof(CameraTypeConverter))]
        public new string DriverType { get; set; } = "HikCamera";

        [Category("相机设置")]
        [Description("相机序列号")]
        [TypeConverter(typeof(HalconSerialNumConverter))]
        public virtual string SerialNum { get; set; }

        [Category("相机设置")]
        [Description("相机IP地址")]
        public string CameraIP { get; set; }

        [Category("相机设置")]
        [Description("上位机IP地址")]
        public string ComputerIP { get; set; }

        [Category("相机设置")]
        [Description("视频模式扫描间隔 单位毫秒")]
        public int ScanInterval { get; set; } = 100;

        [Category("保存设置")]
        [Description("采图保存目录")]
        [Editor(typeof(FoldDialogEditor), typeof(UITypeEditor))]
        public string ImgDirectory { get; set; } = @"../Images";

        [Category("保存设置")]
        [Description("图片保存天数")]
        [Browsable(false)]
        public int SaveImageDayLimit { get; set; } = 0;

        [Category("拍摄设置")]
        [Description("默认曝光值。相机开启后就设置该曝光值。")]
        public float DefaultExposure { get; set; }
    }

    public class HalconSerialNumConverter : ComboBoxItemTypeConvert
    {
        public override void GetConvertHash()
        {
            HTuple deviceList = null;

            AutoResetEvent handle = new AutoResetEvent(false);

            Task.Run(() =>
            {
                HOperatorSet.InfoFramegrabber("GigEVision", "info_boards", out HTuple deviceInfo, out deviceList);
                handle.Set();
            });

            handle.WaitOne(5000);
            if (deviceList != null)
            {
                for (int i = 0; i < deviceList.Length; i++)
                {
                    var list = deviceList[i].S.Split(new char[] { ':', '|' }, StringSplitOptions.RemoveEmptyEntries);

                    _hash[list[1].Trim()] = list[3].Trim() + "--" + list[1].Trim();
                }
            }
        }
    }
    #endregion

    public class CameraTypeConverter : StringConverter
    {
        public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
        {
            return true;
        }

        public override bool GetStandardValuesExclusive(ITypeDescriptorContext context)
        {
            return true;
        }

        public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
        {
            List<string> devices = DeviceFactory.GetAllSupportDeviceTypeNames();

            devices = devices.Where(u => u.EndsWith("Camera")).ToList();

            return new StandardValuesCollection(devices);
        }
    }

    public class CameraInitialConfigEditor : UITypeEditor
    {
        public override UITypeEditorEditStyle GetEditStyle(System.ComponentModel.ITypeDescriptorContext context)
        {
            return UITypeEditorEditStyle.Modal;
        }

        public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
        {
            IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));

            if (edSvc != null)
            {
                Form form = new Form();
                form.FormBorderStyle = FormBorderStyle.SizableToolWindow;
                form.StartPosition = FormStartPosition.CenterParent;
                form.Text = context.PropertyDescriptor.DisplayName + "--" + context.PropertyDescriptor.Description;

                PropertyGrid pg = new PropertyGrid();
                pg.Dock = DockStyle.Fill;
                pg.ToolbarVisible = false;

                string driverType = (value as HalconRelatedCameraInitialConfigBase).DriverType;

                if (!string.IsNullOrWhiteSpace(driverType))
                {
                    IInitialConfig initial = ConfigFactory.GetInitialConfig(driverType);
                    initial.DataFrom(value);
                    value = initial;
                }

                pg.SelectedObject = value;

                form.Controls.Add(pg);

                form.ShowDialog();

                value = pg.SelectedObject;
                return value;
            }

            return base.EditValue(context, provider, value);
        }
    }

    public static class CameraHelper
    {
        public static CameraBase GetCameraInstance(string driverType)
        {
            return DeviceFactory.GetDeviceInstanceByTypeName(driverType) as CameraBase;
        }
    }
}