using LB_VisionProcesses.Cameras;
using LB_VisionProcesses.Communicators;
using LB_VisionProcesses.Alogrithms;
using LB_VisionProcesses.Alogrithms.Halcon;
using System.Collections.Concurrent;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text.Json.Serialization;

namespace LB_VisionProcesses
{
    public abstract class IProcess : IDisposable, ICloneable
    {
        /// <summary>
        /// 流程集合
        /// </summary>
        public static Dictionary<string, string> dicProcesses = new Dictionary<string, string>
        {
            //相机
            { "相机取图", "LB_VisionProcesses.Cameras.CameraConfig" },
            ////读码器
            //{ "读码器", "LB_VisionProcesses.Cameras.CameraConfig" },
            //通讯
            { "通讯测试", "LB_VisionProcesses.Communicators.CommunicatorConfig" },
            //{ "T306通讯", "LB_VisionProcesses.Communicators.T306CommandTool" },
            { "T306通讯", "LB_VisionProcesses.Communicators.T306CommandTool" },
            { "ModbusRTU", "LB_VisionProcesses.Processes.ModbusRTUMasterTool" },
            { "ModbusTCP", "LB_VisionProcesses.Processes.ModbusTCPMasterTool" },

            //Halcon2D算法
            { "Halcon2D_模板匹配工具", "LB_VisionProcesses.Alogrithms.Halcon.HFindModelTool" },
            { "Halcon2D_多模板匹配工具", "LB_VisionProcesses.Alogrithms.Halcon.HFindMultiModelTool" },
            { "Halcon2D_斑点工具", "LB_VisionProcesses.Alogrithms.Halcon.HBlobTool" },
            { "Halcon2D_读码工具", "LB_VisionProcesses.Alogrithms.Halcon.HFindCode2dTool" },
            { "Halcon2D_找线工具", "LB_VisionProcesses.Alogrithms.Halcon.HFindLineTool" },
            { "Halcon2D_找弧工具", "LB_VisionProcesses.Alogrithms.Halcon.HFindEllipseTool" },
            { "Halcon2D_图像增强工具", "LB_VisionProcesses.Alogrithms.Halcon.HImageEnhancementTool" },
            
            //思谋深度学习算法
            { "语义分割工具", "LB_VisionProcesses.Alogrithms.BigModel.Segment.SegmentTool" },

            //图像处理
            { "单图像处理工具", "LB_VisionProcesses.Alogrithms.OneImageConvertTool" },
            { "点云转换工具", "LB_VisionProcesses.Alogrithms.PointsCloudConvertTool" },
            { "畸变矫正工具", "LB_VisionProcesses.Alogrithms.Halcon.HCaltabTool" },

            //OpenCvSharp
            { "OpenCvSharp_模板匹配工具", "LB_VisionProcesses.Alogrithms.OpenCvSharp.FindModelTool" },
            { "OpenCvSharp_斑点工具", "LB_VisionProcesses.Alogrithms.OpenCvSharp.BlobTool" },
            { "OpenCvSharp_找线工具", "LB_VisionProcesses.Alogrithms.OpenCvSharp.FindLineTool" },

            //工具
            { "创建绘制工具", "LB_VisionProcesses.Processes.RecordTool" },
            { "创建固定跟随", "LB_VisionProcesses.Alogrithms.CreateFixtureTool" },
            { "创建线段工具", "LB_VisionProcesses.Alogrithms.CreateSegmentTool" },
            { "创建垂线工具", "LB_VisionProcesses.Alogrithms.CreateVerticalTool" },
            { "线线交点工具", "LB_VisionProcesses.Alogrithms.IntersectionLine2Tool" },
            { "脚本", "LB_VisionProcesses.Processes.ScriptTool" },
            { "延时", "LB_VisionProcesses.Processes.DelayTime" },
            { "分支", "LB_VisionProcesses.Processes.ScriptTool" },
            { "多分支", "LB_VisionProcesses.Processes.ScriptTool" },

        };

        static IProcess()
        {
            _isRunningVisionProServer = true;
        }

        public static bool _isRunningVisionProServer = false;

        /// <summary>
        /// 通讯和相机集合
        /// </summary>
        public static List<BaseCommunicator> lstCommunicators = new List<BaseCommunicator>();
        public static List<BaseCamera> lstCameras = new List<BaseCamera>();

        /// <summary>
        /// 固定跟随集合
        /// </summary>
        public static ConcurrentDictionary<string, Fixture> dicFixtures = new ConcurrentDictionary<string, Fixture>();

        /// <summary>
        /// 畸变矫正集合
        /// </summary>
        public static ConcurrentDictionary<string, HCaltabMap> dicHCaltabMaps = new ConcurrentDictionary<string, HCaltabMap>();

        /// <summary>
        /// 全局变量集合(Key:变量名，Value:变量值)
        /// </summary>
        public static ConcurrentDictionary<string, object> dicGlobalVars = new ConcurrentDictionary<string, object>();

        /// <summary>
        /// 运行日志
        /// </summary>
        public string Msg = "运行成功";

        /// <summary>
        /// 运行结果
        /// </summary>
        public bool Result = true;

        /// <summary>
        /// 运行时间
        /// </summary>
        public double RunTime = 0;

        /// <summary>
        /// 允许运行时间
        /// </summary>
        public double MaxTimeOut = 2000;

        /// <summary>
        /// 工具名称
        /// </summary>
        public string strProcessName = string.Empty;

        /// <summary>
        /// 工具类名
        /// </summary>
        public string strProcessClass = "LB_VisionProcesses.IProcess";

        /// <summary>
        /// 算法参数
        /// </summary>
        public ProcessParams Params = new ProcessParams();

        /// <summary>
        /// 输入图片
        /// </summary>
        public object InputImage;

        /// <summary>
        /// 输出图片
        /// </summary>
        public object OutputImage;

        /// <summary>
        /// 结果区域
        /// </summary>
        public ObjectRecord Record = new ObjectRecord();

        /// <summary>
        /// 运行完成标记
        /// </summary>
        public bool bCompleted = false;

        public abstract void InitRunParams();

        public abstract bool Run();

        public abstract bool Load(string fullPath);

        public abstract bool Save(string filePath);

        public static Assembly GetExecutingAssembly()
        {
            return Assembly.GetExecutingAssembly();
        }

        public abstract object Clone();

        public abstract void Dispose();
    }


    [Serializable]
    public class Fixture
    {
        /// <summary>
        /// 横坐标X
        /// </summary>
        public double X = 0;
        public double Column
        {
            get { return X; }
            set { X = value; }
        }

        /// <summary>
        /// 纵坐标Y
        /// </summary>
        public double Y = 0;
        public double Row
        {
            get { return Y; }
            set { Y = value; }
        }

        /// <summary>
        /// 弧度Phi
        /// </summary>
        public double Phi = 0;
        public double Angle
        {
            get { return Phi / Math.PI * 180; }
            set { Phi = value / 180 * Math.PI; }
        }

        public string strName = "";

        public Fixture() { }

        [JsonConstructor]  // 标记为用于反序列化
        public Fixture(double x, double y, double phi, string strName)
        {
            this.X = x; this.Y = y; this.Phi = phi;
            this.strName = strName;
        }

        public Fixture(Fixture fixture)
        {
            if (fixture == null)
                return;
            this.X = fixture.X; this.Y = fixture.Y; this.Phi = fixture.Phi;
            this.strName = fixture.strName;
        }

        public Fixture(string strName) => this.strName = strName;

        public void GetOffset(double x, double y, double phi, out double offsetX, out double offsetY, out double offsetPhi)
        {
            offsetX = X - x; offsetY = Y - y; offsetPhi = Phi - phi;
        }

        public object Clone()
        {
            return MemberwiseClone();
        }
    }

    public class NaturalStringComparer : IComparer<string>
    {
        [DllImport("shlwapi.dll", CharSet = CharSet.Unicode)]
        public static extern int StrCmpLogicalW(string psz1, string psz2);
        public int Compare(string x, string y)
        {
            return StrCmpLogicalW(x, y);
        }
    }
}