using Egw.Window.Data;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Data.SqlTypes;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Serialization;
using WebWindowTest.Json;
using static WebWindowTest.Json.WindowConst;

namespace WebWindowTest.Models
{
    public class Sash : Area
    {
        #region Public Fields

        // Lista hardware completa passata dal chiamante del componente
        public static List<Hardware> m_HardwareCompleteList = new List<Hardware>();

        // Lista famiglia hardware completa passata dal chiamante del componente
        public static List<string> s_FamilyHardwareList = new List<string>();

        #endregion Public Fields

        #region Public Constructors

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

        #endregion Public Constructors

        #region Public Properties

        public bool bIsSashVertical
        {
            get
            {
                return m_bIsSashVertical;
            }
            set
            {
                m_bIsSashVertical = value;
            }
        }

        //public SashArcElement? SashArcElem
        //{
        //    get
        //    {
        //        return m_SashArcElement;
        //    }
        //    set
        //    {
        //        m_SashArcElement = value!;
        //    }
        //}

        public List<Hardware> HardwareList
        {
            get
            {
                return m_HardwareList;
            }
        }

        public List<AGBOption> HwOptionList
        {
            get
            {
                return m_HwOptionList;
            }
        }

        public Dictionary<string, string> SelHwOptionList
        {
            get
            {
                return m_SelHwOptionList;
            }
        }

        public int nSashQty
        {
            get
            {
                return m_SashList.Count > 0 ? m_SashList.Count : 1;
            }
            set
            {
                if (value > 0 && value <= 3)
                {
                    double widthTot = CalculateWidthArea(ParentWindow.AreaList.First(), ParentWindow.AreaList.FirstOrDefault().DimensionList.Where(x => x.sName == "Width").First().dDimension);
                    if (value > m_SashList.Count)
                    {
                        // recupero larghezza ultimo
                        double dLastDimension = widthTot;
                        double dNewDimension = widthTot;
                        if (m_SashList.Count > 0)
                        {
                            dLastDimension = m_SashList[m_SashList.Count - 1].dDimension;
                            dNewDimension = dLastDimension / (value + 1 - nSashQty);
                            if (m_SashList[m_SashList.Count - 1].MeasureType.Equals(MeasureTypes.PROPORTIONAL))
                                dNewDimension = 1;
                            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++)
                        {
                            var addSashDim = new SashDimension(dNewDimension, m_SashList[m_SashList.Count - 1].MeasureType, this, SplitIndex + 1);
                            for(int i = 1; i <= 4; i++)
                            {
                                addSashDim.JointList.Add(new Joint(this, i, Joints.FULL_V));
                            }
                            SashList.Add(addSashDim);
                        }
                    }
                    else if (value < m_SashList.Count)
                    {
                        if (value > 0)
                        {
                            double dLastDimension = 0;
                            SashDimension itemDelete = null;
                            double deleteDim;
                            for (var SplitIndex = m_SashList.Count - 1; SplitIndex >= value; SplitIndex += -1)
                            {
                                //dLastDimension += m_SashList[SplitIndex].dDimension;
                                itemDelete = m_SashList[SplitIndex];
                                SashList.RemoveAt(SplitIndex);
                            }
                            if (!itemDelete.SelMeasureType.Equals(m_SashList[SashList.Count - 1].SelMeasureType))
                            {
                                AreaDimension ad = new AreaDimension(itemDelete.dDimension, itemDelete.SelMeasureType);
                                List<AreaDimension> adList = new List<AreaDimension>();
                                foreach (var it in SashList)
                                {
                                    adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType));
                                }
                                deleteDim = ad.ConvertDimension(adList, itemDelete.SelMeasureType, m_SashList[SashList.Count - 1].SelMeasureType, widthTot, m_SashList.IndexOf(itemDelete));
                            }
                                //deleteDim = Convert.ConvertDimension(itemDelete, itemDelete.SelMeasureType, m_SashList[SashList.Count - 1].SelMeasureType, itemDelete.dDimension, widthTot);
                            else
                                deleteDim = itemDelete.dDimension;
                            //dLastDimension += m_SashList[SashList.Count - 1].dDimension;
                            dLastDimension = deleteDim + m_SashList[SashList.Count - 1].dDimension;
                            SashList[SashList.Count - 1].SetDimension(dLastDimension);
                            if (value == 1)
                                SashList.First().SetHasHandle(true);
                        }
                        else
                        {
                            SashList.RemoveAt(0);
                        }
                    }
                    if (m_SashList.Count == 0)
                    {
                        Area child = AreaList.First();
                        // Se nella singola anta ho uno split
                        if (!(child is Fill))
                        {
                            child = child.AreaList.First().AreaList.First();
                        }
                        child.SetParentArea(this.ParentArea);
                        this.ParentArea.AreaList.Remove(this);
                        this.ParentArea.AreaList.Add(child);
                    }
                    // Se ho singola anta
                    else if (m_SashList.Count == 1)
                    {
                        // Metto come padre dell'area nello splitted l'anta stessa
                        List<Area> ContentArea = new List<Area>();
                        ContentArea.Add(AreaList.First().AreaList.First());
                        ContentArea.First().SetParentArea(this);
                        AreaList.Clear();
                        AreaList.Add(ContentArea.First());
                    }
                    else
                    {
                        // Se aggiungo ante
                        if (SashList.Count > AreaList.Count)
                        {
                            List<Area> ContentArea = new List<Area>();
                            // Salvo in ContentArea il sottoalbero delle singole aree che mantengo
                            if (AreaList.Count >= 1 & SashList.Count > AreaList.Count)
                            {
                                foreach (Area area in AreaList)
                                {
                                    if (area is Splitted)
                                        ContentArea.Add(area.AreaList.First());
                                    else
                                        ContentArea.Add(area);
                                }
                                AreaList.Clear();
                            }
                            for (int SplitIndex = AreaList.Count; SplitIndex <= SashList.Count - 1; SplitIndex++)
                            {
                                AreaList.Add(Splitted.CreateSplitted(this));
                            }
                            // Riaggiungo i sottoalberi che avevo salvato
                            for (int i = 0; i < AreaList.Count - 1; i++)
                            {
                                if (AreaList.Count == 2)
                                {
                                    ContentArea[i].SetParentArea(AreaList[i]);
                                }
                                AreaList[i].AreaList.Add(ContentArea[i]);
                            }
                            // Aggiungo all'ultimo Splitted l'area di vetro
                            Fill newFill = Fill.CreateFill(AreaList[1], FillTypes.GLASS);
                            newFill.SetAreaType(AreaTypes.FILL);
                            AreaList[AreaList.Count - 1].AreaList.Add(newFill);
                        }
                        // Se tolgo anta
                        else
                        {
                            for (int SplitIndex = SashList.Count; SplitIndex <= AreaList.Count() - 1; SplitIndex++)
                            {
                                AreaList.Remove(AreaList[AreaList.Count - 1]);
                                break;
                            }
                        }
                    }
                    for (int i = 0; i < AreaList.Count; i++)
                        AreaList.ElementAt(i).SearchAreaList(AreaList.ElementAt(i), SashList.ElementAt(i).dDimension, "Width");
                }
                RefreshHardwareList();
                ClearHardwareOptionList();
                SetFirstHardware();
            }
        }

        public OrientationSash OrientationSashType
        {
            get
            {
                return (OrientationSash)m_SelOrientationSashType;
            }
        }

        public List<IdNameStruct> OrientationSashTypeList
        {
            get
            {
                return m_OrientationSashTypeList;
            }
        }

        public bool SashBottomRail
        {
            get
            {
                return m_bSashBottomRail;
            }
            set
            {
                m_bSashBottomRail = value;
            }
        }

        public int SashBottomRailQty
        {
            get
            {
                return m_nSashBottomRailQty;
            }
            set
            {
                if (value >= 0)
                {
                    m_nSashBottomRailQty = value;
                    if (m_nSashBottomRailQty > 0)
                    {
                        m_bSashBottomRail = true;
                    }
                    else
                    {
                        m_bSashBottomRail = false;
                    }
                }
            }
        }

        public List<SashDimension> SashList
        {
            get
            {
                return m_SashList;
            }
            set
            {
                m_SashList = value;
            }
        }

        public SashTypes SashType
        {
            get
            {
                return m_SashType;
            }
            set
            {
                m_SashType = value;
            }
        }

        public string SelFamilyHardware
        {
            get
            {
                return m_SelFamilyHardware;
            }
            set
            {
                SetSelFamilyHardware(value);
            }
        }

        public Hardware SelHardware
        {
            get
            {
                return m_SelHardware;
            }
            set
            {
                m_SelHardware = value;
                if (HwOptionList.Count != 0)
                {
                    ClearHardwareOptionList();
                }
            }
        }

        public string SelHardwareFromId
        {
            get
            {
                return m_SelHardware.Id;
            }
            set
            {
                m_SelHardware = m_HardwareList.FirstOrDefault(x => !string.IsNullOrEmpty(value) && x.Id.Equals(value)) ?? new Hardware(CustomHwId, "", "", Enums.OpeningTypes.Null, "", 0, 0);
                HwOptionList.Clear();
                if (SelHardware.Id == CustomHwId)
                {
                    SelHwOptionList.Clear();
                }
            }
        }

        public string GetHardwareDescription
        {
            get
            {
                return m_SelHardware.Description;
            }
        }

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

        public int SelOrientationSashTypeIndex
        {
            get
            {
                return (int)m_SelOrientationSashType;
            }
            set
            {
                m_SelOrientationSashType = (OrientationSash)value;
                if (value == 0)
                {
                    m_bIsSashVertical = true;
                }
                else
                {
                    m_bIsSashVertical = false;
                }
            }
        }

        public string SashShape
        {
            get => m_CurrShape;
            set => m_CurrShape = value;
        }

        #endregion Public Properties

        #region Public Methods

        public override Sash Copy(Area newParentArea)
        {
            Sash newSash = new Sash(newParentArea, m_ParentWindow);
            AddCounterGroup();
            newSash.SetGroupId(nCounterGroup);
            newSash.SetAreaType(AreaType);
            // Imposta la quantità di ante e definisce SashDimension di ogni anta ai valori di default
            newSash.SetSashQty(nSashQty);
            newSash.SetIsSashVertical(bIsSashVertical);
            newSash.SetOrientationSashType(OrientationSashType);
            newSash.SetSashBottomRailQty(SashBottomRailQty);
            for (int i = 0; i < SashList.Count; i++)
            {
                //Cancello SashDimension di default e aggiungo la copia
                newSash.SashList.RemoveAt(i);
                SashDimension newSashDim = SashList[i].Copy();
                newSash.SashList.Insert(i, newSashDim);
            }
            foreach (var item in AreaList)
            {
                Area newArea = item.Copy(newSash);
                newSash.AreaList.Add(newArea);
            }
            newSash.SetSelFamilyHardwareFromIndex(m_SelHardware.Id);
            newSash.SetSelHardwareFromId(CustomHwId);
            //if (ParentWindow.AreaList.First().SelShapeIndex == (int)Shapes.ARC ||
            //   ParentWindow.AreaList.First().SelShapeIndex == (int)Shapes.DOUBLEARC ||
            //   ParentWindow.AreaList.First().SelShapeIndex == (int)Shapes.ARC_FULL ||
            //   ParentWindow.AreaList.First().SelShapeIndex == (int)Shapes.THREECENTERARC)
            //    newSash.SashArcElem = new SashArcElement(newSash, ParentWindow, 10, true);
            //else
            //    newSash.SashArcElem = null;
            return newSash;
        }

        /// <summary>
        /// Update valori ammissibili x HW list
        /// </summary>
        public void RefreshHardwareList()
        {
            if (m_HardwareCompleteList != null && m_HardwareCompleteList.Count > 0)
            {
                m_HardwareList.Clear();
                Enums.OpeningTypes sOpeningType = ConvertOpeningType();
                if (string.IsNullOrEmpty(m_SelFamilyHardware))
                    m_SelFamilyHardware = s_FamilyHardwareList.FirstOrDefault();
                int sashPosition = 1;
                if (nSashQty > 2 && !(SashList.First().bHasHandle || SashList.Last().bHasHandle))
                    sashPosition = 2;
                var iComp = StringComparison.InvariantCultureIgnoreCase;
                var rawList = m_HardwareCompleteList
                                                    .Where(x => x.Id == "000000" ||
                                                            (!string.IsNullOrEmpty(m_SelFamilyHardware) &&
                                                             x.FamilyName.Equals(m_SelFamilyHardware, iComp) && 
                                                             x.SashQty == nSashQty &&
                                                             x.Shape.Equals(m_CurrShape, iComp) &&
                                                             x.OpeningType == sOpeningType &&
                                                             x.SashPosition == sashPosition)
                                                           )
                                                    .ToList() ?? new List<Hardware>();
                if(rawList.Count == 0 || rawList == null)
                {
                    Hardware hw = new Hardware(CustomHwId, m_SelFamilyHardware, "Custom", sOpeningType, m_CurrShape, nSashQty, 1);
                    rawList.Add(hw);
                }
                m_HardwareList = new List<Hardware>(rawList);
            }
        }

        /// <summary>
        /// Metodo per rimuovere l'intero sash group
        /// </summary>
        public void Remove()
        {
            ParentArea.AreaList.Remove(this);
            Fill newFill = Fill.CreateFill(ParentArea, FillTypes.GLASS);
            newFill.SetAreaType(AreaTypes.FILL);
            ParentArea.AreaList.Add(newFill);
        }

        public void SetSelFamilyHardware(string sFamilyHw)
        {
            m_SelFamilyHardware = sFamilyHw;
            // se ho la shape aggiorno elenco HW
            if (!string.IsNullOrEmpty(m_CurrShape))
            {
                RefreshHardwareList();
            }
            SetFirstHardware();
            if (HwOptionList.Count != 0)
                ClearHardwareOptionList();
        }

        /// <summary>
        /// Aggiornamento HW List e Hw selezionato conseguente a ricezione nuova Shape
        /// </summary>
        /// <param name="newShape"></param>
        public void UpdateShape(string newShape)
        {
            m_CurrShape = newShape;
            // la famiglia hw è vuota seleziono il primo hardware valido e utilizzo la sua famiglia
            if(string.IsNullOrEmpty(m_SelFamilyHardware) || m_SelFamilyHardware == "")
            {
                var listHwValid = Sash.m_HardwareCompleteList
                                                    .FirstOrDefault(x => x.Shape == m_CurrShape &&
                                                                    x.SashQty == nSashQty &&
                                                                    x.OpeningType == ConvertOpeningType()
                                                                    );
                if(listHwValid == null)
                {
                    var familyHwValid = Sash.m_HardwareCompleteList
                                                          .Select(x => x.FamilyName)
                                                          .First();
                    SelHardwareFromId = "000000";
                    ClearHardwareOptionList();
                }
                else
                {
                    SetSelFamilyHardware(listHwValid.FamilyName);
                }
            }
            else
            {
                RefreshHardwareList();
                // se il vecchio hw selezionato non va più bene viene selezionato il primo della lista
                if (!HardwareList.Contains(m_SelHardware) || m_SelHardware.Shape != m_CurrShape)
                {
                    SetFirstHardware();
                    ClearHardwareOptionList();
                }
            }
        }

        #endregion Public Methods

        #region Internal Methods
        
        internal static Sash CreateSash(Area Area)
        {
            Sash newSash = new Sash(Area, Area.ParentWindow);
            AddCounterGroup();
            newSash.SetGroupId(nCounterGroup);
            newSash.SetAreaType(AreaTypes.SASH);
            newSash.SetSashQty(1);
            newSash.SetOrientationSashType(OrientationSash.VERTICAL);
            newSash.SetIsSashVertical(true);
            foreach(var sashDim in newSash.SashList)
            {
                for (var JointIndex = 0; JointIndex <= 3; JointIndex++)
                    sashDim.JointList.Add(new Joint(newSash, JointIndex + 1, Joints.FULL_V));
            }
            newSash.SetSashBottomRail(false);
            newSash.SetSashBottomRailQty(0);
            newSash.SetSelFamilyHardware(Sash.s_FamilyHardwareList.First());
            newSash.ClearHardwareOptionList();
            newSash.SetFirstHardware();
            //newSash.SashArcElem = null;
            return newSash;
        }

        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 Enums.OpeningTypes GetOpeningType(Openings OpeningType)
        {
            switch (OpeningType)
            {
                case Openings.TURNONLY_LEFT:
                case Openings.TURNONLY_RIGHT:
                    {
                        return Enums.OpeningTypes.TurnOnly;
                    }

                case Openings.TILTTURN_LEFT:
                case Openings.TILTTURN_RIGHT:
                    {
                        return Enums.OpeningTypes.TiltTurn;
                    }

                case Openings.TILTONLY_TOP:
                case Openings.TILTONLY_BOTTOM:
                    {
                        return Enums.OpeningTypes.TiltOnly;
                    }

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

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

                case Openings.COMPLANARSLIDE_LEFT:
                case Openings.COMPLANARSLIDE_RIGHT:
                    {
                        return Enums.OpeningTypes.ComplanarSlide;
                    }

                case Openings.LIFTSLIDE_LEFT:
                case Openings.LIFTSLIDE_RIGHT:
                    {
                        return Enums.OpeningTypes.LiftSlide;
                    }

                default:
                    {
                        return Enums.OpeningTypes.Null;
                    }
            }
        }

        internal void ClearHardwareOptionList()
        {
            m_HwOptionList.Clear();
        }

        internal override JsonArea Serialize(bool hideHw)
        {
            if (nCounterGroup < GroupId)
                Area.nCounterGroup = GroupId;
            string currHwId = hideHw ? CustomHwId : m_SelHardware.Id;
            JsonSash JsonSash = new JsonSash(m_bIsSashVertical, m_SashType, m_bSashBottomRail, m_nSashBottomRailQty, currHwId, GroupId);
            foreach (var SashDimension in SashList)
                JsonSash.SashList.Add(SashDimension.Serialize());
            if(HwOptionList.Count > 0)
            {
                foreach (var HwOption in HwOptionList)
                    JsonSash.HwOptionList.Add(HwOption.Serialize());
            }
            else
            {
                foreach (var HwOption in SelHwOptionList)
                    JsonSash.HwOptionList.Add(new JsonHwOption(HwOption.Key, HwOption.Value));
            }
            //if (SashArcElem != null)
            //    JsonSash.ArcElement = SashArcElem.Serialize();
            //else
            //    JsonSash.ArcElement = null;
            foreach (var Area in AreaList)
                JsonSash.AreaList.Add(Area.Serialize(hideHw));
            return JsonSash;
        }

        //internal void SetSashArcElem(SashArcElement arcElement)
        //{
        //    m_SashArcElement = arcElement;
        //}

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

        internal void SetIsMeasureGlass(bool IsMeasureGlass)
        {
            m_bIsMeasureGlass = IsMeasureGlass;
        }

        internal void SetIsSashVertical(bool IsSashVertical)
        {
            m_bIsSashVertical = IsSashVertical;
            if (IsSashVertical)
            {
                m_SelOrientationSashType = OrientationSash.VERTICAL;
            }
            else
            {
                m_SelOrientationSashType = OrientationSash.HORIZONTAL;
            }
        }

        internal void SetHardwareOption(string OptionXml)
        {
            if (!string.IsNullOrEmpty(OptionXml))
            {
                ParametriOpzioni HwOptions = null;
                XmlSerializer serializer = new XmlSerializer(typeof(ParametriOpzioni));
                StringReader reader = new StringReader(OptionXml);
                HwOptions = (ParametriOpzioni)serializer.Deserialize(reader);
                if (HwOptions.Items != null)
                {
                    m_HwOptionList.Clear();
                    foreach (var HwOption in HwOptions.Items)
                    {
                        switch (HwOption.Tipo)
                        {
                            case "Text":
                                {
                                    m_HwOptionList.Add(new AGBOptionText(HwOption));
                                    break;
                                }
                            case "List":
                                {
                                    m_HwOptionList.Add(new AGBOptionCombo(HwOption));
                                    break;
                                }
                        }
                    }
                }
            }
            if (SelHwOptionList.Count > 0)
            {
                foreach (var HwOption in HwOptionList)
                {
                    // Ricerca dell'opzioni nei valori già selezionati
                    var selHwOption = (SelHwOptionList.Where(x => x.Key == HwOption.sName).FirstOrDefault()).Value;
                    if (selHwOption != null)
                    {
                        switch (HwOption.Type)
                        {
                            case HwOptionTypes.COMBO:
                                {
                                    AGBOptionCombo OptCombo = (AGBOptionCombo)HwOption;
                                    var selValue = OptCombo.ValueList.Where(x => x.sValue == selHwOption).FirstOrDefault();
                                    if (selValue != null)
                                        OptCombo.sValue = selValue;
                                    else
                                        OptCombo.sValue = OptCombo.ValueList.First();
                                    break;
                                }
                            case HwOptionTypes.TEXT:
                                {
                                    AGBOptionText OptText = (AGBOptionText)HwOption;
                                    if(OptText.ValueList.FirstOrDefault(x => x.Equals(selHwOption)) != null || OptText.sName.Equals("HMan"))
                                        OptText.sValue = selHwOption;
                                    break;
                                }
                        }
                    }
                    else
                    {
                        SelHwOptionList.Add(HwOption.sName, HwOption.sDescription);
                    }
                }
            }
        }

        internal void SetOrientationSashType(OrientationSash value)
        {
            m_SelOrientationSashType = value;
        }

        internal void SetSashBottomRail(bool bBottomRail)
        {
            m_bSashBottomRail = bBottomRail;
        }

        internal void SetSashBottomRailQty(int nBottomRailQty)
        {
            m_nSashBottomRailQty = nBottomRailQty;
        }

        internal void SetSashQty(int Qty)
        {
            if (Qty >= 0 && Qty <= 4)
            {
                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++)
                    {
                        SashDimension newSashDim = new SashDimension(dNewDimension, MeasureTypes.PERCENTAGE, this, SplitIndex + 1);
                        SashList.Add(newSashDim);
                    }
                }
                else if (Qty < m_SashList.Count)
                {
                    for (var SplitIndex = m_SashList.Count - 1; SplitIndex >= Qty; SplitIndex += -1)
                        SashList.RemoveAt(SplitIndex);
                }
            }
        }

        internal void SetSashType(SashTypes SashType)
        {
            m_SashType = SashType;
        }

        internal string SetSelFamilyHardwareFromIndex(string codHardware)
        {
            string? item = "";
            if (string.IsNullOrEmpty(m_SelFamilyHardware))
            {
                item = m_HardwareCompleteList
                                        .Where(x => x.Id == codHardware)
                                        .Select(x => x.FamilyName)
                                        .FirstOrDefault();
                SetSelFamilyHardware(item ?? "");
            }
            return SelFamilyHardware;
        }

        internal void SetSelHardwareFromId(string sId)
        {
            if (m_HardwareList.Count == 0)
                m_SelHardware = m_HardwareCompleteList.FirstOrDefault(x => x.Id.Equals(sId)) ?? new Hardware(CustomHwId, "", "", Enums.OpeningTypes.Null, "", 0, 0);
            else
                m_SelHardware = m_HardwareList.FirstOrDefault(x => x.Id.Equals(sId)) ?? new Hardware(CustomHwId, "", "", Enums.OpeningTypes.Null, "", 0, 0);
            if (SelHardware.Id == "")
                m_SelHardware = m_HardwareList.First();
            if (SelHardware.Id == CustomHwId)
            {
                HwOptionList.Clear();
                SelHwOptionList.Clear();
            }
        }

        #endregion Internal Methods

        #region Private Fields

        /// <summary>
        /// Codice HW custom x gestione casi non risolvibili di selezione
        /// </summary>
        private const string CustomHwId = "000000";

        private bool m_bIsMeasureGlass;

        private bool m_bIsSashVertical;

        private bool m_bSashBottomRail;

        private string m_CurrShape = "";
        private List<Hardware> m_HardwareList = new List<Hardware>();

        private List<AGBOption> m_HwOptionList = new List<AGBOption>();
        private Dictionary<string, string> m_SelHwOptionList = new Dictionary<string, string>();

        private int m_nSashBottomRailQty;

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

        private List<SashDimension> m_SashList = new List<SashDimension>();
        private SashTypes m_SashType;
        private string m_SelFamilyHardware = "";
        private Hardware m_SelHardware;
        private OrientationSash m_SelOrientationSashType;
        //private SashArcElement m_SashArcElement;

        #endregion Private Fields

        #region Private Methods

        private Enums.OpeningTypes ConvertOpeningType()
        {
            var answ = Enums.OpeningTypes.Null;
            if (m_SashList.Count > 1)
            {
                for (int i = 0; i < m_SashList.Count; i++)
                {
                    if (m_SashList[i].bHasHandle)
                    {
                        answ = GetOpeningType(m_SashList[i].OpeningType);
                    }
                }
            }
            else
            {
                answ = GetOpeningType(m_SashList.First().OpeningType);
            }
            return answ;
        }

        #endregion Private Methods
    }
}