using HalconDotNet;
using LB_VisionControls;
using LB_VisionProcesses.Alogrithms;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Data.Common;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace LB_VisionProcesses
{
    [Serializable]
    public class ProcessParams
    {
        /// <summary>
        /// 输入集合
        /// </summary>
        public ProcessCollections<object> Inputs = new ProcessCollections<object>();

        /// <summary>
        /// 输出集合
        /// </summary>
        public ProcessCollections<object> Outputs = new ProcessCollections<object>();

        /// <summary>
        /// 感兴趣区域
        /// </summary>
        [JsonConverter(typeof(ROIConverter))]  // 使用自定义的 JSON 转换器
        public ROI ROI
        {
            get
            {
                return UpdataROI();
            }
            set
            {
                if (value == null)
                {
                    _kRoi.Item1 = RoiType.None;
                    _kRoi.Item2 = new double[] { };
                    return;
                }

                if (!(value is ROI))
                    return;

                Type type = value.GetType();

                if (typeof(HRectangle2) == type)
                {
                    _kRoi.Item1 = RoiType.Rectangle2;
                    _kRoi.Item2 = new double[] { value.X, value.Y
                    , ((HRectangle2)value).Phi, ((HRectangle2)value).Width, ((HRectangle2)value).Height };

                }
                else if (typeof(HCircle) == type)
                {
                    _kRoi.Item1 = RoiType.Circle;
                    _kRoi.Item2 = new double[] { value.X, value.Y, ((HCircle)value).Radius };
                }
                else if (typeof(HEllipse) == type)
                {
                    _kRoi.Item1 = RoiType.Ellipse;
                    _kRoi.Item2 = new double[] { value.X, value.Y, ((HEllipse)value).Phi, ((HEllipse)value).Radius1, ((HEllipse)value).Radius2
                    , ((HEllipse)value).StartPhi, ((HEllipse)value).EndPhi};
                }
                else if (typeof(HSegment) == type)
                {
                    _kRoi.Item1 = RoiType.Segment;
                    _kRoi.Item2 = new double[] { ((HSegment)value).StartX, ((HSegment)value).StartY
                        , ((HSegment)value).EndX, ((HSegment)value).EndY };
                }
                else
                {
                    _kRoi.Item1 = RoiType.None;
                    _kRoi.Item2 = new double[] { };
                }
            }
        }

        /// <summary>
        /// 固定跟随空间
        /// </summary>
        public Fixture Fixture = new Fixture();

        /// <summary>
        /// ROI KEY
        /// </summary>
        private (RoiType, double[]) _kRoi = (RoiType.None, new double[] { });

        /// <summary>
        /// 刷新搜索区域
        /// </summary>
        private ROI UpdataROI()
        {
            if (_kRoi.Item1 == RoiType.Rectangle2)
            {
                double[] val = _kRoi.Item2 as double[];
                return new HRectangle2(val[0], val[1], val[2], val[3], val[4]);
            }
            else if (_kRoi.Item1 == RoiType.Circle)
            {
                double[] val = _kRoi.Item2 as double[];
                return new HCircle(val[0], val[1], val[2]);
            }
            else if (_kRoi.Item1 == RoiType.Ellipse)
            {
                double[] val = _kRoi.Item2 as double[];
                return new HEllipse(val[0], val[1], val[2], val[3], val[4], val[5], val[6]);
            }
            else if (_kRoi.Item1 == RoiType.Segment)
            {
                double[] val = _kRoi.Item2 as double[];
                return new HSegment(val[0], val[1], val[2], val[3]);
            }
            else
            {
                return new ROI();
            }
        }

        public static string ConvertToString(object data)
        {
            try
            {
                if (data == null)
                {
                    return string.Empty;
                }

                Type type = data.GetType();
                switch (type)
                {
                    case Type t when t == typeof(JArray):
                        {
                            return string.Join(",", ((JArray)data).Cast<object>());
                        }
                    case Type t when t == typeof(List<int>):
                        {
                            return string.Join(",", (List<int>)data);
                        }
                    case Type t when t == typeof(List<double>):
                        {
                            return string.Join(",", ((List<double>)data).Select(x => x.ToString("F4")));
                        }
                    case Type t when t == typeof(List<string>):
                        {
                            return string.Join(",", (List<string>)data);
                        }
                    case Type t when t == typeof(List<object>):
                        {
                            return string.Join(",", (List<object>)data);
                        }
                    default:
                        {//throw new ArgumentException("Unsupported data type");
                            return data?.ToString();
                        }
                }
            }
            catch { return string.Empty; }
        }

        public static int ConvertToInt32(object data)
        {
            try
            {
                if (data == null)
                {
                    return -9994;
                }

                Type type = data.GetType();
                switch (type)
                {
                    case Type a when a == typeof(string):
                    case Type b when b == typeof(short):
                    case Type c when c == typeof(long):
                    case Type e when e == typeof(double):
                        {
                            return Convert.ToInt32(data);
                        }
                    default:
                        {//throw new ArgumentException("Unsupported data type");
                            return Convert.ToInt32(data?.ToString());
                        }
                }
            }
            catch { return -9994; }
        }

        public static double ConvertToDouble(object data)
        {
            try
            {
                if (data == null)
                {
                    return -9994;
                }

                Type type = data.GetType();
                switch (type)
                {
                    case Type a when a == typeof(string):
                    case Type b when b == typeof(short):
                    case Type c when c == typeof(long):
                    case Type e when e == typeof(double):
                    case Type f when f == typeof(float):
                        {
                            return Convert.ToDouble(data);
                        }
                    default:
                        //throw new ArgumentException("Unsupported data type");
                        {
                            return Convert.ToDouble(data?.ToString());
                        }
                }
            }
            catch { return -9994; }
        }

        public void FixDeserializedData()
        {
            for (int i = 0; i < Inputs.Count; i++)
            {
                var value = Inputs[i];
                if (value == null)
                {
                    continue;
                }

                var realValue = value;

                if (value is JArray jArray)
                {
                    realValue = (JArray.FromObject(value)).ToObject<List<string>>();
                }
                else if (value is JObject jObject)
                {
                    realValue = JsonConvert.DeserializeObject<JObject>(value.ToString())?.ToObject<Dictionary<string, object>>();
                }
                else if (value is short || value is long || value is double || value is int)
                {
                    realValue = Convert.ToDouble(value);
                }
                else if (value is bool)
                {
                    realValue = Convert.ToBoolean(value);
                }
                else
                {
                    realValue = value?.ToString();
                }

                Inputs[i] = realValue;
            }

            for (int i = 0; i < Outputs.Count; i++)
            {
                var value = Outputs[i];
                if (value == null)
                {
                    continue;
                }

                var realValue = value;
                if (value is JArray jArray)
                {
                    try
                    {
                        realValue = (JArray.FromObject(value)).ToObject<List<string>>();
                    }
                    catch
                    {
                        realValue = null;
                    }
                }
                else if (value is JObject jObject)
                {
                    try
                    {
                        realValue = JsonConvert.DeserializeObject<JObject>(value.ToString())?.ToObject<Dictionary<string, object>>();
                    }
                    catch
                    {
                        realValue = null;
                    }
                }
                else if (value is short || value is long || value is double || value is int)
                {
                    try
                    {
                        realValue = Convert.ToDouble(value);
                    }
                    catch
                    {
                        realValue = null;
                    }
                }
                else if (value is bool)
                {
                    try
                    {
                        realValue = Convert.ToBoolean(value);
                    }
                    catch
                    {
                        realValue = null;
                    }
                }
                else
                {
                    try
                    {
                        realValue = value?.ToString();
                    }
                    catch
                    {
                        realValue = null;
                    }
                }

                Outputs[i] = realValue;
            }
        }
    }
}