using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.Collections;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Drawing;
using System.Runtime.Intrinsics.Arm;
using System.Xml.Serialization;
using WebWindowJWD;
using WebWindowJWD.Json;
using static WebWindowJWD.Json.WindowConst;

namespace WebWindowJWD
{

    public class Window
    {
        public event EventHandler<OnPreviewEventArgs> OnPreview = delegate { };

        private String m_sProfilePath;
        public string sProfilePath
        {
            get
            {
                return m_sProfilePath;
            }
            set
            {
                m_sProfilePath = value;
            }
        }

        private ObservableCollection<Frame> m_AreaList = new ObservableCollection<Frame>();
        public ObservableCollection<Frame> AreaList
        {
            get
            {
                return m_AreaList;
            }
            set
            {
                m_AreaList = value;
            }
        }

        internal JsonWindow Serialize()
        {
            JsonWindow JsonWindow = new JsonWindow(sProfilePath);
            foreach (var Area in AreaList)
                JsonWindow.AreaList.Add(Area.Serialize());
            return JsonWindow;
        }

        internal string sSerialized()
        {
            return JsonConvert.SerializeObject(Serialize(), Formatting.Indented);

        }

        internal void OnUpdatePreview(string sJwd)
        {
            OnPreviewEventArgs e = new OnPreviewEventArgs(sJwd);
            EventHandler<OnPreviewEventArgs> handler = OnPreview;
            if (handler != null)
            {
                handler(this, e);
            }
        }
    }

    public class OnPreviewEventArgs : EventArgs
    {
        public string sJwd;

        public OnPreviewEventArgs(string sJwd)
        {
            this.sJwd = sJwd;
        }
    }

    public abstract class Area
    {

        protected Window m_ParentWindow;
        public Window ParentWindow
        {
            get
            {
                return m_ParentWindow;
            }
        }

        protected int m_nAreaId = -1;
        public int nAreaId
        {
            get
            {
                return m_nAreaId;
            }
            set
            {
                m_nAreaId = value;
                m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
            }
        }

        private List<Area> m_AreaList = new List<Area>();
        public List<Area> AreaList
        {
            get
            {
                return m_AreaList;
            }
            set
            {
                m_AreaList = value;
            }
        }

        private AreaTypes m_AreaType;
        public AreaTypes AreaType
        {
            get
            {
                return m_AreaType;
            }
            set
            {
                m_AreaType = value;
                //m_delDrawWindow();
            }
        }
        internal void SetAreaType(AreaTypes AreaType)
        {
            m_AreaType = AreaType;
        }

        private Area m_ParentArea;
        public Area ParentArea
        {
            get
            {
                return m_ParentArea;
            }
        }
        internal void SetParentArea(Area ParentArea)
        {
            m_ParentArea = ParentArea;
        }

        public Area(Area ParentArea, Window ParentWindow)
        {
            m_ParentWindow = ParentWindow;
            m_ParentArea = ParentArea;
        }

        internal abstract JsonArea Serialize();
    }

    public class Frame : Area
    {
        private ObservableCollection<IdNameStruct> m_ShapeList = new ObservableCollection<IdNameStruct>
        {
            new IdNameStruct((int)Shapes.RECTANGLE, "Rectangle"),
                new IdNameStruct((int)Shapes.RIGHTCHAMFER, "Right Chamfer"),
                new IdNameStruct((int)Shapes.LEFTCHAMFER, "Left Chamfer"),
                new IdNameStruct((int)Shapes.DOUBLECHAMFER, "Double Chamfer"),
                new IdNameStruct((int)Shapes.ARC, "Arc"),
                new IdNameStruct((int)Shapes.ARC_FULL, "Arc Full"),
                new IdNameStruct((int)Shapes.DOUBLEARC, "Double Arc"),
                new IdNameStruct((int)Shapes.TRIANGLE, "Triangle")
        };
        public ObservableCollection<IdNameStruct> ShapeList
        {
            get
            {
                return m_ShapeList;
            }
        }

        private Shapes m_Shape;
        public Shapes Shape
        {
            get
            {
                return m_Shape;
            }
        }

        public int SelShapeIndex
        {
            get
            {
                return IdNameStruct.IndFromId((int)m_Shape, m_ShapeList);
            }
            set
            {
                Shapes SelShape = (Shapes)IdNameStruct.IdFromInd(value, m_ShapeList);
                if (m_Shape != SelShape)
                {
                    // verifico parametri Dimension
                    DimensionList.Clear();
                    // aggiungo Dimensioni
                    switch (SelShape)
                    {
                        case Shapes.RECTANGLE:
                        case Shapes.ARC_FULL:
                            {
                                DimensionList.Add(new FrameDimension(this, 1, "Width", 1500, true));
                                DimensionList.Add(new FrameDimension(this, 2, "Height", 1800, true));
                                break;
                            }

                        case Shapes.RIGHTCHAMFER:
                            {
                                DimensionList.Add(new FrameDimension(this, 1, "Width", 1500, true));
                                DimensionList.Add(new FrameDimension(this, 2, "Left Height", 1800, true));
                                DimensionList.Add(new FrameDimension(this, 3, "Right Height", 1500, true));
                                break;
                            }

                        case Shapes.LEFTCHAMFER:
                            {
                                DimensionList.Add(new FrameDimension(this, 1, "Width", 1500, true));
                                DimensionList.Add(new FrameDimension(this, 2, "Left Height", 1500, true));
                                DimensionList.Add(new FrameDimension(this, 3, "Right Height", 1800, true));
                                break;
                            }

                        case Shapes.DOUBLECHAMFER:
                        case Shapes.ARC:
                            {
                                DimensionList.Add(new FrameDimension(this, 1, "Width", 1500, true));
                                DimensionList.Add(new FrameDimension(this, 2, "Height", 1500, true));
                                DimensionList.Add(new FrameDimension(this, 3, "Full Height", 1800, true));
                                break;
                            }

                        case Shapes.DOUBLEARC:
                            {
                                DimensionList.Add(new FrameDimension(this, 1, "Width", 1500, true));
                                DimensionList.Add(new FrameDimension(this, 2, "Height", 1500, true));
                                DimensionList.Add(new FrameDimension(this, 3, "Full Height", 2400, true));
                                break;
                            }

                        case Shapes.TRIANGLE:
                            {
                                DimensionList.Add(new FrameDimension(this, 1, "Width", 2000, true));
                                DimensionList.Add(new FrameDimension(this, 2, "Height", 1500, true));
                                DimensionList.Add(new FrameDimension(this, 3, "Height projection", 0, true));
                                break;
                            }

                        case Shapes.CUSTOM:
                            {
                                DimensionList.Clear();
                                break;
                            }
                    }
                    // aggiungo Joint
                    m_JointList.Clear();
                    switch (SelShape)
                    {
                        case Shapes.RECTANGLE:
                        case Shapes.RIGHTCHAMFER:
                        case Shapes.LEFTCHAMFER:
                        case Shapes.DOUBLECHAMFER:
                        case Shapes.ARC:
                        case Shapes.DOUBLEARC:
                            {
                                JointList.Add(new Joint(this, 1, Joints.FULL_H));
                                JointList.Add(new Joint(this, 2, Joints.FULL_H));
                                JointList.Add(new Joint(this, 3, Joints.FULL_H));
                                JointList.Add(new Joint(this, 4, Joints.FULL_H));
                                break;
                            }

                        case Shapes.ARC_FULL:
                            {
                                JointList.Add(new Joint(this, 1, Joints.FULL_H));
                                JointList.Add(new Joint(this, 2, Joints.FULL_H));
                                JointList.Add(new Joint(this, 3, Joints.ANGLED));
                                JointList.Add(new Joint(this, 4, Joints.ANGLED));
                                break;
                            }

                        case Shapes.TRIANGLE:
                            {
                                JointList.Add(new Joint(this, 1, Joints.FULL_H));
                                JointList.Add(new Joint(this, 2, Joints.FULL_H));
                                JointList.Add(new Joint(this, 3, Joints.ANGLED));
                                break;
                            }

                        case Shapes.CUSTOM:
                            {
                                JointList.Clear();
                                break;
                            }
                    }
                    m_Shape = SelShape;
                }
                m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
            }
        }

        internal void SetSelShape(Shapes Value)
        {
            DimensionList.Clear();
            // aggiungo Dimension
            switch (Value)
            {
                case Shapes.RECTANGLE:
                case Shapes.ARC_FULL:
                    {
                        DimensionList.Add(new FrameDimension(this, 1, "Width", 1500, true));
                        DimensionList.Add(new FrameDimension(this, 2, "Height", 1800, true));
                        break;
                    }

                case Shapes.RIGHTCHAMFER:
                    {
                        DimensionList.Add(new FrameDimension(this, 1, "Width", 1500, true));
                        DimensionList.Add(new FrameDimension(this, 2, "Left Height", 1800, true));
                        DimensionList.Add(new FrameDimension(this, 3, "Right Height", 1500, true));
                        break;
                    }

                case Shapes.LEFTCHAMFER:
                    {
                        DimensionList.Add(new FrameDimension(this, 1, "Width", 1500, true));
                        DimensionList.Add(new FrameDimension(this, 2, "Left Height", 1500, true));
                        DimensionList.Add(new FrameDimension(this, 3, "Right Height", 1800, true));
                        break;
                    }

                case Shapes.DOUBLECHAMFER:
                case Shapes.ARC:
                    {
                        DimensionList.Add(new FrameDimension(this, 1, "Width", 1500, true));
                        DimensionList.Add(new FrameDimension(this, 2, "Height", 1500, true));
                        DimensionList.Add(new FrameDimension(this, 3, "Full Height", 1800, true));
                        break;
                    }

                case Shapes.DOUBLEARC:
                    {
                        DimensionList.Add(new FrameDimension(this, 1, "Width", 1500, true));
                        DimensionList.Add(new FrameDimension(this, 2, "Height", 1500, true));
                        DimensionList.Add(new FrameDimension(this, 3, "Full Height", 2400, true));
                        break;
                    }

                case Shapes.TRIANGLE:
                    {
                        DimensionList.Add(new FrameDimension(this, 1, "Width", 2000, true));
                        DimensionList.Add(new FrameDimension(this, 2, "Height", 1500, true));
                        DimensionList.Add(new FrameDimension(this, 3, "Height projection", 0, true));
                        break;
                    }

                case Shapes.CUSTOM:
                    {
                        DimensionList.Clear();
                        break;
                    }
            }
            // aggiungo Joint
            int nJointQty = 4;
            switch (Value)
            {
                case Shapes.RECTANGLE:
                case Shapes.RIGHTCHAMFER:
                case Shapes.LEFTCHAMFER:
                case Shapes.DOUBLECHAMFER:
                case Shapes.ARC:
                case Shapes.DOUBLEARC:
                    {
                        JointList.Add(new Joint(this, 1, Joints.FULL_H));
                        JointList.Add(new Joint(this, 2, Joints.FULL_H));
                        JointList.Add(new Joint(this, 3, Joints.FULL_H));
                        JointList.Add(new Joint(this, 4, Joints.FULL_H));
                        break;
                    }

                case Shapes.ARC_FULL:
                    {
                        JointList.Add(new Joint(this, 1, Joints.FULL_H));
                        JointList.Add(new Joint(this, 2, Joints.FULL_H));
                        JointList.Add(new Joint(this, 3, Joints.ANGLED));
                        JointList.Add(new Joint(this, 4, Joints.ANGLED));
                        break;
                    }

                case Shapes.TRIANGLE:
                    {
                        JointList.Add(new Joint(this, 1, Joints.FULL_H));
                        JointList.Add(new Joint(this, 2, Joints.FULL_H));
                        JointList.Add(new Joint(this, 3, Joints.ANGLED));
                        break;
                    }

                case Shapes.CUSTOM:
                    {
                        JointList.Clear();
                        break;
                    }
            }
            m_Shape = Value;
        }

        private ObservableCollection<FrameDimension> m_DimensionList = new ObservableCollection<FrameDimension>();
        public ObservableCollection<FrameDimension> DimensionList
        {
            get
            {
                return m_DimensionList;
            }
        }

        private ObservableCollection<Joint> m_JointList = new ObservableCollection<Joint>();
        public ObservableCollection<Joint> JointList
        {
            get
            {
                return m_JointList;
            }
            set
            {
                m_JointList = value;
            }
        }

        private bool m_bBottomRail;
        public bool BottomRail
        {
            get
            {
                return m_bBottomRail;
            }
            set
            {
                m_bBottomRail = value;
                m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
            }
        }
        internal void SetBottomRail(bool bBottomRail)
        {
            m_bBottomRail = bBottomRail;
        }

        private int m_nBottomRailQty = 0;
        public int BottomRailQty
        {
            get
            {
                return m_nBottomRailQty;
            }
            set
            {
                m_nBottomRailQty = value;
                if (m_nBottomRailQty > 0)
                {
                    m_bBottomRail = true;
                }
                else
                {
                    m_bBottomRail = false;
                }
                m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
            }
        }
        internal void SetBottomRailQty(int nBottomRailQty)
        {
            m_nBottomRailQty = nBottomRailQty;
        }

        private ObservableCollection<Curve> m_Outline;
        public ObservableCollection<Curve> Outline
        {
            get
            {
                return m_Outline;
            }
            set
            {
                m_Outline = value;
            }
        }

        public Frame(Area ParentArea, Window ParentWindow) : base(ParentArea, ParentWindow)
        {
        }

        internal static Area CreateFrame(Window Window)
        {
            Frame NewFrame = new Frame(null, Window);
            NewFrame.SetAreaType(AreaTypes.FRAME);
            NewFrame.SetSelShape(Shapes.RECTANGLE);
            NewFrame.SetBottomRail(false);
            NewFrame.SetBottomRailQty(0);
            return NewFrame;
        }

        private LuaShapes ConvertShape(Shapes value)
        {
            switch (value)
            {
                case Shapes.RECTANGLE:
                    {
                        return LuaShapes.RECT;
                    }

                case Shapes.RIGHTCHAMFER:
                    {
                        return LuaShapes.CHAMFER_SIDE;
                    }

                case Shapes.LEFTCHAMFER:
                    {
                        return LuaShapes.CHAMFER_SIDE;
                    }

                case Shapes.DOUBLECHAMFER:
                    {
                        return LuaShapes.CHAMFER;
                    }

                case Shapes.ARC:
                    {
                        return LuaShapes.SEGMENTAL_ARC;
                    }

                case Shapes.ARC_FULL:
                    {
                        return LuaShapes.ROUND_ARC;
                    }

                case Shapes.DOUBLEARC:
                    {
                        return LuaShapes.POINTED_ARC;
                    }

                case Shapes.TRIANGLE:
                    {
                        return LuaShapes.TRIANGLE;
                    }

                default:
                    {
                        return LuaShapes.RECT;
                    }
            }
        }

        internal override JsonArea Serialize()
        {
            JsonFrame JsonFrame = new JsonFrame(m_Shape, m_bBottomRail, m_nBottomRailQty);
            foreach (var Dimension in DimensionList)
                JsonFrame.DimensionList.Add(Dimension.Serialize());
            foreach (var Joint in JointList)
                JsonFrame.JointList.Add(Joint.Serialize());
            foreach (var Area in AreaList)
                JsonFrame.AreaList.Add(Area.Serialize());
            return JsonFrame;
        }
    }

    public class Sash : Area
    {
        public int nSashQty
        {
            get
            {
                return m_SashList.Count > 0 ? m_SashList.Count : 1;
            }
            set
            {
                if (value > m_SashList.Count)
                {
                    // recupero larghezza ultimo
                    double dLastDimension = 100;
                    double dNewDimension = 100;
                    if (m_SashList.Count > 0)
                    {
                        dLastDimension = m_SashList[m_SashList.Count - 1].dDimension;
                        dNewDimension = dLastDimension / (value + 1 - nSashQty);
                        m_SashList[m_SashList.Count - 1].SetDimension(dNewDimension);
                    }
                    else
                        dNewDimension = dLastDimension / (value + 1 - nSashQty);
                    // aggiungo area Sash di default
                    for (var SplitIndex = m_SashList.Count; SplitIndex <= value - 1; SplitIndex++)
                    {
                        SashList.Add(new SashDimension(dNewDimension, true, this));
                    }
                }
                else if (value < m_SashList.Count)
                {
                    double dLastDimension = 0;
                    for (var SplitIndex = m_SashList.Count - 1; SplitIndex >= value; SplitIndex += -1)
                    {
                        dLastDimension += m_SashList[SplitIndex].dDimension;
                        SashList.RemoveAt(SplitIndex);
                    }
                    dLastDimension += m_SashList[SashList.Count - 1].dDimension;
                    SashList[SashList.Count - 1].SetDimension(dLastDimension);
                }
                if (m_SashList.Count == 1)
                {
                    List<Area> ContentArea = new List<Area>();
                    while (AreaList.Count > 0)
                    {
                        if (AreaList.Count == 1 & AreaList[0].AreaList.Count > 0)
                        {
                            foreach (Area selArea in AreaList[0].AreaList)
                            {
                                ContentArea.Add(selArea);
                            }
                        }
                        AreaList.Remove(AreaList[AreaList.Count - 1]);
                    }
                    if (ContentArea.Count > 0)
                    {
                        AreaList = ContentArea;
                    }
                }
                else
                {
                    List<Area> ContentArea = new List<Area>();
                    if (AreaList.Count == 1 & SashList.Count > AreaList.Count)
                    {
                        ContentArea.Add(AreaList.ElementAt(0));
                        AreaList.Clear();
                    }
                    for (int SplitIndex = AreaList.Count; SplitIndex <= SashList.Count - 1; SplitIndex++)
                    {
                        AreaList.Add(Splitted.CreateSplitted(this));
                    }
                    for (int SplitIndex = SashList.Count; SplitIndex <= AreaList.Count() - 1; SplitIndex++)
                    {
                        AreaList.Remove(AreaList[AreaList.Count - 1]);
                    }
                    if (AreaList[AreaList.Count - 1].AreaList.Count == 0)
                    {
                        if (ContentArea.Count > 0)
                        {
                            for (int SplitIndex = 0; SplitIndex <= AreaList.Count() - 1; SplitIndex++)
                            {
                                if (SplitIndex == 0)
                                {
                                    AreaList[0].AreaList.Add(ContentArea[0]);
                                }
                                else
                                {
                                    AreaList[SplitIndex].AreaList.Add(Fill.CreateFill(AreaList[SplitIndex], FillTypes.GLASS));
                                }
                            }
                        }
                        else
                        {
                            AreaList[AreaList.Count - 1].AreaList.Add(Fill.CreateFill(AreaList[AreaList.Count - 1], FillTypes.GLASS));
                            //AreaList[AreaList.Count - 1] = AreaList[AreaList.Count - 2];
                        }
                    }
                }
                //RefreshHardwareList();
                RefreshHardwareOptionList();
                //SetFirstHardware();
                m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
            }
        }
        internal void SetSashQty(int Qty)
        {
            if (Qty > m_SashList.Count)
            {
                // recupero larghezza ultimo
                double dLastDimension = 100;
                double dNewDimension = 100;
                if (m_SashList.Count > 0)
                {
                    dLastDimension = m_SashList[m_SashList.Count - 1].dDimension;
                    dNewDimension = dLastDimension / (Qty + 1 - nSashQty);
                    m_SashList[m_SashList.Count - 1].dDimension = dNewDimension;
                }
                else
                    dNewDimension = dLastDimension / (Qty + 1 - nSashQty);
                // aggiungo area Sash di default
                for (var SplitIndex = m_SashList.Count; SplitIndex <= Qty - 1; SplitIndex++)
                    SashList.Add(new SashDimension(dNewDimension, true, this));
            }
            else if (Qty < m_SashList.Count)
            {
                for (var SplitIndex = m_SashList.Count - 1; SplitIndex >= Qty; SplitIndex += -1)
                    SashList.RemoveAt(SplitIndex);
            }
        }

        private List<IdNameStruct> m_OrientationSashTypeList = new List<IdNameStruct>
        {
            new IdNameStruct((int)OrientationSash.VERTICAL, "Vertical"),
            new IdNameStruct((int)OrientationSash.HORIZONTAL, "Horizontal"),
        };
        public List<IdNameStruct> OrientationSashTypeList
        {
            get
            {
                return m_OrientationSashTypeList;
            }
        }

        private OrientationSash m_SelOrientationSashType;
        public OrientationSash SelOrientationSashType
        {
            get
            {
                return m_SelOrientationSashType;
            }
            set
            {
                m_SelOrientationSashType = value;
            }
        }

        public OrientationSash OrientationSashType
        {
            get
            {
                return (OrientationSash)m_SelOrientationSashType;
            }
        }
        internal void SetOrientationSashType(OrientationSash value)
        {
            m_SelOrientationSashType = value;
        }
        public int SelOrientationSashTypeIndex
        {
            get
            {
                return IdNameStruct.IndFromId((int)m_SelOrientationSashType, m_OrientationSashTypeList);
            }
            set
            {
                m_SelOrientationSashType = (OrientationSash)IdNameStruct.IdFromInd(value, m_OrientationSashTypeList);
                if (value == 0)
                {
                    m_bIsSashVertical = true;
                }
                else
                {
                    m_bIsSashVertical = false;
                }
                m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
            }
        }


        private bool m_bIsSashVertical;
        public bool bIsSashVertical
        {
            get
            {
                return m_bIsSashVertical;
            }
            set
            {
                m_bIsSashVertical = value;
            }
        }
        internal void SetIsSashVertical(bool IsSashVertical)
        {
            m_bIsSashVertical = IsSashVertical;
            if (IsSashVertical)
            {
                m_SelOrientationSashType = OrientationSash.VERTICAL;
            }
            else
            {
                m_SelOrientationSashType = OrientationSash.HORIZONTAL;
            }
        }

        private bool m_bIsMeasureGlass;
        public bool bIsMeasureGlass
        {
            get
            {
                return m_bIsMeasureGlass;
            }
            set
            {
                m_bIsMeasureGlass = value;
            }
        }
        internal void SetIsMeasureGlass(bool IsMeasureGlass)
        {
            m_bIsMeasureGlass = IsMeasureGlass;
        }

        private ObservableCollection<SashDimension> m_SashList = new ObservableCollection<SashDimension>();
        public ObservableCollection<SashDimension> SashList
        {
            get
            {
                return m_SashList;
            }
            set
            {
                m_SashList = value;
            }
        }

        private SashTypes m_SashType;
        public SashTypes SashType
        {
            get
            {
                return m_SashType;
            }
            set
            {
                m_SashType = value;
            }
        }
        internal void SetSashType(SashTypes SashType)
        {
            m_SashType = SashType;
        }

        private ObservableCollection<Joint> m_JointList = new ObservableCollection<Joint>();
        public ObservableCollection<Joint> JointList
        {
            get
            {
                return m_JointList;
            }
            set
            {
                m_JointList = value;
            }
        }

        private bool m_bSashBottomRail;
        public bool SashBottomRail
        {
            get
            {
                return m_bSashBottomRail;
            }
            set
            {
                m_bSashBottomRail = value;
            }
        }
        internal void SetSashBottomRail(bool bBottomRail)
        {
            m_bSashBottomRail = bBottomRail;
        }

        private int m_nSashBottomRailQty;
        public int SashBottomRailQty
        {
            get
            {
                return m_nSashBottomRailQty;
            }
            set
            {
                m_nSashBottomRailQty = value;
                if (m_nSashBottomRailQty > 0)
                {
                    m_bSashBottomRail = true;
                }
                else
                {
                    m_bSashBottomRail = false;
                }
                m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
            }
        }
        internal void SetSashBottomRailQty(int nBottomRailQty)
        {
            m_nSashBottomRailQty = nBottomRailQty;
        }

        private bool m_bIsPercentage = true;
        public bool bIsPercentage
        {
            get
            {
                return m_bIsPercentage;
            }
        }

        private ObservableCollection<Hardware> m_HardwareList = new ObservableCollection<Hardware>();
        public ObservableCollection<Hardware> HardwareList
        {
            get
            {
                return m_HardwareList;
            }
        }

        private Hardware m_SelHardware;
        //public Hardware SelHardware
        //{
        //    get
        //    {
        //        return m_SelHardware;
        //    }
        //    set
        //    {
        //        m_SelHardware = value;
        //        if (m_SelHardware != null && m_SelHardware.sId != "000000")
        //        {
        //            string sHwdOptPath = "";
        //            var gf = EgtLuaCreateGlobTable("WDG");
        //            var tft = EgtLuaSetGlobIntVar("WDG.AREAID", m_nAreaId);
        //            var tfy = EgtLuaSetGlobStringVar("WDG.HDWFAVOURITE", value.sId);
        //            SashDimension HandleSash = m_SashList.FirstOrDefault(x => x.bHasHandle);
        //            string sHandle = "Dx";
        //            switch (GetOpeningSide(HandleSash.OpeningType))
        //            {
        //                case object _ when OpeningSides.LEFT:
        //                    {
        //                        sHandle = "Sx";
        //                        break;
        //                    }

        //                case object _ when OpeningSides.RIGHT:
        //                    {
        //                        sHandle = "Dx";
        //                        break;
        //                    }
        //            }
        //            var tfd = EgtLuaSetGlobStringVar("WDG.HDWHANDLE", sHandle);
        //            var tlt = EgtLuaCallFunction("WinCreate_GetHardwareOptionPath");
        //            var tltf = EgtLuaGetGlobStringVar("WDG.HWDOPTPATH", sHwdOptPath);
        //            if (!string.IsNullOrWhiteSpace(sHwdOptPath))
        //            {
        //                XmlSerializer serializer = new XmlSerializer(typeof(ParametriOpzioni));
        //                ParametriOpzioni HwdOptions = null/* TODO Change to default(_) if this is not a reference type */;
        //                string sHdwOptPath = Path.ChangeExtension(sHwdOptPath, ".opt");
        //                bool bHdwOptFound = false;
        //                for (var WaitIndex = 0; WaitIndex <= 100; WaitIndex++)
        //                {
        //                    if (File.Exists(sHdwOptPath))
        //                    {
        //                        bHdwOptFound = true;
        //                        break;
        //                    }
        //                    System.Threading.Thread.Sleep(100);
        //                }
        //                if (bHdwOptFound)
        //                {
        //                    string sHwdOptText = "";
        //                    try
        //                    {
        //                        sHwdOptText = File.ReadAllText(sHdwOptPath);
        //                    }
        //                    catch (Exception ex)
        //                    {
        //                        EgtOutLog("Hardware file opt not found or read!");
        //                    }
        //                    if (!string.IsNullOrWhiteSpace(sHwdOptText))
        //                    {
        //                        using (TextReader reader = new StringReader(sHwdOptText))
        //                        {
        //                            HwdOptions = serializer.Deserialize(reader);
        //                        }
        //                        if (!IsNothing(HwdOptions))
        //                        {
        //                            m_HwdOptionList.Clear();
        //                            foreach (var HdwOption in HwdOptions.Items)
        //                                m_HwdOptionList.Add(new AGBOption(HdwOption));
        //                            NotifyPropertyChanged(nameof(HwdOptionList));
        //                        }
        //                    }
        //                }
        //                var ud = EgtLuaResetGlobVar("WDG");
        //            }
        //        }
        //    }
        //}

        //internal void SetSelHardware(Hardware value)
        //{
        //    m_SelHardware = value;
        //}

        //internal void SetSelHardwareFromId(string sId)
        //{
        //    m_SelHardware = m_HardwareList.FirstOrDefault(x => x.sId == sId);
        //    if (IsNothing(m_SelHardware))
        //        m_SelHardware = m_HardwareList(0);
        //}

        //internal void SetFirstHardware()
        //{
        //    if (m_HardwareList.Count > 0)
        //    {
        //        m_SelHardware = m_HardwareList(0);
        //    }
        //}

        private ObservableCollection<AGBOption> m_HwdOptionList = new ObservableCollection<AGBOption>();
        public ObservableCollection<AGBOption> HwdOptionList
        {
            get
            {
                return m_HwdOptionList;
            }
        }

        public Sash(Area ParentArea, Window ParentWindow) : base(ParentArea, ParentWindow)
        {
        }

        internal static Sash CreateSash(Area Area)
        {
            Sash NewSash = new Sash(Area, Area.ParentWindow);
            NewSash.SetAreaType(AreaTypes.SASH);
            NewSash.SetSashQty(1);
            NewSash.SetOrientationSashType(OrientationSash.VERTICAL);
            NewSash.SetIsSashVertical(true);
            // recupero numero di lati dell'area contenitore
            //int nOutlineLayerId = EgtGetFirstNameInGroup(Area.nAreaId, WIN_OUTLINE);
            //int nJointQty = EgtGetGroupObjs(nOutlineLayerId);
            //for (var JointIndex = 0; JointIndex <= nJointQty - 1; JointIndex++)
            //    NewSash.JointList.Add(new Joint(JointIndex + 1, Joints.FULL_H));
            NewSash.SetSashBottomRail(false);
            NewSash.SetSashBottomRailQty(0);
            //NewSash.RefreshHardwareList();
            NewSash.RefreshHardwareOptionList();
            //NewSash.SetFirstHardware();
            return NewSash;
        }

        internal OpeningTypes GetOpeningType(Openings OpeningType)
        {
            switch (OpeningType)
            {
                case Openings.TURNONLY_LEFT:
                case Openings.TURNONLY_RIGHT:
                    {
                        return OpeningTypes.TURNONLY;
                    }

                case Openings.TILTTURN_LEFT:
                case Openings.TILTTURN_RIGHT:
                    {
                        return OpeningTypes.TILTTURN;
                    }

                case Openings.TILTONLY_TOP:
                case Openings.TILTONLY_BOTTOM:
                    {
                        return OpeningTypes.TILTONLY;
                    }

                case Openings.PIVOT:
                    {
                        return OpeningTypes.PIVOT;
                    }

                case Openings.FIXED:
                    {
                        return OpeningTypes.FIXED;
                    }

                case Openings.COMPLANARSLIDE_LEFT:
                case Openings.COMPLANARSLIDE_RIGHT:
                    {
                        return OpeningTypes.COMPLANARSLIDE;
                    }

                case Openings.LIFTSLIDE_LEFT:
                case Openings.LIFTSLIDE_RIGHT:
                    {
                        return OpeningTypes.LIFTSLIDE;
                    }

                default:
                    {
                        return OpeningTypes.NULL;
                    }
            }
        }

        private string ConvertOpeningType()
        {
            if (m_SashList.Any(x => GetOpeningType(x.OpeningType) == OpeningTypes.TILTTURN))
                return "AR";
            else
                switch (GetOpeningType(m_SashList[0].OpeningType))
                {
                    case OpeningTypes.TURNONLY:
                        {
                            return "AB";
                        }

                    case OpeningTypes.TILTONLY:
                        {
                            return "VA";
                        }

                    case OpeningTypes.PIVOT:
                        {
                            return "BI";
                        }

                    case OpeningTypes.COMPLANARSLIDE:
                        {
                            return "CO";
                        }

                    case OpeningTypes.LIFTSLIDE:
                        {
                            return "AS";
                        }

                    default:
                        {
                            return "";
                        }
                }
        }

        //internal void RefreshHardwareList()
        //{
        //    m_HardwareList.Clear();
        //    string sSashShape = FindSashShape();
        //    string sOpeningType = ConvertOpeningType();
        //    m_HardwareList = new ObservableCollection<Hardware>(from Hardware in Map.refManageWindowVM.HardwareList
        //                                                        where Hardware.sId == "000000" || (Hardware.nSashQty == nSashQty && Hardware.sShape == sSashShape && Hardware.sOpeningType == sOpeningType)
        //                                                        select Hardware);
        //}

        internal void RefreshHardwareOptionList()
        {
            m_HwdOptionList.Clear();
        }

        internal OpeningSides GetOpeningSide(Openings OpeningType)
        {
            switch (OpeningType)
            {
                case Openings.TURNONLY_LEFT:
                case Openings.TILTTURN_LEFT:
                case Openings.TILTONLY_TOP:
                case Openings.COMPLANARSLIDE_LEFT:
                case Openings.LIFTSLIDE_LEFT:
                    {
                        return OpeningSides.LEFT;
                    }

                case Openings.TURNONLY_RIGHT:
                case Openings.TILTTURN_RIGHT:
                case Openings.TILTONLY_BOTTOM:
                case Openings.COMPLANARSLIDE_RIGHT:
                case Openings.LIFTSLIDE_RIGHT:
                    {
                        return OpeningSides.RIGHT;
                    }

                default:
                    {
                        return OpeningSides.NULL;
                    }
            }
        }

        internal override JsonArea Serialize()
        {
            JsonSash JsonSash = new JsonSash(m_bIsSashVertical, m_SashType, m_bSashBottomRail, m_nSashBottomRailQty/*, m_SelHardware.sId*/);
            foreach (var SashDimension in SashList)
                JsonSash.SashList.Add(SashDimension.Serialize());
            foreach (var Joint in JointList)
                JsonSash.JointList.Add(Joint.Serialize());
            foreach (var Area in AreaList)
                JsonSash.AreaList.Add(Area.Serialize());
            return JsonSash;
        }
    }

    public class Split : Area
    {
        public int nSplitQty
        {
            get
            {
                return m_SplitPositionList.Count > 0 ? m_SplitPositionList.Count - 1 : 0;
            }
            set
            {
                if (value > m_SplitPositionList.Count - 1)
                {
                    // recupero larghezza ultimo
                    double dLastDimension = 100;
                    double dNewDimension = 100;
                    if (m_SplitPositionList.Count > 0)
                    {
                        dLastDimension = m_SplitPositionList[m_SplitPositionList.Count - 1].dDimension;
                        dNewDimension = dLastDimension / (value + 1 - nSplitQty);
                        m_SplitPositionList[m_SplitPositionList.Count - 1].SetDimension(dNewDimension);
                    }
                    else
                        dNewDimension = dLastDimension / (value + 1 - nSplitQty);
                    // aggiungo area Split di default
                    for (var SplitIndex = m_SplitPositionList.Count; SplitIndex <= value; SplitIndex++)
                        SplitPositionList.Add(new SplitDimension(dNewDimension, true, this));
                }
                else if (value < m_SplitPositionList.Count - 1)
                {
                    double dLastDimension = 0;
                    for (var SplitIndex = m_SplitPositionList.Count - 1; SplitIndex >= value + 1; SplitIndex += -1)
                    {
                        dLastDimension += m_SplitPositionList[SplitIndex].dDimension;
                        SplitPositionList.RemoveAt(SplitIndex);
                    }
                    dLastDimension += m_SplitPositionList[SplitPositionList.Count - 1].dDimension;
                    SplitPositionList[SplitPositionList.Count - 1].SetDimension(dLastDimension);
                }
                for (var SplitIndex = AreaList.Count; SplitIndex <= SplitPositionList.Count - 1; SplitIndex++)
                {
                    AreaList.Add(Splitted.CreateSplitted(this));
                    AreaList.Last().AreaList.Add(Fill.CreateFill(AreaList.Last(), FillTypes.GLASS));
                }
                for (var SplitIndex = SplitPositionList.Count; SplitIndex <= AreaList.Count - 1; SplitIndex++)
                {
                    AreaList.Remove(AreaList[AreaList.Count - 1]);
                }
                m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
            }
        }

        internal void SetSplitQty(int Qty, bool NotifyProperty = false)
        {
            if (Qty > m_SplitPositionList.Count)
            {
                // recupero larghezza ultimo
                double dLastDimension = 100;
                double dNewDimension = 100;
                if (m_SplitPositionList.Count > 0)
                {
                    dLastDimension = m_SplitPositionList[m_SplitPositionList.Count - 1].dDimension;
                    dNewDimension = dLastDimension / (Qty + 1 - nSplitQty);
                    m_SplitPositionList[m_SplitPositionList.Count - 1].dDimension = dNewDimension;
                }
                else
                    dNewDimension = dLastDimension / (Qty + 1 - nSplitQty);
                // aggiungo area Split di default
                for (var SplitIndex = m_SplitPositionList.Count; SplitIndex <= Qty; SplitIndex++)
                    SplitPositionList.Add(new SplitDimension(dNewDimension, true, this));
            }
            else if (Qty < m_SplitPositionList.Count)
            {
                for (var SplitIndex = m_SplitPositionList.Count - 1; SplitIndex >= Qty; SplitIndex += -1)
                    SplitPositionList.RemoveAt(SplitIndex);
            }
        }

        private ObservableCollection<IdNameStruct> m_SplitShapeList = new ObservableCollection<IdNameStruct>
        {
            new IdNameStruct((int)SplitShapes.VERTICAL, "Vertical"),
            new IdNameStruct((int)SplitShapes.HORIZONTAL, "Horizontal"),
            new IdNameStruct((int)SplitShapes.GRID, "Grid"),
            new IdNameStruct((int)SplitShapes.CUSTOM, "Custom")
        };
        public ObservableCollection<IdNameStruct> SplitShapeList
        {
            get
            {
                return m_SplitShapeList;
            }
        }

        private SplitShapes m_SelSplitShape;
        public int SelSplitShapeIndex
        {
            get
            {
                return IdNameStruct.IndFromId((int)m_SelSplitShape, m_SplitShapeList);
            }
            set
            {
                m_SelSplitShape = (SplitShapes)IdNameStruct.IdFromInd(value, m_SplitShapeList);
                m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
            }
        }
        internal void SetSplitShape(SplitShapes Value, bool NotifyProperty = false)
        {
            m_SelSplitShape = Value;
        }
        internal SplitShapes SelSplitShape
        {
            get
            {
                return m_SelSplitShape;
            }
        }

        private bool m_bIsPercentage = true;
        public bool bIsPercentage
        {
            get
            {
                return m_bIsPercentage;
            }
        }

        private ObservableCollection<SplitDimension> m_SplitPositionList = new ObservableCollection<SplitDimension>();
        public ObservableCollection<SplitDimension> SplitPositionList
        {
            get
            {
                return m_SplitPositionList;
            }
            set
            {
                m_SplitPositionList = value;
            }
        }

        private Curve m_Split;
        public Curve sSplit
        {
            get
            {
                return m_Split;
            }
            set
            {
                m_Split = value;
            }
        }

        public Split(Area ParentArea, Window ParentWindow) : base(ParentArea, ParentWindow)
        {
        }

        internal static Split CreateSplit(Area Area, SplitShapes SplitShape)
        {
            Split Split = new Split(Area, Area.ParentWindow);
            Split.SetAreaType(AreaTypes.SPLIT);
            Split.SetSplitShape(SplitShape, true);
            return Split;
        }

        internal override JsonArea Serialize()
        {
            JsonSplit JsonSplit = new JsonSplit(m_SelSplitShape);
            foreach (var SplitPosition in m_SplitPositionList)
                JsonSplit.SplitPositionList.Add(SplitPosition.Serialize());
            foreach (var Area in AreaList)
                JsonSplit.AreaList.Add(Area.Serialize());
            return JsonSplit;
        }
    }

    public class Splitted : Area
    {
        public Splitted(Area ParentArea, Window ParentWindow) : base(ParentArea, ParentWindow)
        {
        }

        internal static Splitted CreateSplitted(Area Area)
        {
            Splitted Splitted = new Splitted(Area, Area.ParentWindow);
            Splitted.SetAreaType(AreaTypes.SPLITTED);
            return Splitted;
        }

        internal override JsonArea Serialize()
        {
            JsonSplitted JsonSplitted = new JsonSplitted();
            foreach (var Area in AreaList)
                JsonSplitted.AreaList.Add(Area.Serialize());
            return JsonSplitted;
        }
    }

    public class Fill : Area
    {
        private List<IdNameStruct> m_FillTypeList = new List<IdNameStruct>
        {
            new IdNameStruct((int)FillTypes.GLASS, "Glass"),
            new IdNameStruct((int)FillTypes.WOOD, "Wood")
        };
        public List<IdNameStruct> FillTypeList
        {
            get
            {
                return m_FillTypeList;
            }
        }
        private FillTypes m_SelFillType;
        public FillTypes SelFillType
        {
            get
            {
                return m_SelFillType;
            }
            set
            {
                m_SelFillType = value;
            }
        }

        public FillTypes FillType
        {
            get
            {
                return (FillTypes)m_SelFillType;
            }
        }
        internal void SetFillType(FillTypes value)
        {
            m_SelFillType = value;
        }
        public int SelFillTypeIndex
        {
            get
            {
                return IdNameStruct.IndFromId((int)m_SelFillType, m_FillTypeList);
            }
            set
            {
                m_SelFillType = (FillTypes)IdNameStruct.IdFromInd(value, m_FillTypeList);
                m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
            }
        }

        public Fill(Area ParentArea, Window ParentWindow) : base(ParentArea, ParentWindow)
        {
        }

        internal static Fill CreateFill(Area Area, FillTypes FillType)
        {
            Fill Fill = new Fill(Area, Area.ParentWindow);
            Fill.SetAreaType(AreaTypes.FILL);
            Fill.SetFillType(FillType);
            return Fill;
        }

        internal override JsonArea Serialize()
        {
            JsonFill JsonFill = new JsonFill(FillType);
            foreach (var Area in AreaList)
                JsonFill.AreaList.Add(Area.Serialize());
            return JsonFill;
        }
    }

    public class Joint
    {
        protected Area m_ParentArea;
        public Area ParentArea
        {
            get
            {
                return m_ParentArea;
            }
        }
        private int m_nIndex;
        public int nIndex
        {
            get
            {
                return m_nIndex;
            }
        }

        private List<IdNameStruct> m_JointTypeList = new List<IdNameStruct>
            {
                new IdNameStruct((int)Joints.ANGLED, "Angled"),
                new IdNameStruct((int)Joints.FULL_H, "Full H"),
                new IdNameStruct((int)Joints.FULL_V, "Full V")
            };
        public List<IdNameStruct> JointTypeList
        {
            get
            {
                return m_JointTypeList;
            }
        }

        private Joints m_SelJointType;
        public int SelJointTypeIndex
        {
            get
            {
                return IdNameStruct.IndFromId((int)m_SelJointType, m_JointTypeList);
            }
            set
            {
                m_SelJointType = (Joints)IdNameStruct.IdFromInd(value, m_JointTypeList);
                m_ParentArea.ParentWindow.OnUpdatePreview(m_ParentArea.ParentWindow.sSerialized());
            }
        }
        public Joints SelJointType
        {
            get
            {
                return m_SelJointType;
            }
            set
            {
                m_SelJointType = value;
            }
        }
        internal void SetSelJointType(Joints value)
        {
            m_SelJointType = value;
            //NotifyPropertyChanged(nameof(SelJointTypeIndex));
        }
        public Joint(Area ParentArea, int nIndex, Joints SelJointType)
        {
            m_ParentArea = ParentArea;
            m_nIndex = nIndex;
            m_SelJointType = SelJointType;
        }

        internal JsonJoint Serialize()
        {
            JsonJoint JsonJoint = new JsonJoint(m_nIndex, m_SelJointType);
            return JsonJoint;
        }
    }

    public class Curve
    {
        private GDB_TY m_CurveType;
        public GDB_TY CurveType
        {
            get
            {
                return m_CurveType;
            }
            set
            {
                m_CurveType = value;
            }
        }

        private Point3d m_ptStart;
        public Point3d ptStart
        {
            get
            {
                return m_ptStart;
            }
            set
            {
                m_ptStart = value;
            }
        }

        private Point3d m_ptEnd;
        public Point3d ptEnd
        {
            get
            {
                return m_ptEnd;
            }
            set
            {
                m_ptEnd = value;
            }
        }
    }

    public class Hardware
    {
        private string m_sId;
        public string sId
        {
            get
            {
                return m_sId;
            }
        }

        private string m_sName;
        public string sName
        {
            get
            {
                return m_sName;
            }
        }

        private string m_sOpeningType;
        public string sOpeningType
        {
            get
            {
                return m_sOpeningType;
            }
        }

        private string m_sShape;
        public string sShape
        {
            get
            {
                return m_sShape;
            }
        }

        private int m_nSashQty;
        public int nSashQty
        {
            get
            {
                return m_nSashQty;
            }
        }

        private int m_nSashPosition;
        public int nSashPosition
        {
            get
            {
                return m_nSashPosition;
            }
        }

        public Hardware(string sId, string sName, string sOpeningType, string sShape, int nSashQty, int nSashPosition)
        {
            m_sId = sId;
            m_sName = sName;
            m_sOpeningType = sOpeningType;
            m_sShape = sShape;
            m_nSashQty = nSashQty;
            m_nSashPosition = nSashPosition;
        }
    }

    public class AGBOption
    {
        public enum HDWOPTIONTYPES : int
        {
            TEXT = 1,
            LENGHT = 2,
            COMBO = 3
        }

        private HDWOPTIONTYPES m_Type;
        public HDWOPTIONTYPES Type
        {
            get
            {
                return m_Type;
            }
        }

        private string m_sName;
        public string sName
        {
            get
            {
                return m_sName;
            }
        }

        private string m_sDescription;
        public string sDescription
        {
            get
            {
                return m_sDescription;
            }
        }

        private List<AGBOptionParameter> m_ValueList = new List<AGBOptionParameter>();
        public List<AGBOptionParameter> ValueList
        {
            get
            {
                return m_ValueList;
            }
        }

        private AGBOptionParameter m_sValue;
        public AGBOptionParameter sValue
        {
            get
            {
                return m_sValue;
            }
            set
            {
                m_sValue = value;
            }
        }

        private Visibility m_OptVisibility;
        public Visibility OptVisibility
        {
            get
            {
                return m_OptVisibility;
            }
        }

        //public AGBOption(ParametriOpzioniParametri HdwOptionParam)
        //{
        //    if (HdwOptionParam.Opzioni.Count > 0)
        //    {
        //        m_Type = HDWOPTIONTYPES.COMBO;
        //        foreach (var Value in HdwOptionParam.Opzioni)
        //            m_ValueList.Add(new AGBOptionParameter(Value.Valore, Value.DescrizioneOpzione));
        //    }
        //    else
        //        m_Type = HDWOPTIONTYPES.TEXT;
        //    m_sName = HdwOptionParam.NomeParametro;
        //    m_sDescription = HdwOptionParam.DescrizioneParametro;
        //    m_sValue = m_ValueList.FirstOrDefault(x => x.sValue == HdwOptionParam.ValoreCorrente);
        //    m_OptVisibility = Visibility.Visible; // If(HdwOptionParam.Visible.ToLower = "true", Visibility.Visible, Visibility.Collapsed)
        //}
    }

    public class AGBOptionParameter
    {
        private string m_sValue;
        public string sValue
        {
            get
            {
                return m_sValue;
            }
        }

        private string m_sDescription;
        public string sDescription
        {
            get
            {
                return m_sDescription;
            }
        }

        public AGBOptionParameter(string sValue, string sDescription)
        {
            m_sValue = sValue;
            m_sDescription = sDescription;
        }
    }

    public class FrameDimension
    {
        protected Frame m_ParentFrame;
        public Frame ParentFrame
        {
            get
            {
                return m_ParentFrame;
            }
        }

        private bool m_bIsLen = false;

        private int m_nIndex;
        public int nIndex
        {
            get
            {
                return m_nIndex;
            }
        }

        private string m_sName;
        public string sName
        {
            get
            {
                return m_sName;
            }
        }

        private double m_dValue;
        public double dValue
        {
            get
            {
                return m_dValue;
            }
            set
            {
                m_dValue = value;
                m_ParentFrame.ParentWindow.OnUpdatePreview(m_ParentFrame.ParentWindow.sSerialized());
            }
        }

        public FrameDimension(Frame ParentFrame, int nIndex, string sName, double dValue, bool bIsLen)
        {
            m_ParentFrame = ParentFrame;
            m_nIndex = nIndex;
            m_sName = sName;
            m_dValue = dValue;
            m_bIsLen = bIsLen;
        }

        internal JsonFrameDimension Serialize()
        {
            JsonFrameDimension JsonFrameDimension = new JsonFrameDimension(m_nIndex, m_sName, m_dValue);
            return JsonFrameDimension;
        }
    }

    public class SashDimension
    {
        // reference
        private Sash m_Parent;

        private bool m_bIsRelative = false;
        public bool bIsRelative
        {
            get
            {
                return m_bIsRelative;
            }
        }

        private List<IdNameStruct> m_OpeningTypeList = new List<IdNameStruct>
        {
            new IdNameStruct((int)Openings.TURNONLY_LEFT, ">"),
            new IdNameStruct((int)Openings.TURNONLY_RIGHT, "<"),
            new IdNameStruct((int)Openings.TILTTURN_LEFT, ">*"),
            new IdNameStruct((int)Openings.TILTTURN_RIGHT, "<*"),
            new IdNameStruct((int)Openings.TILTONLY_TOP, "˄"),
            new IdNameStruct((int)Openings.TILTONLY_BOTTOM, "˅"),
            new IdNameStruct((int)Openings.PIVOT, "◊"),
            new IdNameStruct((int)Openings.FIXED, "X"),
            new IdNameStruct((int)Openings.COMPLANARSLIDE_LEFT, "-→"),
            new IdNameStruct((int)Openings.COMPLANARSLIDE_RIGHT, "←-"),
            new IdNameStruct((int)Openings.LIFTSLIDE_LEFT, "┌→"),
            new IdNameStruct((int)Openings.LIFTSLIDE_RIGHT, "←┐")
        };
        public List<IdNameStruct> OpeningTypeList
        {
            get
            {
                return m_OpeningTypeList;
            }
        }

        private Openings m_SelOpeningType;
        public Openings SelOpeningType
        {
            get
            {
                return m_SelOpeningType;
            }
            set
            {
                m_SelOpeningType = value;
                //m_Parent.RefreshHardwareList();
                m_Parent.RefreshHardwareOptionList();
                //m_Parent.SetFirstHardware();
            }
        }

        public Openings OpeningType
        {
            get
            {
                return (Openings)m_SelOpeningType;
            }
        }
        internal void SetOpeningType(Openings value)
        {
            m_SelOpeningType = value;
        }
        public int SelOpeningTypeIndex
        {
            get
            {
                return IdNameStruct.IndFromId((int)m_SelOpeningType, m_OpeningTypeList);
            }
            set
            {
                m_SelOpeningType = (Openings)IdNameStruct.IdFromInd(value, m_OpeningTypeList);
                m_Parent.ParentWindow.OnUpdatePreview(m_Parent.ParentWindow.sSerialized());
            }
        }

        private bool m_bHasHandle;
        public bool bHasHandle
        {
            get
            {
                return m_bHasHandle;
            }
            set
            {
                m_bHasHandle = value;
                m_Parent.ParentWindow.OnUpdatePreview(m_Parent.ParentWindow.sSerialized());
            }
        }
        internal void SetHasHandle(bool value)
        {
            m_bHasHandle = value;
        }

        private double m_dDimension;
        public double dDimension
        {
            get
            {
                return m_dDimension;
            }
            set
            {
                // se sono in percentuale
                if (m_bIsRelative)
                {
                    // verifico se ci sono assoluti
                    List<SashDimension> RelativeDimList = m_Parent.SashList.Where(x => x.bIsRelative).ToList();
                    if (RelativeDimList.Count > 0)
                    {
                        if (m_Parent.bIsPercentage)
                        {
                            int nIndex = RelativeDimList.IndexOf(this);
                            if (value < m_dDimension)
                            {
                                if (nIndex < RelativeDimList.Count - 1)
                                    RelativeDimList[nIndex + 1].SetDimension(RelativeDimList[nIndex + 1].dDimension + (m_dDimension - value));
                                else if (RelativeDimList.Count > 1)
                                    RelativeDimList[nIndex - 1].SetDimension(RelativeDimList[nIndex - 1].dDimension + (m_dDimension - value));
                                else
                                {
                                    m_dDimension = 100;
                                    return;
                                }
                            }
                            else
                            {
                                double dRes = value;
                                if (nIndex < RelativeDimList.Count - 1)
                                {
                                    for (var nInd = 0; nInd <= nIndex - 1; nInd++)
                                        dRes += RelativeDimList[nInd].dDimension;
                                    dRes = (100 - dRes) / (RelativeDimList.Count - nIndex - 1);
                                    for (var Ind = nIndex + 1; Ind <= RelativeDimList.Count - 1; Ind++)
                                        RelativeDimList[Ind].SetDimension(dRes);
                                }
                                else if (RelativeDimList.Count > 1)
                                {
                                    for (var Ind = nIndex + 1; Ind <= RelativeDimList.Count - 1; Ind++)
                                        dRes += RelativeDimList[Ind].dDimension;
                                    dRes = (100 - dRes) / (nIndex - 1);
                                    for (var nInd = 0; nInd <= nIndex - 1; nInd++)
                                        RelativeDimList[nInd].SetDimension(dRes);
                                }
                                else
                                {
                                    m_dDimension = 100;
                                    return;
                                }
                            }
                        }
                        else
                        {
                        }
                    }
                }
                m_dDimension = value;
                m_Parent.ParentWindow.OnUpdatePreview(m_Parent.ParentWindow.sSerialized());
            }
        }
        internal void SetDimension(double dValue)
        {
            m_dDimension = dValue;
        }

        public SashDimension(double dDimension, bool bIsRelative, Sash Parent)
        {
            m_dDimension = dDimension;
            m_bIsRelative = bIsRelative;
            m_Parent = Parent;
            // assengno maniglia
            if (Parent.SashList.Count == 0 || !Parent.SashList.Any(x => x.bHasHandle))
                m_bHasHandle = true;
            // assegno tipo di anta
            if (Parent.SashList.Count == 0)
                SetOpeningType(Openings.TILTTURN_LEFT);
            else if (Parent.SashList.Count == 1)
            {
                switch (Parent.SashList[0].OpeningType)
                {
                    case Openings.TURNONLY_LEFT:
                        {
                            SetOpeningType(Openings.TURNONLY_RIGHT);
                            break;
                        }

                    case Openings.TURNONLY_RIGHT:
                        {
                            SetOpeningType(Openings.TURNONLY_LEFT);
                            break;
                        }

                    case Openings.TILTTURN_LEFT:
                        {
                            SetOpeningType(Openings.TILTTURN_RIGHT);
                            break;
                        }

                    case Openings.TILTTURN_RIGHT:
                        {
                            SetOpeningType(Openings.TILTTURN_LEFT);
                            break;
                        }

                    case Openings.TILTONLY_TOP:
                        {
                            SetOpeningType(Openings.TILTONLY_BOTTOM);
                            break;
                        }

                    case Openings.TILTONLY_BOTTOM:
                        {
                            SetOpeningType(Openings.TILTONLY_TOP);
                            break;
                        }

                    case Openings.COMPLANARSLIDE_LEFT:
                        {
                            SetOpeningType(Openings.COMPLANARSLIDE_RIGHT);
                            break;
                        }

                    case Openings.COMPLANARSLIDE_RIGHT:
                        {
                            SetOpeningType(Openings.COMPLANARSLIDE_LEFT);
                            break;
                        }

                    case Openings.LIFTSLIDE_LEFT:
                        {
                            SetOpeningType(Openings.LIFTSLIDE_RIGHT);
                            break;
                        }

                    case Openings.LIFTSLIDE_RIGHT:
                        {
                            SetOpeningType(Openings.LIFTSLIDE_LEFT);
                            break;
                        }
                }
            }
            else
                SetOpeningType(Parent.SashList[Parent.SashList.Count - 1].OpeningType);
        }

        internal JsonSashDimension Serialize()
        {
            JsonSashDimension JsonSashDimension = new JsonSashDimension(OpeningType, m_bHasHandle, m_dDimension);
            return JsonSashDimension;
        }
    }

    public class SplitDimension
    {
        // reference
        private Split m_Parent;

        private bool m_bIsRelative = false;
        public bool bIsRelative
        {
            get
            {
                return m_bIsRelative;
            }
        }
        internal void SetIsRelative(bool value)
        {
            m_bIsRelative = value;
        }

        private double m_dDimension;
        public double dDimension
        {
            get
            {
                return m_dDimension;
            }
            set
            {
                // se sono in percentuale
                if (m_bIsRelative)
                {
                    // verifico se ci sono assoluti
                    List<SplitDimension> RelativeDimList = m_Parent.SplitPositionList.Where(x => x.bIsRelative).ToList();
                    if (RelativeDimList.Count > 0)
                    {
                        if (m_Parent.bIsPercentage)
                        {
                            int nIndex = RelativeDimList.IndexOf(this);
                            if (value < m_dDimension)
                            {
                                if (nIndex < RelativeDimList.Count - 1)
                                    RelativeDimList[nIndex + 1].SetDimension(RelativeDimList[nIndex + 1].dDimension + (m_dDimension - value));
                                else if (RelativeDimList.Count > 1)
                                    RelativeDimList[nIndex - 1].SetDimension(RelativeDimList[nIndex - 1].dDimension + (m_dDimension - value));
                                else
                                {
                                    m_dDimension = 100;
                                    return;
                                }
                            }
                            else
                            {
                                double dRes = value;
                                if (nIndex < RelativeDimList.Count - 1)
                                {
                                    for (var nInd = 0; nInd <= nIndex - 1; nInd++)
                                        dRes += RelativeDimList[nInd].dDimension;
                                    dRes = (100 - dRes) / (RelativeDimList.Count - nIndex - 1);
                                    for (var Ind = nIndex + 1; Ind <= RelativeDimList.Count - 1; Ind++)
                                        RelativeDimList[Ind].SetDimension(dRes);
                                }
                                else if (RelativeDimList.Count > 1)
                                {
                                    for (var Ind = nIndex + 1; Ind <= RelativeDimList.Count - 1; Ind++)
                                        dRes += RelativeDimList[Ind].dDimension;
                                    dRes = (100 - dRes) / (nIndex - 1);
                                    for (var nInd = 0; nInd <= nIndex - 1; nInd++)
                                        RelativeDimList[nInd].SetDimension(dRes);
                                }
                                else
                                {
                                    m_dDimension = 100;
                                    return;
                                }
                            }
                        }
                        else
                        {
                        }
                    }
                }
                m_dDimension = value;
                m_Parent.ParentWindow.OnUpdatePreview(m_Parent.ParentWindow.sSerialized());
            }
        }
        internal void SetDimension(double dValue)
        {
            m_dDimension = dValue;
        }

        public SplitDimension(double dDimension, bool bIsRelative, Split Parent)
        {
            m_dDimension = dDimension;
            m_bIsRelative = bIsRelative;
            m_Parent = Parent;
        }

        internal JsonSplitDimension Serialize()
        {
            JsonSplitDimension JsonSplitDimension = new JsonSplitDimension(m_bIsRelative, m_dDimension);
            return JsonSplitDimension;
        }
    }


    public struct IdNameStruct
    {
        private int m_Id;

        private string m_Name;

        public int Id
        {
            get
            {
                return m_Id;
            }
            set
            {
                m_Id = value;
            }
        }

        public string Name
        {
            get
            {
                return m_Name;
            }
            set
            {
                m_Name = value;
            }
        }

        public IdNameStruct(int Id, string Name)
        {
            this = default(IdNameStruct);
            m_Id = Id;
            m_Name = Name;
        }

        public override string ToString()
        {
            return Name;
        }

        public static int IndFromId(int Id, ObservableCollection<IdNameStruct> List)
        {
            checked
            {
                int num = List.Count - 1;
                for (int i = 0; i <= num; i++)
                {
                    if (List[i].Id == Id)
                    {
                        return i;
                    }
                }

                return 0;
            }
        }

        public static int IndFromId(int Id, List<IdNameStruct> List)
        {
            checked
            {
                int num = List.Count - 1;
                for (int i = 0; i <= num; i++)
                {
                    if (List[i].Id == Id)
                    {
                        return i;
                    }
                }

                return 0;
            }
        }

        public static int IdFromInd(int Ind, ObservableCollection<IdNameStruct> List)
        {
            return List[Ind].Id;
        }

        public static int IdFromInd(int Ind, List<IdNameStruct> List)
        {
            return List[Ind].Id;
        }

        public static int IndFromId(int Id, ObservableCollection<object> List)
        {
            checked
            {
                int num = List.Count - 1;
                for (int i = 0; i <= num; i++)
                {
                    if (List[i] is IdNameStruct && ((IdNameStruct)List[i]).Id == Id)
                    {
                        return i;
                    }
                }

                return 0;
            }
        }

        public static int IndFromId(int Id, List<object> List)
        {
            checked
            {
                int num = List.Count - 1;
                for (int i = 0; i <= num; i++)
                {
                    if (List[i] is IdNameStruct && ((IdNameStruct)List[i]).Id == Id)
                    {
                        return i;
                    }
                }

                return 0;
            }
        }

        public static int IdFromInd(int Ind, ObservableCollection<object> List)
        {
            if (List[Ind] is IdNameStruct)
            {
                return ((IdNameStruct)List[Ind]).Id;
            }

            return 0;
        }

        public static int IdFromInd(int Ind, List<object> List)
        {
            if (List[Ind] is IdNameStruct)
            {
                return ((IdNameStruct)List[Ind]).Id;
            }

            return 0;
        }

        //public static int IdFromName(string Name, ObservableCollection<object> List)
        //{
        //    checked
        //    {
        //        int num = List.Count - 1;
        //        for (int i = 0; i <= num; i++)
        //        {
        //            if (Operators.CompareString(((IdNameStruct)List[i]).Name, Name, TextCompare: false) == 0)
        //            {
        //                return ((IdNameStruct)List[i]).Id;
        //            }
        //        }

        //        return 0;
        //    }
        //}

        //public static int IdFromName(string Name, List<object> List)
        //{
        //    checked
        //    {
        //        int num = List.Count - 1;
        //        for (int i = 0; i <= num; i++)
        //        {
        //            if (Operators.CompareString(((IdNameStruct)List[i]).Name, Name, TextCompare: false) == 0)
        //            {
        //                return ((IdNameStruct)List[i]).Id;
        //            }
        //        }

        //        return 0;
        //    }
        //}
    }

}