webwindowconfigurator/WebWindowComplex/Models/Sash.cs

using Egw.Window.Data;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WebWindowComplex.Json;
using static WebWindowComplex.Json.WindowConst;

namespace WebWindowComplex.Models
{
    public class Sash : Area
    {

        public event EventHandler<OnReqShapeEventArgs> OnReqShape = delegate { };

        internal void OnReqShapePreview(string sJwd, int groupId)
        {
            OnReqShapeEventArgs e = new OnReqShapeEventArgs(sJwd, groupId);
            EventHandler<OnReqShapeEventArgs> handler = OnReqShape;
            if (handler != null)
            {
                handler(this, e);
            }
        }

        #region Public Fields

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

        // Lista 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 string sSashShape
        {
            get => m_CurrShape;
        }
        public bool bIsMeasureGlass
        {
            get
            {
                return m_bIsMeasureGlass;
            }
            set
            {
                m_bIsMeasureGlass = value;
            }
        }

        public bool bIsPercentage
        {
            get
            {
                return m_bIsPercentage;
            }
        }

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

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

        public List<ParametriOpzioni> HwdOptionList
        {
            get
            {
                return m_HwdOptionList;
            }
        }

        public List<Joint> JointList
        {
            get
            {
                return m_JointList;
            }
            set
            {
                m_JointList = value;
            }
        }

        public int nSashQty
        {
            get
            {
                return m_SashList.Count > 0 ? m_SashList.Count : 1;
            }
            set
            {
                if (value >= 0 && value <= 4)
                {
                    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, SplitIndex + 1));
                        }
                    }
                    else if (value < m_SashList.Count)
                    {
                        if (value > 0)
                        {
                            double dLastDimension = 0;
                            for (var SplitIndex = m_SashList.Count - 1; SplitIndex >= value; SplitIndex += -1)
                            {
                                dLastDimension += m_SashList[SplitIndex].dDimension;
                                SashList.RemoveAt(SplitIndex);
                            }
                            dLastDimension += m_SashList[SashList.Count - 1].dDimension;
                            SashList[SashList.Count - 1].SetDimension(dLastDimension);
                            if (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);
                            //Fill newFill = new Fill(AreaList[1], ParentWindow);
                            //newFill.SetFillType(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;
                            }
                        }
                    }
                }
                ReqRefreshShape();
                RefreshHardwareOptionList();
                SetFirstHardware();
                m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
            }
        }

        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
            {
                // Controllo che il valore inserito sia positivo
                if (value >= 0)
                {
                    m_nSashBottomRailQty = value;
                    if (m_nSashBottomRailQty > 0)
                    {
                        m_bSashBottomRail = true;
                    }
                    else
                    {
                        m_bSashBottomRail = false;
                    }
                    m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
                }
            }
        }

        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);
                m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
            }
        }

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

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

        public string SelHardwareFromId
        {
            get
            {
                return m_SelHardware.Id;
            }
            set
            {
                m_SelHardware = m_HardwareList.FirstOrDefault(x => !string.IsNullOrEmpty(value) && x.Id.Equals(value)) ?? new Hardware("", "", "", Enums.OpeningTypes.Null, "", 0, 0);
                ParentWindow.OnUpdatePreview(ParentWindow.sSerialized());
            }
        }

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

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

        #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);
            newSash.SetSelFamilyHardwareFromIndex(SelHardware.Id);
            newSash.ReqRefreshShape();
            newSash.RefreshHardwareOptionList();
            newSash.SetSelHardware(SelHardware);
            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 JointList)
            {
                Joint newJoint = item.Copy();
                newSash.JointList.Add(newJoint);
            }
            foreach (var item in AreaList)
            {
                Area newArea = item.Copy(newSash);
                newSash.AreaList.Add(newArea);
            }
            return newSash;
        }

        /// <summary>
        /// Richiesta calcolo shape corrente
        /// </summary>
        public void ReqRefreshShape()
        {
            if (m_HardwareCompleteList != null && m_HardwareCompleteList.Count > 0)
            {
                m_HardwareList.Clear();
                // reset shape corrente
                m_CurrShape = "";

                // chiamata evento calcolo shape: gruppo da calcolare
                OnReqShapePreview(m_ParentWindow.sSerialized(), GroupId);
            }
        }

        /// <summary>
        /// Agfgiornamento HW List conseguente a ricezione nuiova Shape
        /// </summary>
        /// <param name="newShape"></param>
        public void UpdateShape(string newShape)
        {
            m_CurrShape = newShape;
            RefreshHardwareList();
        }

        /// <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();
                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)
                             )
                            .ToList();
                if (rawList != null && rawList.Count > 0)
                {
                    m_HardwareList = new List<Hardware>(rawList);
                }
                else
                {
                    m_HardwareList = new List<Hardware>();
                }
            }
        }


        public void Remove()
        {
            ParentArea.AreaList.Remove(this);
            Fill newFill = Fill.CreateFill(ParentArea, FillTypes.GLASS);
            newFill.SetAreaType(AreaTypes.FILL);
            ParentArea.AreaList.Add(newFill);
            m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
        }

        #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);
            for (var JointIndex = 0; JointIndex <= 3; JointIndex++)
                newSash.JointList.Add(new Joint(newSash, JointIndex + 1, Joints.FULL_H));
            newSash.SetSashBottomRail(false);
            newSash.SetSashBottomRailQty(0);
            newSash.SetSelFamilyHardware(Sash.s_FamilyHardwareList.First());
            newSash.ReqRefreshShape();
            newSash.RefreshHardwareOptionList();
            newSash.SetFirstHardware();
            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 RefreshHardwareOptionList()
        {
            m_HwdOptionList.Clear();
        }

        internal override JsonArea Serialize()
        {
            if (nCounterGroup < GroupId)
                Area.nCounterGroup = GroupId;
            JsonSash JsonSash = new JsonSash(m_bIsSashVertical, m_SashType, m_bSashBottomRail, m_nSashBottomRailQty, m_SelHardware.Id, GroupId);
            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;
        }

        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 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++)
                        SashList.Add(new SashDimension(dNewDimension, true, this, SplitIndex + 1));
                }
                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;
        }

        public void SetSelFamilyHardware(string sFamilyHw)
        {
            m_SelFamilyHardware = sFamilyHw;
            ReqRefreshShape();
            RefreshHardwareOptionList();
            SetFirstHardware();
        }
        internal string SetSelFamilyHardwareFromIndex(string codHardware)
        {
            if (string.IsNullOrEmpty(m_SelFamilyHardware))
            {
                var item = m_HardwareCompleteList
                                        .Where(x => x.Id == codHardware)
                                        .Select(x => x.FamilyName)
                                        .ToList();
                SelFamilyHardware = item.First();
            }
            return SelFamilyHardware;
        }

        internal void SetSelHardware(Hardware value)
        {
            SelHardware = value;
        }

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

        #endregion Internal Methods

        #region Private Fields

        private bool m_bIsMeasureGlass;

        private bool m_bIsPercentage = true;

        private bool m_bIsSashVertical;

        private bool m_bSashBottomRail;

        private List<Hardware> m_HardwareList = new List<Hardware>();

        private List<ParametriOpzioni> m_HwdOptionList = new List<ParametriOpzioni>();

        private List<Joint> m_JointList = new List<Joint>();

        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 string m_CurrShape = "";
        private Hardware m_SelHardware;
        private OrientationSash m_SelOrientationSashType;

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

        private string FindSashShape()
        {
            return "Rectangle";
        }

        #endregion Private Methods
    }
}