using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Runtime.Intrinsics.Arm;
using System.Xml.Serialization;
using WebWindowConfigurator.Json;
using static WebWindowConfigurator.Json.WindowConst;

namespace WebWindowConfigurator
{
    public class FrameDimension
    {
        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;
            }
        }

        public FrameDimension(int nIndex, string sName, double dValue, bool bIsLen)
        {
            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 Window
    {
        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;
        }
    }

    public abstract class Area
    {
        protected int m_nAreaId = -1;
        public int nAreaId
        {
            get
            {
                return m_nAreaId;
            }
            set
            {
                m_nAreaId = value;
            }
        }

        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)
        {
            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;
        }
    }

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

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

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

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

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

                case Shapes.TRIANGLE:
                    {
                        DimensionList.Add(new FrameDimension(1, "Width", 2000, true));
                        DimensionList.Add(new FrameDimension(2, "Height", 1500, true));
                        DimensionList.Add(new FrameDimension(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(1, Joints.FULL_H));
                        JointList.Add(new Joint(2, Joints.FULL_H));
                        JointList.Add(new Joint(3, Joints.FULL_H));
                        JointList.Add(new Joint(4, Joints.FULL_H));
                        break;
                    }

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

                case Shapes.TRIANGLE:
                    {
                        JointList.Add(new Joint(1, Joints.FULL_H));
                        JointList.Add(new Joint(2, Joints.FULL_H));
                        JointList.Add(new Joint(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;
        }
    }
    internal void SetBottomRail(bool bBottomRail)
    {
        m_bBottomRail = bBottomRail;
    }

    private int m_nBottomRailQty = 0;
    public int BottomRailQty
    {
        get
        {
            return m_nBottomRailQty;
        }
        set
        {
            m_nBottomRailQty = value;
        }
    }
    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) : base(ParentArea)
    {
    }

    internal static Area CreateFrame(Window Window)
    {
        Frame NewFrame = new Frame(null/* TODO Change to default(_) if this is not a reference type */);
        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;
    }
}

//    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;
//                    ;/* Cannot convert ExpressionStatementSyntax, System.ArgumentOutOfRangeException: Index was out of range. Must be non-negative and less than the size of the collection. (Parameter 'index')
//   at ICSharpCode.CodeConverter.CSharp.VisualBasicConverter.NodesVisitor.VisitSimpleArgument(SimpleArgumentSyntax node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/NodesVisitor.cs:line 1069
//   at Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxVisitor`1.Visit(SyntaxNode node)
//   at ICSharpCode.CodeConverter.CSharp.CommentConvertingNodesVisitor.DefaultVisit(SyntaxNode node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/CommentConvertingNodesVisitor.cs:line 28
//   at ICSharpCode.CodeConverter.CSharp.VisualBasicConverter.NodesVisitor.<>c__DisplayClass83_0.<ConvertArguments>b__0(ArgumentSyntax a, Int32 i) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/NodesVisitor.cs:line 1045
//   at System.Linq.Enumerable.SelectIterator[TSource,TResult](IEnumerable`1 source, Func`3 selector)+MoveNext()
//   at System.Linq.Enumerable.WhereEnumerableIterator`1.MoveNext()
//   at Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList[TNode](IEnumerable`1 nodes)
//   at ICSharpCode.CodeConverter.CSharp.VisualBasicConverter.NodesVisitor.VisitArgumentList(ArgumentListSyntax node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/NodesVisitor.cs:line 1022
//   at Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxVisitor`1.Visit(SyntaxNode node)
//   at ICSharpCode.CodeConverter.CSharp.CommentConvertingNodesVisitor.DefaultVisit(SyntaxNode node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/CommentConvertingNodesVisitor.cs:line 28
//   at ICSharpCode.CodeConverter.CSharp.VisualBasicConverter.NodesVisitor.VisitInvocationExpression(InvocationExpressionSyntax node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/NodesVisitor.cs:line 1422
//   at Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxVisitor`1.Visit(SyntaxNode node)
//   at ICSharpCode.CodeConverter.CSharp.CommentConvertingNodesVisitor.DefaultVisit(SyntaxNode node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/CommentConvertingNodesVisitor.cs:line 28
//   at ICSharpCode.CodeConverter.CSharp.VisualBasicConverter.NodesVisitor.VisitMemberAccessExpression(MemberAccessExpressionSyntax node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/NodesVisitor.cs:line 977
//   at Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxVisitor`1.Visit(SyntaxNode node)
//   at ICSharpCode.CodeConverter.CSharp.CommentConvertingNodesVisitor.DefaultVisit(SyntaxNode node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/CommentConvertingNodesVisitor.cs:line 28
//   at ICSharpCode.CodeConverter.CSharp.VisualBasicConverter.NodesVisitor.VisitInvocationExpression(InvocationExpressionSyntax node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/NodesVisitor.cs:line 1431
//   at Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxVisitor`1.Visit(SyntaxNode node)
//   at ICSharpCode.CodeConverter.CSharp.CommentConvertingNodesVisitor.DefaultVisit(SyntaxNode node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/CommentConvertingNodesVisitor.cs:line 28
//   at ICSharpCode.CodeConverter.CSharp.VisualBasicConverter.MethodBodyVisitor.VisitExpressionStatement(ExpressionStatementSyntax node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/MethodBodyVisitor.cs:line 97
//   at Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxVisitor`1.Visit(SyntaxNode node)
//   at ICSharpCode.CodeConverter.CSharp.CommentConvertingMethodBodyVisitor.DefaultVisit(SyntaxNode node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/CommentConvertingMethodBodyVisitor.cs:line 27

//Input: 
//            SashList(SashList.Count - 1).SetDimension(dLastDimension)

// */
//                }
//                RefreshHardwareList();
//                RefreshHardwareOptionList();
//                SetFirstHardware();
//            }
//        }
//        internal void SetSashQty(int Qty, bool NotifyProperty = false)
//        {
//            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);
//            }
//            if (NotifyProperty)
//                NotifyPropertyChanged(nameof(nSashQty));
//        }

//        private bool m_bIsSashVertical;
//        public bool bIsSashVertical
//        {
//            get
//            {
//                return m_bIsSashVertical;
//            }
//            set
//            {
//                m_bIsSashVertical = value;
//            }
//        }
//        internal void SetIsSashVertical(bool IsSashVertical, bool NotifyProperty = false)
//        {
//            m_bIsSashVertical = IsSashVertical;
//            if (NotifyProperty)
//                NotifyPropertyChanged(nameof(bIsSashVertical));
//        }

//        private bool m_bIsMeasureGlass;
//        public bool bIsMeasureGlass
//        {
//            get
//            {
//                return m_bIsMeasureGlass;
//            }
//            set
//            {
//                m_bIsMeasureGlass = value;
//            }
//        }
//        internal void SetIsMeasureGlass(bool IsMeasureGlass, bool NotifyProperty = false)
//        {
//            m_bIsMeasureGlass = IsMeasureGlass;
//            if (NotifyProperty)
//                NotifyPropertyChanged(nameof(bIsMeasureGlass));
//        }

//        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_bBottomRail;
//        public bool BottomRail
//        {
//            get
//            {
//                return m_bBottomRail;
//            }
//            set
//            {
//                m_bBottomRail = value;
//            }
//        }
//        internal void SetBottomRail(bool bBottomRail)
//        {
//            m_bBottomRail = bBottomRail;
//        }

//        private int m_nBottomRailQty = 0;
//        public int BottomRailQty
//        {
//            get
//            {
//                return m_nBottomRailQty;
//            }
//            set
//            {
//                m_nBottomRailQty = value;
//            }
//        }
//        internal void SetBottomRailQty(int nBottomRailQty)
//        {
//            m_nBottomRailQty = 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 (!IsNothing(m_SelHardware) && 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;
//            NotifyPropertyChanged(nameof(SelHardware));
//        }
//        internal void SetSelHardwareFromId(string sId)
//        {
//            m_SelHardware = m_HardwareList.FirstOrDefault(x => x.sId == sId);
//            if (IsNothing(m_SelHardware))
//                m_SelHardware = m_HardwareList(0);
//            NotifyPropertyChanged(nameof(SelHardware));
//        }
//        internal void SetFirstHardware()
//        {
//            if (m_HardwareList.Count > 0)
//            {
//                m_SelHardware = m_HardwareList(0);
//                NotifyPropertyChanged(nameof(SelHardware));
//            }
//        }

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

//        public Sash(Area ParentArea) : base(ParentArea)
//        {
//        }

//        internal static Sash CreateSash(Area Area)
//        {
//            Sash NewSash = new Sash(Area);
//            NewSash.SetAreaType(AreaTypes.SASH);
//            NewSash.SetSashQty(1);
//            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.SetBottomRail(false);
//            NewSash.SetBottomRailQty(0);
//            NewSash.RefreshHardwareList();
//            NewSash.RefreshHardwareOptionList();
//            NewSash.SetFirstHardware();
//            return NewSash;
//        }

//        private string FindSashShape()
//        {
//            // Return "R"
//            // se non ancora creato, recupero area precedente
//            int nAreaId = m_nAreaId;
//            if (m_nAreaId == GDB_ID.NULL)
//                nAreaId = ParentArea.nAreaId;
//            int nOutlineLayerId = EgtGetFirstNameInGroup(nAreaId, WIN_OUTLINE);
//            List<int> OutlineIdList = new List<int>();
//            int nOutlineId = EgtGetFirstInGroup(nOutlineLayerId);
//            while (nOutlineId != GDB_ID.NULL)
//            {
//                OutlineIdList.Add(nOutlineId);
//                nOutlineId = EgtGetNext(nOutlineId);
//            }
//            int nTempLayerId = EgtCreateGroup(nAreaId);
//            int nCompoOutlineId = EgtCreateCurveCompo(nTempLayerId, OutlineIdList.ToArray(), false);
//            Point3d ptP;
//            Vector3d vtL1;
//            Vector3d vtL2;
//            Vector3d vtB1;
//            Vector3d vtB2;
//            Vector3d vtN;
//            double dRad;
//            bool bCCW;
//            if (EgtCurveIsARectangle(nCompoOutlineId, 0.001, ptP, vtL1, vtL2))
//                return "R";
//            else if (EgtCurveIsACircle(nCompoOutlineId, ptP, vtN, dRad, bCCW))
//                return "C";
//            else if (EgtCurveIsATrapezoid(nCompoOutlineId, ptP, vtB1, vtL1, vtB2))
//                return "T";
//            else
//                for (var nOutlineIndex = 0; nOutlineIndex <= OutlineIdList.Count - 1; nOutlineIndex++)
//                {
//                    if (EgtGetType(OutlineIdList[nOutlineIndex]) == GDB_TY.CRV_ARC)
//                    {
//                        Vector3d vtStart;
//                        EgtStartVector(OutlineIdList[nOutlineIndex], GDB_ID.ROOT, vtStart);
//                        Vector3d vtEnd;
//                        EgtEndVector(OutlineIdList[nOutlineIndex], GDB_ID.ROOT, vtEnd);
//                        int nPrevOutlineId = nOutlineId > 0 ? OutlineIdList[nOutlineIndex - 1] : OutlineIdList[OutlineIdList.Count - 1];
//                        int dPrevLen;
//                        EgtCurveLength(nPrevOutlineId, dPrevLen);
//                        Vector3d vtPrev;
//                        EgtStartVector(nPrevOutlineId, vtPrev);
//                        int nNextOutlineId = nOutlineId < OutlineIdList.Count - 1 ? OutlineIdList[nOutlineIndex + 1] : OutlineIdList[0];
//                        int dNextLen;
//                        EgtCurveLength(nNextOutlineId, dNextLen);
//                        Vector3d vtNext;
//                        EgtEndVector(nNextOutlineId, vtNext);
//                        if (Math.Abs(dPrevLen - dNextLen) < 10 * EPS_SMALL)
//                        {
//                            if (AreSameVectorApprox(vtEnd, vtNext))
//                                return "AS";
//                            else
//                                return "AR";
//                        }
//                        else if (AreSameVectorApprox(vtEnd, vtNext))
//                            return "SS";
//                        else
//                            return "SR";
//                    }
//                }
//            return "R";
//        }

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

//                case object _ when Openings.TILTTURN_LEFT:
//                case object _ when Openings.TILTTURN_RIGHT:
//                    {
//                        return OpeningTypes.TILTTURN;
//                    }

//                case object _ when Openings.TILTONLY_TOP:
//                case object _ when Openings.TILTONLY_BOTTOM:
//                    {
//                        return OpeningTypes.TILTONLY;
//                    }

//                case object _ when Openings.PIVOT:
//                    {
//                        return OpeningTypes.PIVOT;
//                    }

//                case object _ when Openings.FIXED:
//                    {
//                        return OpeningTypes.FIXED;
//                    }

//                case object _ when Openings.COMPLANARSLIDE_LEFT:
//                case object _ when Openings.COMPLANARSLIDE_RIGHT:
//                    {
//                        return OpeningTypes.COMPLANARSLIDE;
//                    }

//                case object _ when Openings.LIFTSLIDE_LEFT:
//                case object _ when Openings.LIFTSLIDE_RIGHT:
//                    {
//                        return OpeningTypes.LIFTSLIDE;
//                    }

//                default:
//                    {
//                        return OpeningTypes.NULL;
//                    }
//            }
//        }

//        private void ConvertOpeningType()
//        {
//            if (m_SashList.Any(x => GetOpeningType(x.OpeningType) == OpeningTypes.TILTTURN))
//                return "AR";
//            else
//                switch (GetOpeningType(m_SashList(0).OpeningType))
//                {
//                    case object _ when OpeningTypes.TURNONLY:
//                        {
//                            return "AB";
//                        }

//                    case object _ when OpeningTypes.TILTONLY:
//                        {
//                            return "VA";
//                        }

//                    case object _ when OpeningTypes.PIVOT:
//                        {
//                            return "BI";
//                        }

//                    case object _ when OpeningTypes.COMPLANARSLIDE:
//                        {
//                            return "CO";
//                        }

//                    case object _ when 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);
//            NotifyPropertyChanged(nameof(HardwareList));
//        }

//        internal void RefreshHardwareOptionList()
//        {
//            m_HwdOptionList.Clear();
//            NotifyPropertyChanged(nameof(HwdOptionList));
//        }

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

//                case object _ when Openings.TURNONLY_RIGHT:
//                case object _ when Openings.TILTTURN_RIGHT:
//                case object _ when Openings.TILTONLY_BOTTOM:
//                case object _ when Openings.COMPLANARSLIDE_RIGHT:
//                case object _ when Openings.LIFTSLIDE_RIGHT:
//                    {
//                        return OpeningSides.RIGHT;
//                    }

//                default:
//                    {
//                        return OpeningSides.NULL;
//                    }
//            }
//        }

//        internal override bool DrawArea(Area Area, int nAreaId)
//        {
//            // verifico se applicata
//            if (!bApplied)
//                return true;
//            // verifico che esista area sash con info corrette
//            if (IsNothing(m_JointList) || m_JointList.Count < 3 || IsNothing(m_SashType))
//                return false;
//            // se un'anta
//            if (nSashQty == 1)
//            {
//                // creo anta
//                var tf = EgtLuaSetGlobIntVar("WDG.AREAID", nAreaId);
//                var tg = EgtLuaSetGlobIntVar("WDG.JOINTBL", m_JointList(0).SelJointType);
//                var th = EgtLuaSetGlobIntVar("WDG.JOINTBR", m_JointList(1).SelJointType);
//                var tj = EgtLuaSetGlobIntVar("WDG.JOINTTR", m_JointList(2).SelJointType);
//                var tkt = EgtLuaSetGlobIntVar("WDG.JOINTTL", m_JointList(3).SelJointType);
//                var tft = EgtLuaSetGlobIntVar("WDG.SASHTYPE", m_SashType);
//                var tfr = EgtLuaSetGlobIntVar("WDG.OPENINGTYPE", m_SashList(0).SelOpeningType.Id);
//                var tlt = EgtLuaCallFunction("WinCreate_AddSash");
//                var tltf = EgtLuaGetGlobIntVar("WDG.AREAID", m_nAreaId);
//                nAreaId = m_nAreaId;
//                if (m_nAreaId == GDB_ID.NULL)
//                    return false;
//                // aggiungo BottomRail se necessario
//                if (m_bBottomRail)
//                {
//                    EgtLuaSetGlobIntVar("WDG.NBR", m_nBottomRailQty);
//                    var tdlt = EgtLuaCallFunction("WinCreate_AddBottomRail");
//                }
//            }
//            else
//            {
//                // se piu' di un'anta
//                // creo split
//                EgtLuaSetGlobIntVar("WDG.AREAID", nAreaId);
//                EgtLuaSetGlobIntVar("WDG.SPLITORIENTATION", m_bIsSashVertical ? SplitShapes.VERTICAL : SplitShapes.HORIZONTAL);
//                EgtLuaSetGlobIntVar("WDG.SPLITTYPE", LuaSplitTypes.FRENCH);
//                EgtLuaSetGlobIntVar("WDG.MEASURETYPE", 3);
//                for (var PositionIndex = 0; PositionIndex <= SashList.Count - 2; PositionIndex++)
//                    ;/* Cannot convert ExpressionStatementSyntax, System.ArgumentOutOfRangeException: Index was out of range. Must be non-negative and less than the size of the collection. (Parameter 'index')
//   at ICSharpCode.CodeConverter.CSharp.VisualBasicConverter.NodesVisitor.VisitSimpleArgument(SimpleArgumentSyntax node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/NodesVisitor.cs:line 1069
//   at Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxVisitor`1.Visit(SyntaxNode node)
//   at ICSharpCode.CodeConverter.CSharp.CommentConvertingNodesVisitor.DefaultVisit(SyntaxNode node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/CommentConvertingNodesVisitor.cs:line 28
//   at ICSharpCode.CodeConverter.CSharp.VisualBasicConverter.NodesVisitor.<>c__DisplayClass83_0.<ConvertArguments>b__0(ArgumentSyntax a, Int32 i) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/NodesVisitor.cs:line 1045
//   at System.Linq.Enumerable.SelectIterator[TSource,TResult](IEnumerable`1 source, Func`3 selector)+MoveNext()
//   at System.Linq.Enumerable.WhereEnumerableIterator`1.MoveNext()
//   at Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList[TNode](IEnumerable`1 nodes)
//   at ICSharpCode.CodeConverter.CSharp.VisualBasicConverter.NodesVisitor.VisitArgumentList(ArgumentListSyntax node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/NodesVisitor.cs:line 1022
//   at Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxVisitor`1.Visit(SyntaxNode node)
//   at ICSharpCode.CodeConverter.CSharp.CommentConvertingNodesVisitor.DefaultVisit(SyntaxNode node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/CommentConvertingNodesVisitor.cs:line 28
//   at ICSharpCode.CodeConverter.CSharp.VisualBasicConverter.NodesVisitor.VisitInvocationExpression(InvocationExpressionSyntax node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/NodesVisitor.cs:line 1422
//   at Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxVisitor`1.Visit(SyntaxNode node)
//   at ICSharpCode.CodeConverter.CSharp.CommentConvertingNodesVisitor.DefaultVisit(SyntaxNode node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/CommentConvertingNodesVisitor.cs:line 28
//   at ICSharpCode.CodeConverter.CSharp.VisualBasicConverter.NodesVisitor.VisitMemberAccessExpression(MemberAccessExpressionSyntax node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/NodesVisitor.cs:line 977
//   at Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxVisitor`1.Visit(SyntaxNode node)
//   at ICSharpCode.CodeConverter.CSharp.CommentConvertingNodesVisitor.DefaultVisit(SyntaxNode node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/CommentConvertingNodesVisitor.cs:line 28
//   at ICSharpCode.CodeConverter.CSharp.VisualBasicConverter.NodesVisitor.VisitBinaryExpression(BinaryExpressionSyntax node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/NodesVisitor.cs:line 1398
//   at Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxVisitor`1.Visit(SyntaxNode node)
//   at ICSharpCode.CodeConverter.CSharp.CommentConvertingNodesVisitor.DefaultVisit(SyntaxNode node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/CommentConvertingNodesVisitor.cs:line 28
//   at ICSharpCode.CodeConverter.CSharp.VisualBasicConverter.NodesVisitor.VisitTernaryConditionalExpression(TernaryConditionalExpressionSyntax node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/NodesVisitor.cs:line 1339
//   at Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxVisitor`1.Visit(SyntaxNode node)
//   at ICSharpCode.CodeConverter.CSharp.CommentConvertingNodesVisitor.DefaultVisit(SyntaxNode node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/CommentConvertingNodesVisitor.cs:line 28
//   at ICSharpCode.CodeConverter.CSharp.VisualBasicConverter.NodesVisitor.VisitSimpleArgument(SimpleArgumentSyntax node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/NodesVisitor.cs:line 1060
//   at Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxVisitor`1.Visit(SyntaxNode node)
//   at ICSharpCode.CodeConverter.CSharp.CommentConvertingNodesVisitor.DefaultVisit(SyntaxNode node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/CommentConvertingNodesVisitor.cs:line 28
//   at ICSharpCode.CodeConverter.CSharp.VisualBasicConverter.NodesVisitor.<>c__DisplayClass83_0.<ConvertArguments>b__0(ArgumentSyntax a, Int32 i) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/NodesVisitor.cs:line 1045
//   at System.Linq.Enumerable.SelectIterator[TSource,TResult](IEnumerable`1 source, Func`3 selector)+MoveNext()
//   at System.Linq.Enumerable.WhereEnumerableIterator`1.MoveNext()
//   at Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList[TNode](IEnumerable`1 nodes)
//   at ICSharpCode.CodeConverter.CSharp.VisualBasicConverter.NodesVisitor.VisitArgumentList(ArgumentListSyntax node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/NodesVisitor.cs:line 1022
//   at Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxVisitor`1.Visit(SyntaxNode node)
//   at ICSharpCode.CodeConverter.CSharp.CommentConvertingNodesVisitor.DefaultVisit(SyntaxNode node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/CommentConvertingNodesVisitor.cs:line 28
//   at ICSharpCode.CodeConverter.CSharp.VisualBasicConverter.NodesVisitor.VisitInvocationExpression(InvocationExpressionSyntax node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/NodesVisitor.cs:line 1422
//   at Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxVisitor`1.Visit(SyntaxNode node)
//   at ICSharpCode.CodeConverter.CSharp.CommentConvertingNodesVisitor.DefaultVisit(SyntaxNode node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/CommentConvertingNodesVisitor.cs:line 28
//   at ICSharpCode.CodeConverter.CSharp.VisualBasicConverter.MethodBodyVisitor.VisitExpressionStatement(ExpressionStatementSyntax node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/MethodBodyVisitor.cs:line 97
//   at Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxVisitor`1.Visit(SyntaxNode node)
//   at ICSharpCode.CodeConverter.CSharp.CommentConvertingMethodBodyVisitor.DefaultVisit(SyntaxNode node) in /home/runner/work/CodeConverter/CodeConverter/.temp/codeconverter/ICSharpCode.CodeConverter/CSharp/CommentConvertingMethodBodyVisitor.cs:line 27

//Input: 
//            EgtLuaSetGlobNumVar("WDG.POSITION" & PositionIndex + 1, If(m_SashList(PositionIndex).bIsRelative, SashList(PositionIndex).dDimension / 100, SashList(PositionIndex).dDimension))

// */
//                EgtLuaSetGlobNumVar("WDG.PROPORTION", SashList.Sum(x => x.dDimension / (double)100));
//                EgtLuaCallFunction("WinCreate_AddSplits");
//                int AreaIndex = 1;
//                int NewAreaId = GDB_ID.NULL;
//                while (EgtLuaGetGlobIntVar("WDG.AREAID" + AreaIndex, NewAreaId))
//                {
//                    if (NewAreaId != GDB_ID.NULL)
//                    {
//                        Area.AreaList(AreaIndex - 1).nAreaId = NewAreaId;
//                        AreaIndex += 1;
//                    }
//                    else
//                        break;
//                }
//                EgtLuaGetGlobIntVar("WDG.AREAID", Area.nAreaId);
//                // calcolo OpeningSide e OpeningType
//                int nHandleIndex = SashList.IndexOf(SashList.FirstOrDefault(x => x.bHasHandle));
//                SashTypes[] SashTypeList = new SashTypes[m_SashList.Count - 1 + 1];
//                SashTypes[] FinalSashTypeList = new SashTypes[m_SashList.Count - 1 + 1];
//                for (var nSashIndex = 0; nSashIndex <= m_SashList.Count - 1; nSashIndex++)
//                {
//                    // se active
//                    if (GetOpeningSide(m_SashList(nSashIndex).OpeningType) == GetOpeningSide(m_SashList(nHandleIndex).OpeningType))
//                        SashTypeList[nSashIndex] = SashTypes.ACTIVE;
//                    else
//                        // altrimenti inactive
//                        SashTypeList[nSashIndex] = SashTypes.INACTIVE;
//                }
//                for (nSashIndex = 0; nSashIndex <= m_SashList.Count - 1; nSashIndex++)
//                {
//                    if (nSashIndex == 0)
//                    {
//                        if (SashTypeList[nSashIndex] == SashTypeList[nSashIndex + 1])
//                        {
//                            if (SashTypeList[nSashIndex] == SashTypes.ACTIVE)
//                                FinalSashTypeList[nSashIndex] = SashTypes.ACTIVE_OUT;
//                            else
//                                FinalSashTypeList[nSashIndex] = SashTypes.INACTIVE_OUT;
//                        }
//                        else
//                            // rimane come e'
//                            FinalSashTypeList[nSashIndex] = SashTypeList[nSashIndex];
//                    }
//                    else if (nSashIndex == m_SashList.Count - 1)
//                    {
//                        if (SashTypeList[nSashIndex] == SashTypeList[nSashIndex - 1])
//                        {
//                            if (SashTypeList[nSashIndex] == SashTypes.ACTIVE)
//                                FinalSashTypeList[nSashIndex] = SashTypes.ACTIVE_OUT;
//                            else
//                                FinalSashTypeList[nSashIndex] = SashTypes.INACTIVE_OUT;
//                        }
//                        else
//                            // rimane come e'
//                            FinalSashTypeList[nSashIndex] = SashTypeList[nSashIndex];
//                    }
//                    else if (SashTypeList[nSashIndex] == SashTypeList[nSashIndex + 1] || SashTypeList[nSashIndex] == SashTypeList[nSashIndex - 1])
//                    {
//                        if (SashTypeList[nSashIndex] == SashTypes.ACTIVE)
//                            FinalSashTypeList[nSashIndex] = SashTypes.ACTIVE_IN;
//                        else
//                            FinalSashTypeList[nSashIndex] = SashTypes.INACTIVE_IN;
//                    }
//                    else
//                        // rimane come e'
//                        FinalSashTypeList[nSashIndex] = SashTypeList[nSashIndex];
//                }
//                // creo ante
//                for (nSashIndex = 0; nSashIndex <= m_SashList.Count - 1; nSashIndex++)
//                {
//                    var tf = EgtLuaSetGlobIntVar("WDG.AREAID", Area.AreaList(nSashIndex).nAreaId);
//                    var tg = EgtLuaSetGlobIntVar("WDG.JOINTBL", m_JointList(0).SelJointType);
//                    var th = EgtLuaSetGlobIntVar("WDG.JOINTBR", m_JointList(1).SelJointType);
//                    var tj = EgtLuaSetGlobIntVar("WDG.JOINTTR", m_JointList(2).SelJointType);
//                    var tkt = EgtLuaSetGlobIntVar("WDG.JOINTTL", m_JointList(3).SelJointType);
//                    var tft = EgtLuaSetGlobIntVar("WDG.SASHTYPE", FinalSashTypeList[nSashIndex]);
//                    var tfr = EgtLuaSetGlobIntVar("WDG.OPENINGTYPE", m_SashList(nSashIndex).SelOpeningType.Id);
//                    var tlt = EgtLuaCallFunction("WinCreate_AddSash");
//                    int nNewAreaId = GDB_ID.NULL;
//                    var tltf = EgtLuaGetGlobIntVar("WDG.AREAID", nNewAreaId);
//                    Area.AreaList(nSashIndex).nAreaId = nNewAreaId;
//                    if (nNewAreaId == GDB_ID.NULL)
//                        return false;
//                    // aggiungo BottomRail se necessario
//                    if (m_bBottomRail)
//                    {
//                        EgtLuaSetGlobIntVar("WDG.NBR", m_nBottomRailQty);
//                        var tdlt = EgtLuaCallFunction("WinCreate_AddBottomRail");
//                    }
//                }
//            }
//            // aggiungo ferramenta
//            if (!IsNothing(m_SelHardware))
//            {
//                EgtSetInfo(m_nAreaId, LUA_WIN_HDW_FAVOURITE, m_SelHardware.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;
//                        }
//                }
//                EgtSetInfo(m_nAreaId, LUA_WIN_HDW_HANDLE, sHandle);
//                string sOptions = "";
//                for (var OptionIndex = 0; OptionIndex <= m_HwdOptionList.Count - 1; OptionIndex++)
//                {
//                    var HdwOption = m_HwdOptionList(OptionIndex);
//                    sOptions += HdwOption.sName + "=" + HdwOption.sValue.sValue + OptionIndex < m_HwdOptionList.Count - 1 ? "," : "";
//                }
//                EgtSetInfo(m_nAreaId, LUA_WIN_HDW_OPTIONS, sOptions);
//            }
//            // lancio disegno delle sotto aree
//            foreach (var Area in AreaList)
//            {
//                if (!Area.DrawArea(Area, nAreaId))
//                    return false;
//            }
//            return true;
//        }

//        internal override bool GetSelectionArea()
//        {
//            if (nSashQty == 1)
//            {
//                int nSelLayerId = EgtGetFirstNameInGroup(m_nAreaId, WIN_SELECTION);
//                if (nSelLayerId != GDB_ID.NULL)
//                    SetSelectionGeomId(nSelLayerId);
//            }
//            else if (nSashQty > 1)
//            {
//                var nSplitIndex = 0;
//                int nArea1Id = GDB_ID.NULL;
//                int nArea2Id = GDB_ID.NULL;
//                int nSplitAreaId = m_nAreaId;
//                while (nSplitIndex < nSashQty - 1)
//                {
//                    nArea1Id = EgtGetFirstNameInGroup(nSplitAreaId, WIN_AREA + 1);
//                    nArea2Id = EgtGetFirstNameInGroup(nSplitAreaId, WIN_AREA + 2);
//                    int nSashId = EgtGetFirstNameInGroup(nArea1Id, WIN_AREA + "*");
//                    int nSashSelId = EgtGetFirstNameInGroup(nSashId, WIN_SELECTION);
//                    SelectionGeomIds(nSplitIndex) = nSashSelId;
//                    nSplitAreaId = nArea2Id;
//                    nSplitIndex += 1;
//                }
//                nArea2Id = EgtGetFirstNameInGroup(EgtGetParent(nArea1Id), WIN_AREA + 2);
//                int nSash2Id = EgtGetFirstNameInGroup(nArea2Id, WIN_AREA + "*");
//                int nSash2SelId = EgtGetFirstNameInGroup(nSash2Id, WIN_SELECTION);
//                SelectionGeomIds(nSplitIndex) = nSash2SelId;
//            }
//            // lancio recupero area di selezione delle sotto aree
//            foreach (var Area in AreaList)
//            {
//                if (!Area.GetSelectionArea())
//                    return false;
//            }
//            return true;
//        }

//        internal override JsonArea Serialize()
//        {
//            JsonSash JsonSash = new JsonSash(m_bIsSashVertical, m_SashType, 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 Joint
    {
        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);
        }
    }
    public Joints SelJointType
    {
        get
        {
            return m_SelJointType;
        }
        set
        {
            m_SelJointType = value;
        }
    }
        internal void SetSelJointType(Joints value)
    {
        m_SelJointType = value;
        //NotifyPropertyChanged(nameof(SelJointTypeIndex));
    }
    public Joint(int nIndex, Joints SelJointType)
    {
        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 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 IdNameStruct m_SelOpeningType;
//    //    public IdNameStruct SelOpeningType
//    //    {
//    //        get
//    //        {
//    //            return m_SelOpeningType;
//    //        }
//    //        set
//    //        {
//    //            m_SelOpeningType = value;
//    //            m_Parent.RefreshHardwareList();
//    //            m_Parent.RefreshHardwareOptionList();
//    //            m_Parent.SetFirstHardware();
//    //        }
//    //    }

//    //    public Openings OpeningType
//    //    {
//    //        get
//    //        {
//    //            return m_SelOpeningType.Id;
//    //        }
//    //    }
//    //internal void SetOpeningType(Openings value)
//    //{
//    //    m_SelOpeningType = m_OpeningTypeList.FirstOrDefault(x => x.Id == value);
//    //    NotifyPropertyChanged(nameof(SelOpeningType));
//    //}

//    //private bool m_bHasHandle;
//    //public bool bHasHandle
//    //{
//    //    get
//    //    {
//    //        return m_bHasHandle;
//    //    }
//    //    set
//    //    {
//    //        m_bHasHandle = value;
//    //    }
//    //}
//    //internal void SetHasHandle(bool value)
//    //{
//    //    m_bHasHandle = value;
//    //    NotifyPropertyChanged(nameof(bHasHandle));
//    //}

//    //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;
//    //    }
//    //}
//    //internal void SetDimension(double dValue)
//    //{
//    //    m_dDimension = dValue;
//    //    NotifyPropertyChanged(nameof(dDimension));
//    //}

//    //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 object _ when Openings.TURNONLY_LEFT:
//    //                {
//    //                    SetOpeningType(Openings.TURNONLY_RIGHT);
//    //                    break;
//    //                }

//    //            case object _ when Openings.TURNONLY_RIGHT:
//    //                {
//    //                    SetOpeningType(Openings.TURNONLY_LEFT);
//    //                    break;
//    //                }

//    //            case object _ when Openings.TILTTURN_LEFT:
//    //                {
//    //                    SetOpeningType(Openings.TILTTURN_RIGHT);
//    //                    break;
//    //                }

//    //            case object _ when Openings.TILTTURN_RIGHT:
//    //                {
//    //                    SetOpeningType(Openings.TILTTURN_LEFT);
//    //                    break;
//    //                }

//    //            case object _ when Openings.TILTONLY_TOP:
//    //                {
//    //                    SetOpeningType(Openings.TILTONLY_BOTTOM);
//    //                    break;
//    //                }

//    //            case object _ when Openings.TILTONLY_BOTTOM:
//    //                {
//    //                    SetOpeningType(Openings.TILTONLY_TOP);
//    //                    break;
//    //                }

//    //            case object _ when Openings.COMPLANARSLIDE_LEFT:
//    //                {
//    //                    SetOpeningType(Openings.COMPLANARSLIDE_RIGHT);
//    //                    break;
//    //                }

//    //            case object _ when Openings.COMPLANARSLIDE_RIGHT:
//    //                {
//    //                    SetOpeningType(Openings.COMPLANARSLIDE_LEFT);
//    //                    break;
//    //                }

//    //            case object _ when Openings.LIFTSLIDE_LEFT:
//    //                {
//    //                    SetOpeningType(Openings.LIFTSLIDE_RIGHT);
//    //                    break;
//    //                }

//    //            case object _ when 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 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;
    //    }
    //}
}
    
}