using HalconDotNet;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;

namespace Bro.Common.Base
{
    public class HDevEngineTool : IDisposable
    {
        #region 常量

        // path of external procedures
        readonly string ProcedurePath = Environment.CurrentDirectory + "\\Vision\\";

        #endregion

        #region 成员变量

        /// <summary>
        /// 处理过程名
        /// </summary>
        public string ProcedureName;

        /// <summary>
        /// hdev程序启动引擎
        /// </summary>
        private readonly HDevEngine myEngine;

        /// <summary>
        /// 过程载入工具 .hdvp
        /// </summary>
        private HDevProcedureCall procedureCall;

        /// <summary>
        /// 程序运行是否成功
        /// </summary>
        public bool IsSuccessful { get; set; } = false;

        /// <summary>
        /// 控制参数字典
        /// </summary>
        public Dictionary<string, HTuple> InputTupleDic { get; set; }

        /// <summary>
        /// 图形参数字典
        /// </summary>
        public Dictionary<string, HObject> InputImageDic { get; set; }

        #endregion

        #region 初始化
        /// <summary>
        /// 实例化 默认搜索路径为: 启动路径//Vision//
        /// </summary>
        public HDevEngineTool()
        {
            ProcedureName = "";
            myEngine = new HalconDotNet.HDevEngine();
            myEngine.SetProcedurePath(ProcedurePath);

            InputImageDic = new Dictionary<string, HObject>();
            InputTupleDic = new Dictionary<string, HTuple>();
        }

        /// <summary>
        /// 实例化
        /// </summary>
        /// <param name="path">外部函数搜索路径</param>
        public HDevEngineTool(string path)
        {
            myEngine = new HalconDotNet.HDevEngine();
            myEngine.SetProcedurePath(path);

            InputImageDic = new Dictionary<string, HObject>();
            InputTupleDic = new Dictionary<string, HTuple>();
        }
        #endregion

        /// <summary>
        /// 设置函数运行所需参数
        /// </summary>
        /// <param name="_tupleDictionary">控制参数</param>
        /// <param name="_imageDictionary">图形参数</param>
        public void SetDictionary(Dictionary<string, HTuple> _tupleDictionary, Dictionary<string, HObject> _imageDictionary)
        {
            InputTupleDic = _tupleDictionary;
            InputImageDic = _imageDictionary;
        }

        /// <summary>
        /// 载入过程 .hdvp
        /// </summary>
        /// <param name="procedureName">过程名</param>
        public void LoadProcedure(string procedureName)
        {
            ProcedureName = procedureName;
            try
            {
                HDevProcedure procedure = new HDevProcedure(procedureName);
                procedureCall = new HDevProcedureCall(procedure);
            }
            catch (HDevEngineException Ex)
            {
                Trace.TraceInformation("HDevProgram {0} Load fail ,Error Line : {1}, Line number: {2}, Halcon error number : {3}", Ex.ProcedureName, Ex.LineText, Ex.LineNumber, Ex.HalconError);
                return;
            }
        }

        /// <summary>
        /// 执行过程
        /// </summary>
        public bool RunProcedure(out string errorMsg)
        {
            errorMsg = "";
            try
            {
                foreach (KeyValuePair<string, HTuple> pair in InputTupleDic)
                {
                    procedureCall.SetInputCtrlParamTuple(pair.Key, pair.Value);
                }

                foreach (KeyValuePair<string, HObject> pair in InputImageDic)
                {
                    procedureCall.SetInputIconicParamObject(pair.Key, pair.Value);
                }

                procedureCall.Execute();

                IsSuccessful = true;

                return true;
            }
            catch (HDevEngineException ex)
            {
                IsSuccessful = false;
                //Trace.TraceInformation("HDevProgram {0} Run fail , Line number: {1}, Halcon error number : {2},ex:{3}", ex.ProcedureName, ex.LineNumber, ex.HalconError, ex.Message);
                //return;
                errorMsg = $"HDevProgram {ex.ProcedureName} Run fail , Line number: {ex.LineNumber}, Halcon error number : {ex.HalconError},ex:{ex.Message}";
                return false;
            }
        }

        public HTuple GetResultTuple(string key)
        {
            if (IsSuccessful)
            {
                return procedureCall.GetOutputCtrlParamTuple(key);
            }
            else
            {
                return new HTuple();
            }

        }

        public HObject GetResultObject(string key, bool ignoreError = false)
        {
            if (ignoreError || IsSuccessful)
            {
                return procedureCall.GetOutputIconicParamObject(key);
            }
            else
            {
                return new HObject();
            }
        }

        public void Dispose()
        {
            procedureCall?.Dispose();
            myEngine?.Dispose();
        }
    }

    public static class HalconHelper
    {
        [DllImport("kernel32.dll", EntryPoint = "CopyMemory", SetLastError = false)]
        public static extern void CopyMemory(int dest, int src, uint count);
        //public static extern void CopyMemory(IntPtr dest, IntPtr src, uint count);

        public static HImage ConvertBitmapToHObject(this Bitmap bmp)
        {
            HImage himage = new HImage();
            try
            {
                //判断输入图像不为null
                if (bmp == null)
                {
                    return null;
                }

                {
                    //重绘himage
                    //HImage curImage = new HImage();
                    BitmapData bmpData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format8bppIndexed);
                    himage.GenImage1("byte", bmp.Width, bmp.Height, bmpData.Scan0);
                    bmp.UnlockBits(bmpData);
                    //himage = curImage;
                }
                return himage;
            }
            catch (Exception e)
            {
                return null;
            }
        }

        public static Bitmap ConvertHImgaeToBitmap(this HImage hImage)
        {
            try
            {
                HTuple type, width, height, pointer;
                //HOperatorSet.AccessChannel(ho, out ho, 1);
                HOperatorSet.GetImagePointer1(hImage, out pointer, out type, out width, out height);
                //himg.GetImagePointer1(out type, out width, out height);

                Bitmap bmp = new Bitmap(width.I, height.I, PixelFormat.Format8bppIndexed);
                ColorPalette pal = bmp.Palette;
                for (int i = 0; i <= 255; i++)
                {
                    pal.Entries[i] = Color.FromArgb(255, i, i, i);
                }
                bmp.Palette = pal;
                BitmapData bitmapData = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed);
                int PixelSize = Bitmap.GetPixelFormatSize(bitmapData.PixelFormat) / 8;
                int stride = bitmapData.Stride;
                int ptr = bitmapData.Scan0.ToInt32();
                for (int i = 0; i < height; i++)
                {
                    CopyMemory(ptr, pointer, (uint)(width * PixelSize));
                    pointer += width;
                    ptr += bitmapData.Stride;
                }

                bmp.UnlockBits(bitmapData);
                return bmp;
            }
            catch (Exception exc)
            {
                return null;
            }
        }

        public static List<double> HTupleToDouble(this HTuple tuple)
        {
            List<double> list = new List<double>();

            for (int i = 0; i < tuple.Length; i++)
            {
                list.Add(tuple[i]);
            }

            return list;
        }

        public static HImage ConvertHObjectToHImage(this HObject obj)
        {
            HTuple pointer, type, width, heght;
            HOperatorSet.GetImagePointer1(obj, out pointer, out type, out width, out heght);

            HImage img = new HImage();
            img.GenImage1(type, width, heght, pointer);

            return img;
        }
    }
}