using Egw.Window.Data;
using System.Xml.Serialization;
using WebWindowComplex.Json;
using static WebWindowComplex.Json.WindowConst;

namespace WebWindowComplex.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

        /// <summary>
        /// Dimensione solo luce
        /// true --> dimensione solo luce
        /// false --> dimensione totale
        /// </summary>
        public bool bIsDimensionLight
        {
            get
            {
                return m_IsbDimensionLight;
            }
            set
            {
                if (m_IsbDimensionLight != value)
                {
                    m_IsbDimensionLight = value;
                }
            }
        }

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

        //public SashArcElement? SashArcElem
        //{
        //    get
        //    {
        //        return m_SashArcElement;
        //    }
        //    set
        //    {
        //        m_SashArcElement = value!;
        //    }
        //}
        public List<ElementDimension> BottomRailElemDimList
        {
            get => m_BottomRailElemDimList;
            set => m_BottomRailElemDimList = 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)
                {
                    Frame frame = (Frame)ParentWindow.AreaList.First();
                    double widthTot = 0;
                    if (bIsDimensionLight)
                    {
                        foreach (var item in m_SashList)
                            widthTot = widthTot + item.dDimension;
                    }
                    else
                    {
                        widthTot = CalculateWidthSashGroup(frame, frame.DimensionList.Where(x => x.sName == "Width").First().dDimension, new AreaFound(-1, false)).m_Dimension;
                    }
                    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;
                            if (m_SashList[m_SashList.Count - 1].MeasureType.Equals(MeasureTypes.PROPORTIONAL))
                                dNewDimension = 1;
                            else if (m_SashList[m_SashList.Count - 1].MeasureType is MeasureTypes.PERCENTAGE)
                                dNewDimension = dLastDimension / (value + 1 - nSashQty);
                            else
                            {
                                if (bIsDimensionLight)
                                    dNewDimension = (dLastDimension - m_SashList.Last().ElementDimensionList.ElementAt(1).dDimension
                                                                    - m_SashList.Last().ElementDimensionList.Last().dDimension
                                                                    + Window.m_ParameterList.GetValueOrDefault("Sash_Active_Overlap"))/2;
                                else
                                    dNewDimension = dLastDimension / (value + 1 - nSashQty)
                                                    + (Window.m_ParameterList.GetValueOrDefault("Sash_Active_Overlap"))/2;
                            }
                            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);
                        }
                        if (m_CurrShape == "FullArc" ||
                            m_CurrShape == "Arc" ||
                            m_CurrShape == "SemiFullArc" ||
                            m_CurrShape == "SemiArc")
                        {
                            if (SashList.ElementAt(value - 2) != null)
                                SashList.ElementAt(value - 2)!.JointList.ElementAt(2).SelJointTypeIndex = (int)Joints.FULL_V;
                            if (SashList.LastOrDefault() != null)
                                SashList.LastOrDefault()!.JointList.ElementAt(2).SelJointTypeIndex = (int)Joints.ANGLED;
                        }
                    }
                    else if (value < m_SashList.Count)
                    {
                        if (value > 0)
                        {
                            double dLastDimension = 0;
                            SashDimension itemDelete = new SashDimension(0, MeasureTypes.NULL, this, 0);
                            double deleteDim = 0;
                            double splitDelete = 0;
                            for (var SplitIndex = m_SashList.Count - 1; SplitIndex >= value; SplitIndex += -1)
                            {
                                itemDelete = m_SashList[SplitIndex];
                                if(itemDelete.SelMeasureType is MeasureTypes.ABSOLUTE)
                                {
                                    if (bIsDimensionLight)
                                        splitDelete = m_SashList[m_SashList.Count - 2].ElementDimensionList.ElementAt(1).dDimension
                                                        + m_SashList.Last().ElementDimensionList.Last().dDimension
                                                        - m_SashList.Last().ElementDimensionList.Last().dOverlap;
                                    else
                                        splitDelete = - m_SashList.Last().ElementDimensionList.Last().dOverlap;
                                }
                                SashList.RemoveAt(SplitIndex);
                            }
                            if (!itemDelete.SelMeasureType.Equals(m_SashList[SashList.Count - 1].SelMeasureType))
                            {
                                AreaDimension ad = new AreaDimension(itemDelete.dDimension, itemDelete.SelMeasureType, itemDelete.Parent);
                                List<AreaDimension> adList = new List<AreaDimension>();
                                foreach (var it in SashList)
                                {
                                    adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType, it.Parent));
                                }
                                deleteDim = ad.ConvertDimension(adList, itemDelete.SelMeasureType, m_SashList[SashList.Count - 1].SelMeasureType, widthTot, m_SashList.IndexOf(itemDelete));
                            }
                            else
                            {
                                deleteDim = itemDelete.dDimension;
                            }
                            dLastDimension = deleteDim + m_SashList[SashList.Count - 1].dDimension + splitDelete;
                            if(SashList[SashList.Count - 1].SelMeasureType is MeasureTypes.PROPORTIONAL && SashList.Count == 1)
                                SashList[SashList.Count - 1].SetDimension(1);
                            else
                                SashList[SashList.Count - 1].SetDimension(dLastDimension);
                            if (value == 1)
                                SashList.First().SetHasHandle(true);
                        }
                        else
                        {
                            SashList.RemoveAt(0);
                        }
                        if (m_CurrShape == "FullArc" ||
                            m_CurrShape == "Arc" ||
                            m_CurrShape == "SemiFullArc" ||
                            m_CurrShape == "SemiArc")
                        {
                            if (SashList.LastOrDefault() != null)
                            {
                                SashList.LastOrDefault()!.JointList.ElementAt(2).SelJointTypeIndex = (int)Joints.ANGLED;
                            }
                        }
                    }
                    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 <= ContentArea.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
                            for(int k = ContentArea.Count; k <= AreaList.Count - 1; k++)
                            {
                                Fill newFill = Fill.CreateFill(AreaList[k], FillTypes.GLASS);
                                newFill.SetAreaType(AreaTypes.FILL);
                                AreaList[k].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++)
                    {
                        double width = SashList.ElementAt(i).dDimension;
                        if(SashList.ElementAt(i).ElementDimensionList.Count > 0 && !bIsDimensionLight)
                            width = width - SashList.ElementAt(i).ElementDimensionList.ElementAt(1).dDimension
                                          - SashList.ElementAt(i).ElementDimensionList.Last().dDimension;
                        AreaList.ElementAt(i).SearchAreaList(AreaList.ElementAt(i), width, "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)
                {
                    if (value > m_nSashBottomRailQty)
                    {
                        // Aggiungo un element
                        BottomRailElemDimList.Add(new ElementDimension(this, BottomRailElemDimList.Count + 1, 78));
                        BottomRailElemDimList.Last().SetNameElement("Sash_Fill_Rail");
                        BottomRailElemDimList.Last().SetMinDimension(Window.m_ParameterList.GetValueOrDefault(BottomRailElemDimList.Last().sName + "_DimMin"));
                        BottomRailElemDimList.Last().SetMaxDimension(Window.m_ParameterList.GetValueOrDefault(BottomRailElemDimList.Last().sName + "_DimMax"));
                        BottomRailElemDimList.Last().SetDimension(Window.m_ParameterList.GetValueOrDefault(BottomRailElemDimList.Last().sName + "_DimStd"));
                        BottomRailElemDimList.Last().SetOverlapElement(Window.m_ParameterList.GetValueOrDefault("Sash_BottomRail_Overlap"));
                        if (value > 1 && BottomRailElemDimList.Count - 2 >= 0)
                        {
                            BottomRailElemDimList.ElementAt(BottomRailElemDimList.Count - 2).SetNameElement("Sash_Rail");
                            BottomRailElemDimList.ElementAt(BottomRailElemDimList.Count - 2).SetMinDimension(Window.m_ParameterList.GetValueOrDefault(BottomRailElemDimList.ElementAt(BottomRailElemDimList.Count - 2).sName + "_DimMin"));
                            BottomRailElemDimList.ElementAt(BottomRailElemDimList.Count - 2).SetMaxDimension(Window.m_ParameterList.GetValueOrDefault(BottomRailElemDimList.ElementAt(BottomRailElemDimList.Count - 2).sName + "_DimMax"));
                            BottomRailElemDimList.ElementAt(BottomRailElemDimList.Count - 2).SetDimension(BottomRailElemDimList.ElementAt(BottomRailElemDimList.Count - 2).dDimension);
                        }
                    }
                    else if (value < m_nSashBottomRailQty)
                    {
                        // Elimino gli element
                        for (int i = BottomRailElemDimList.Count - 1; i == value; i--)
                            BottomRailElemDimList.RemoveAt(i);
                        if (value >= 1)
                        {
                            BottomRailElemDimList.Last().SetNameElement("Sash_Fill_Rail");
                            BottomRailElemDimList.Last().SetMinDimension(Window.m_ParameterList.GetValueOrDefault(BottomRailElemDimList.Last().sName + "_DimMin"));
                            BottomRailElemDimList.Last().SetMaxDimension(Window.m_ParameterList.GetValueOrDefault(BottomRailElemDimList.Last().sName + "_DimMax"));
                            BottomRailElemDimList.Last().SetDimension(BottomRailElemDimList.Last().dDimension);
                        }
                    }
                    m_nSashBottomRailQty = value;
                    if (m_nSashBottomRailQty > 0)
                    {
                        m_bSashBottomRail = true;
                    }
                    else
                    {
                        m_bSashBottomRail = false;
                    }
                    Frame frame = ParentWindow.AreaList.First();
                    if (frame.AreaList.Count > 0 && frame != null)
                        frame.SearchAreaList(frame, frame.AvailHeightArea(), "Height");
                    //ParentWindow.AreaList.First().SearchAreaList(ParentWindow.AreaList.First(), ParentWindow.AreaList.First().AvailHeightArea(), "Height");
                }
            }
        }

        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 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 = new List<Hardware>();
                    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 void SetIsDimensionLight(bool DimensionLight)
        {
            m_IsbDimensionLight = DimensionLight;
        }

        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, bIsDimensionLight);
            foreach (var SashDimension in SashList)
                JsonSash.SashList.Add(SashDimension.Serialize());
            foreach (var BottomRailDim in BottomRailElemDimList)
                JsonSash.BottomRailElemDimList.Add(BottomRailDim.Serialize());
            if (HwOptionList.Count > 0)
            {
                foreach (var HwOption in HwOptionList)
                    JsonSash.HwOptionList.Add(HwOption.Serialize());
            }
            //else if(currHwId != "000000")
            //{
            //    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 SetIsSashVertical(bool IsSashVertical)
        {
            m_bIsSashVertical = IsSashVertical;
            if (IsSashVertical)
            {
                m_SelOrientationSashType = OrientationSash.VERTICAL;
            }
            else
            {
                m_SelOrientationSashType = OrientationSash.HORIZONTAL;
            }
        }

        /// <summary>
        /// Metodo per impostare opzioni hardware da xml
        /// </summary>
        /// <param name="OptionXml"></param>
        internal void SetHardwareOption(string OptionXml)
        {
            if (!string.IsNullOrEmpty(OptionXml))
            {
                ParametriOpzioni? HwOptions = new ParametriOpzioni();
                XmlSerializer serializer = new XmlSerializer(typeof(ParametriOpzioni));
                StringReader reader = new StringReader(OptionXml);
                HwOptions = (ParametriOpzioni?)serializer.Deserialize(reader);
                if (HwOptions != null && 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)
        {
            if(codHardware != "000000")
            {
                string? item = "";
                if (string.IsNullOrEmpty(m_SelFamilyHardware))
                {
                    item = m_HardwareCompleteList
                                            .Where(x => x.Id == codHardware)
                                            .Select(x => x.FamilyName)
                                            .FirstOrDefault();
                    SetSelFamilyHardware(item ?? "");
                }
            }
            return m_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();
            }
        }

        internal AreaFound CalculateWidthSashGroup(Area area, double width, AreaFound res)
        {
            for (int i = 0; i < area.AreaList.Count; i++)
            {
                if (area.Equals(this))
                {
                    res.m_Dimension = width;
                    res.m_Found = true;
                    return res;
                }
                Area item = area.AreaList[i];
                if (area is Split split)
                {
                    if (split.SplitVertList.Count > 0)
                    {
                        double dim = width;
                        double widthGlass = width;
                        foreach (var elem in split.ElemDimVertList)
                        {
                            widthGlass = widthGlass - elem.dDimension;
                        }
                        switch (split.SplitVertList.ElementAt(i).SelMeasureType)
                        {
                            case MeasureTypes.ABSOLUTE:
                                {
                                    dim = split.SplitVertList.ElementAt(i).dDimension;
                                    break;
                                }
                            case MeasureTypes.PROPORTIONAL:
                                {
                                    
                                    AreaDimension ad = new AreaDimension(split.SplitVertList.ElementAt(i).dDimension, split.SplitVertList.ElementAt(i).SelMeasureType, split.SplitVertList.ElementAt(i).Parent);
                                    List<AreaDimension> adList = new List<AreaDimension>();
                                    foreach (var it in split.SplitVertList)
                                    {
                                        adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType, it.Parent));
                                    }
                                    dim = ad.ConvertFromPropVal(adList, MeasureTypes.ABSOLUTE, widthGlass);
                                    break;
                                }
                            case MeasureTypes.PERCENTAGE:
                                {
                                    dim = split.SplitVertList.ElementAt(i).dDimension * widthGlass / 100;
                                    break;
                                }
                        }
                        if (split.ParentArea is Frame frame && split.AreaList.ElementAt(i).AreaList.First() is Sash sash)
                            dim = dim + sash.SashList.First().ElementDimensionList.Last().dOverlap
                                      + sash.SashList.Last().ElementDimensionList.ElementAt(1).dOverlap;
                        res = CalculateWidthSashGroup(item, dim, res);
                        if (res.m_Dimension != -1 && res.m_Found)
                            return res;
                    }
                    else
                    {
                        double dim = width;
                        if (split.SplitHorizList.Count > 0 && split.AreaList.ElementAt(i).AreaList.First() is Sash sash)
                        {
                            dim = dim + sash.SashList.First().ElementDimensionList.Last().dOverlap
                                      + sash.SashList.Last().ElementDimensionList.ElementAt(1).dOverlap;
                        }
                        res = CalculateWidthSashGroup(item, dim, res);
                        if (res.m_Dimension != -1 && res.m_Found)
                            return res;
                    }
                }
                else if (area is Sash sash)
                {
                    switch (sash.SashList.ElementAt(i).SelMeasureType)
                    {
                        case MeasureTypes.ABSOLUTE:
                            {
                                res = CalculateWidthSashGroup(item, sash.SashList.ElementAt(i).dDimension, res);
                                break;
                            }
                        case MeasureTypes.PROPORTIONAL:
                            {
                                SashDimension anta = sash.SashList.ElementAt(i);
                                AreaDimension ad = new AreaDimension(anta.dDimension, anta.SelMeasureType, anta.Parent);
                                List<AreaDimension> adList = new List<AreaDimension>();
                                foreach (var it in sash.SashList)
                                {
                                    adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType, it.Parent));
                                }
                                res = CalculateWidthSashGroup(item, ad.ConvertFromPropVal(adList, MeasureTypes.ABSOLUTE, width), res);
                                break;
                            }
                        case MeasureTypes.PERCENTAGE:
                            {
                                res = CalculateWidthSashGroup(item, sash.SashList.ElementAt(i).dDimension * width / 100, res);
                                break;
                            }
                    }
                    if (res.m_Dimension != -1 && res.m_Found)
                        return res;
                }
                else
                {
                    res = CalculateWidthSashGroup(item, width, res);
                    if (res.m_Dimension != -1 && res.m_Found)
                        return res;
                }
            }
            return res;
        }

        internal AreaFound CalculateHeightSashGroup(Area area, double height, AreaFound res)
        {
            for (int i = 0; i < area.AreaList.Count; i++)
            {
                if (area.Equals(this))
                {
                    res.m_Dimension = height;
                    res.m_Found = true;
                    return res;
                }
                Area item = area.AreaList[i];
                if (area is Split split)
                {
                    if (split.SplitVertList.Count > 0)
                    {
                        double dim = height;
                        res = CalculateHeightSashGroup(item, dim, res);
                        if (res.m_Dimension != -1 && res.m_Found)
                            return res;
                    }
                    else
                    {
                        double dim = height;
                        double widthGlass = height;
                        int minSubArea = split.ElemDimHorizList.Min(x => x.nSubArea);
                        foreach (var elem in split.ElemDimHorizList.Where(x => x.nSubArea == minSubArea))
                        {
                            widthGlass = widthGlass - elem.dDimension;
                        }
                        switch (split.SplitHorizList.ElementAt(i).SelMeasureType)
                        {
                            case MeasureTypes.ABSOLUTE:
                                {
                                    dim = split.SplitHorizList.ElementAt(i).dDimension;
                                    break;
                                }
                            case MeasureTypes.PROPORTIONAL:
                                {
                                    
                                    AreaDimension ad = new AreaDimension(split.SplitHorizList.ElementAt(i).dDimension, split.SplitHorizList.ElementAt(i).SelMeasureType, split.SplitHorizList.ElementAt(i).Parent);
                                    List<AreaDimension> adList = new List<AreaDimension>();
                                    foreach (var it in split.SplitHorizList)
                                    {
                                        adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType, it.Parent));
                                    }
                                    dim = ad.ConvertFromPropVal(adList, MeasureTypes.ABSOLUTE, widthGlass);
                                    break;
                                }
                            case MeasureTypes.PERCENTAGE:
                                {
                                    dim = split.SplitHorizList.ElementAt(i).dDimension * widthGlass / 100;
                                    break;
                                }
                        }
                        if (split.ParentArea is Frame frame && split.AreaList.ElementAt(i).AreaList.First() is Sash sash)
                            dim = dim + sash.SashList.First().ElementDimensionList.First().dOverlap
                                      + sash.SashList.First().ElementDimensionList.ElementAt(sash.SashList.First().ElementDimensionList.Count - 2).dOverlap;
                        res = CalculateHeightSashGroup(item, dim, res);
                        if (res.m_Dimension != -1 && res.m_Found)
                            return res;
                    }
                }
                else
                {
                    res = CalculateHeightSashGroup(item, height, res);
                    if (res.m_Dimension != -1 && res.m_Found)
                        return res;
                }
            }
            return res;
        }

        #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_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<ElementDimension> m_BottomRailElemDimList = new List<ElementDimension>();
        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 = null;
        private OrientationSash m_SelOrientationSashType;
        //private SashArcElement m_SashArcElement;

        private bool m_IsbDimensionLight = false;

        #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
    }
}