using Egw.Window.Data;
using Microsoft.AspNetCore.Components;
using Newtonsoft.Json;
using System.Threading.Tasks;
using WebWindowTest.Compo;
using WebWindowTest.DTO;
using WebWindowTest.Json;
using WebWindowTest.Models;
using WebWindowTest;
using static WebWindowTest.Json.WindowConst;
using static WebWindowTest.LayoutConst;

namespace WebWindowTest
{
    public partial class Test : IDisposable
    {
        #region Public Enums

        public enum DataReq
        {
            /// <summary>
            /// Nessuna richiesta
            /// </summary>
            None = 0,

            /// <summary>
            /// Richiesta hardware opzioni
            /// </summary>
            ReqHwOpt,

            /// <summary>
            /// Richiesta svg
            /// </summary>
            ReqSvg,

            /// <summary>
            /// Richiesta shape sash group
            /// </summary>
            ReqShape
        }

        #endregion Public Enums

        #region Public Properties

        /// <summary>
        /// Classe override css x SVG (x rescale)
        /// </summary>
        [Parameter]
        public string CssSvg { get; set; } = "responsive-svg";

        /// <summary>
        /// Preselezione valori
        /// </summary>
        [Parameter]
        public SelectPayload? CurrSelection { get; set; } = null;

        /// <summary>
        /// Richiesta azione al parent
        /// </summary>
        [Parameter]
        public EventCallback<DataAction> EC_ActionReq { get; set; }

        /// <summary>
        /// Richiesta update da JWD (SVG, calcoli vari...)
        /// </summary>
        [Parameter]
        public EventCallback<Dictionary<string, string>> EC_DoUpdate { get; set; }

        /// <summary>
        /// Richiesta chiusura JWD (+ refresh)
        /// se torna true --> richiesta salvataggio
        /// se torna false --> richiesta revert
        /// </summary>
        [Parameter]
        public EventCallback<bool> EC_OnClose { get; set; }

        /// <summary>
        /// Sollevo evento errore validazione con una lista di errori rilevati
        /// </summary>
        [Parameter]
        public EventCallback<Dictionary<string, string>> EC_ValidError { get; set; }

        /// <summary>
        /// Elenco anagrafiche di base
        /// </summary>
        [Parameter]
        public BaseListPayload ListPayload { get; set; } = null!;

        /// <summary>
        /// Dati live controllo (JWD, SVG, ...)
        /// </summary>
        [Parameter]
        public LivePayload LiveData { get; set; } = null!;

        #endregion Public Properties

        #region Public Methods

        public void Dispose()
        {
            if (m_CurrWindow != null)
            {
                m_CurrWindow = null;
            }
        }

        #endregion Public Methods

        #region Protected Fields

        protected List<string> currLoading = new List<string>();

        /// <summary>
        /// Dati live precedenti x comparazione
        /// </summary>
        protected LivePayload? prevLiveData = null;

        #endregion Protected Fields

        #region Protected Properties

        protected List<Fill> FillList
        {
            get => m_FillList;
        }

        protected Frame FrameWindow
        {
            get => m_Frame!;
            set => m_Frame = value;
        }

        protected List<ItemTable> ItemTableList
        {
            get => m_ItemTableList;
        }

        /// <summary>
        /// Componente SVG da mostrare
        /// </summary>
        protected MarkupString outSvg
        {
            get
            {
                // aggiunta gestione classe svg per posizionamento con costraints
                var newSvg = LiveData.SvgPreview.Replace("<svg", $"<svg class=\"{CssSvg}\"");
                return (MarkupString)newSvg;
            }
        }

        protected List<Sash> SashList
        {
            get => m_SashList;
        }

        protected List<Splitted> SplittedList
        {
            get => m_SplittedList;
        }

        protected string SelColorMaterial { get; set; } = "";
        protected string SelFamilyHardware { get; set; } = "";
        protected string SelGlass { get; set; } = "";
        protected string SelMaterial { get; set; } = ""!;
        protected string SelProfile { get; set; } = "";

        protected List<Split> SplitList
        {
            get => m_SplitList;
        }

        #endregion Protected Properties

        #region Protected Methods

        /// <summary>
        /// Metodo per riempire la lista ItemTable in modo da poter rappresentarla come tabella
        /// </summary>
        /// <param name="node"> Area da classificare </param>
        /// <param name="row"> numero di riga </param>
        /// <param name="col"> numero di colonna </param>
        /// <param name="maxRow"> numero di riga massimo </param>
        /// <param name="maxCol"> numero di colonna massimo </param>
        protected void CreateElementTable(Area node, int row, int col, int maxRow, int maxCol)
        {
            if (node != null)
            {
                switch (node.AreaType)
                {
                    case AreaTypes.FRAME:
                        {
                            if (node.AreaList.Count >= 1)
                                ItemTableList.Add(new ItemTable(AreaTypes.FRAME, "FR", row, col, -1, node.AreaList.Count));
                            else
                                ItemTableList.Add(new ItemTable(AreaTypes.FRAME, "FR", row, col, -1, 0));
                            row++;
                            col++;
                            maxRow++;
                            maxCol++;
                            break;
                        }
                    case AreaTypes.SASH:
                        {
                            string nWIndow;
                            // Se ha fratelli
                            if ((node.ParentArea.ParentArea != null && node.ParentArea.ParentArea.AreaList.Count > 1) ||
                                (node.ParentArea != null && node.ParentArea.AreaList.Count > 1))
                            {
                                for (int i = 0; i < SashList.Count; i++)
                                {
                                    if (SashList[i].Equals(node))
                                    {
                                        nWIndow = SashList.Count == 1 ? "" : $"{i + 1}";
                                        // Se il nodo ha figli, salvo il numero nell'oggetto
                                        if (node.AreaList.Count >= 1)
                                            ItemTableList.Add(new ItemTable(AreaTypes.SASH, "SG" + nWIndow, maxRow, col, i, node.AreaList.Count));
                                        else
                                            ItemTableList.Add(new ItemTable(AreaTypes.SASH, "SG" + nWIndow, maxRow, col, i, 0));
                                    }
                                }
                                maxCol++;
                            }
                            else
                            {
                                // Se il nodo ha figli, salvo il numero nell'oggetto
                                if (node.AreaList.Count >= 1)
                                    ItemTableList.Add(new ItemTable(AreaTypes.SASH, "SG", row, col, 0, node.AreaList.Count));
                                else
                                    ItemTableList.Add(new ItemTable(AreaTypes.SASH, "SG", row, col, 0, 0));
                                maxCol++;
                            }
                            row++;
                            col++;
                            maxRow++;
                            break;
                        }
                    case AreaTypes.FILL:
                        {
                            if ((node.ParentArea.AreaList.Count > 1 && node.ParentArea.AreaList.First().Equals(node)) ||
                                (node.ParentArea.ParentArea != null && node.ParentArea.ParentArea.AreaList.Count > 1 && node.ParentArea.ParentArea.AreaList.First().AreaList.First().Equals(node)))
                                maxCol++;
                            string nFill;
                            for (int i = 0; i < FillList.Count; i++)
                            {
                                if (FillList[i].Equals(node))
                                {
                                    nFill = FillList.Count == 1 ? "" : $"{i + 1}";
                                    ItemTableList.Add(new ItemTable(AreaTypes.FILL, "FL" + nFill, maxRow, col, i, 0));
                                    break;
                                }
                            }
                            row++;
                            col++;
                            maxRow++;
                            break;
                        }
                    case AreaTypes.SPLIT:
                        {
                            // Se il nodo ha fratelli o cugini
                            if (node.ParentArea.AreaList.Count > 1 || (node.ParentArea.ParentArea != null && node.ParentArea.ParentArea.AreaList.Count > 1))
                            {
                                if (node.ParentArea.AreaList.First().Equals(node) || node.ParentArea.ParentArea.AreaList.First().Equals(node))
                                    maxCol++;
                                for (int i = 0; i < SplitList.Count; i++)
                                {
                                    if (SplitList[i].Equals(node))
                                    {
                                        string nSplit = SplitList.Count == 1 ? "" : $"{i + 1}";
                                        if (node.AreaList.Count >= 1)
                                            ItemTableList.Add(new ItemTable(AreaTypes.SPLIT, "SP" + nSplit, maxRow, col, i, node.AreaList.Count));
                                        else
                                            ItemTableList.Add(new ItemTable(AreaTypes.SPLIT, "SP" + nSplit, maxRow, col, i, 0));
                                    }
                                }
                            }
                            else
                            {
                                for (int i = 0; i < SplitList.Count; i++)
                                {
                                    if (SplitList[i].Equals(node))
                                    {
                                        string nSplit = SplitList.Count == 1 ? "" : $"{i + 1}";
                                        if (node.AreaList.Count >= 1)
                                            ItemTableList.Add(new ItemTable(AreaTypes.SPLIT, "SP" + nSplit, row, col, i, node.AreaList.Count));
                                        else
                                            ItemTableList.Add(new ItemTable(AreaTypes.SPLIT, "SP" + nSplit, row, col, i, 0));
                                        maxCol++;
                                    }
                                }
                            }
                            row++;
                            col++;
                            maxRow++;
                            break;
                        }
                    case AreaTypes.SPLITTED:
                        {
                            break;
                        }
                }
                foreach (var item in node.AreaList)
                {
                    if (maxRow < m_maxRow)
                        CreateElementTable(item, row, col, m_maxRow, maxCol);
                    else
                        CreateElementTable(item, row, col, maxRow, maxCol);
                }
            }
            if (maxCol > m_maxCol)
            {
                m_maxCol = maxCol;
            }
            if (maxRow > m_maxRow)
            {
                m_maxRow = maxRow;
            }
        }

        /// <summary>
        /// Metodo per riempire le liste Sash, Split, Splitted e Fill
        /// </summary>
        /// <param name="node"> Area da classificare </param>
        /// <param name="IntoSash"> Parametro per sapere se si è dentro un'anta </param>
        protected void CreateWindowsList(Area node, bool IntoSash)
        {
            if (node != null)
            {
                if (node.ParentArea is Sash || IntoSash == true)
                    IntoSash = true;
                switch (node.AreaType)
                {
                    case AreaTypes.FRAME:
                        {
                            FrameWindow = (Frame)node;
                            break;
                        }
                    case AreaTypes.SASH:
                        {
                            m_SashList.Add((Sash)node);
                            break;
                        }
                    case AreaTypes.FILL:
                        {
                            m_FillList.Add((Fill)node);
                            break;
                        }
                    case AreaTypes.SPLIT:
                        {
                            m_SplitList.Add((Split)node);
                            break;
                        }
                    case AreaTypes.SPLITTED:
                        {
                            if (node.ParentArea is Split && !IntoSash && node.AreaList.First() is Fill)
                            {
                                m_SplittedList.Add((Splitted)node);
                            }
                            break;
                        }
                }
                foreach (var item in node.AreaList)
                {
                    CreateWindowsList(item, IntoSash);
                }
            }
        }

        /// <summary>
        /// Calcola CSS warning
        /// </summary>
        /// <param name="fKey"></param>
        /// <returns></returns>
        protected string cssValid(string fKey)
        {
            return listWarnings.ContainsKey(fKey) ? "border border-danger" : "";
        }

        /// <summary>
        /// Richiesta chiusura SENZA salvataggio (= restore prev)
        /// </summary>
        /// <returns></returns>
        protected async Task DoClose()
        {
            editLock = false;
            await EC_OnClose.InvokeAsync(false);
        }

        /// <summary>
        /// Richiesta update anteprima SVG
        /// </summary>
        /// <param name="doForce">Forza richiesta anche con JWD invariato</param>
        /// <param name="hideHw">Nasconde hw (def. false) poiché senza è piu rapido</param>
        /// <returns></returns>
        protected async Task DoPreviewSvg(bool doForce = false, bool hideHw = false)
        {
            if (m_CurrWindow != null)
            {
#if DEBUG
                var CurrJwd = JsonConvert.SerializeObject(m_CurrWindow.Serialize(false), Formatting.Indented);
                var CalcJwd = JsonConvert.SerializeObject(m_CurrWindow.Serialize(hideHw), Formatting.Indented);
#else
                var CurrJwd = JsonConvert.SerializeObject(m_CurrWindow.Serialize(false));
                var CalcJwd = JsonConvert.SerializeObject(m_CurrWindow.Serialize(hideHw));
#endif
                // verifico variazione JWD
                if (!prevJwd.Equals(CurrJwd) || doForce || prevReq != (int)DataReq.ReqSvg)
                {
                    prevJwd = CurrJwd;
                    prevReq = (int)DataReq.ReqSvg;
                    Dictionary<string, string> Args = new Dictionary<string, string>();
                    Args.Add("Mode", $"{(int)Enums.QuestionModes.PREVIEW}");
                    Args.Add("SerializedData", CalcJwd);
                    await EC_DoUpdate.InvokeAsync(Args);
                }
            }
        }

        /// <summary>
        /// Richiesta calcolo Options HW
        /// </summary>
        /// <param name="groupIdList">Lista degli ID numerici dei gruppi da valutare</param>
        /// <returns></returns>
        protected async Task DoReqOptHardware(List<int> groupIdList, bool isFirst = false)
        {
            if (m_CurrWindow != null)
            {
                loadListAdd("LoadHwOpt");
#if DEBUG
                var CurrJwd = JsonConvert.SerializeObject(m_CurrWindow.Serialize(), Formatting.Indented);
#else
                var CurrJwd = JsonConvert.SerializeObject(m_CurrWindow.Serialize());
#endif
                // verifico variazione JWD
                if (!prevJwd.Equals(CurrJwd) || isFirst || prevReq != (int)DataReq.ReqHwOpt)
                {
                    prevJwd = CurrJwd;
                    prevReq = (int)DataReq.ReqHwOpt;
                    Dictionary<string, string> Args = new Dictionary<string, string>();
                    Args.Add("Mode", $"{(int)Enums.QuestionModes.HARDWARE}");
                    Args.Add("SubMode", $"{(int)Enums.QuestionHwSubModes.HARDWAREOPTIONS}");
                    Args.Add("SerializedData", CurrJwd);
                    string listGroupId = JsonConvert.SerializeObject(groupIdList);
                    Args.Add("GroupId", listGroupId);
                    await EC_DoUpdate.InvokeAsync(Args);
                }
            }
        }

        /// <summary>
        /// Richiesta Shape compatibile da JWD
        /// </summary>
        /// <param name="groupIdList">Lista degli ID numerici dei gruppi da valutare</param>
        /// <returns></returns>
        protected async Task DoReqShape(List<int> groupIdList)
        {
            if (m_CurrWindow != null)
            {
#if DEBUG
                var CurrJwd = JsonConvert.SerializeObject(m_CurrWindow.Serialize(), Formatting.Indented);
#else
                var CurrJwd = JsonConvert.SerializeObject(m_CurrWindow.Serialize());
#endif
                // verifico variazione JWD
                if (!prevJwd.Equals(CurrJwd) || prevReq != (int)DataReq.ReqShape)
                //if (!prevLiveData.CurrJwd.Equals(CurrJwd))
                {
                    prevJwd = CurrJwd;
                    prevReq = (int)DataReq.ReqShape;
                    Dictionary<string, string> Args = new Dictionary<string, string>();
                    Args.Add("Mode", $"{(int)Enums.QuestionModes.HARDWARE}");
                    Args.Add("SubMode", $"{(int)Enums.QuestionHwSubModes.SASHSHAPE}");
                    Args.Add("SerializedData", CurrJwd);
                    string listGroupId = JsonConvert.SerializeObject(groupIdList);
                    Args.Add("GroupId", listGroupId);
                    await EC_DoUpdate.InvokeAsync(Args);
                }
            }
        }

        /// <summary>
        /// Metodo di reset
        /// </summary>
        protected Task DoReset()
        {
            return Task.CompletedTask;
            // Da fare
        }

        /// <summary>
        /// Richiesta chiusura con salvataggio
        /// </summary>
        /// <returns></returns>
        protected async Task DoSave()
        {
            editLock = false;
            //manca salvataggio JWD
            await EC_OnClose.InvokeAsync(true);
        }

        protected override void OnAfterRender(bool firstRender)
        {
            isRendered = true;
        }

        /// <summary>
        /// Primo init componente
        /// </summary>
        protected override void OnInitialized()
        {
            // reset editLock...
            editLock = false;
            listErrPre = new Dictionary<string, string>();
            listErrLink = new Dictionary<string, string>();
            listWarnings = new Dictionary<string, string>();
        }

        /// <summary>
        /// Gestione update post ricezione parametri da controllo chiamante
        /// </summary>
        protected override async Task OnParametersSetAsync()
        {
            isLoading = true;
            // SOLO SE sono presenti...
            if (ListPayload.IsPopulated() && LiveData.IsValid())
            {
                bool updRequested = false;
                listErrPre = new Dictionary<string, string>();
                listErrLink = new Dictionary<string, string>();
                listWarnings = new Dictionary<string, string>();
                // controllo elenchi BasePayload siano validi...
                if (ListPayload.IsValid())
                {
                    // SOLO SE modificato live data...
                    if (prevLiveData == null || !prevLiveData.Equals(LiveData))
                    {
                        bool needDeser = prevLiveData == null || !prevLiveData.JwdEqual(LiveData);
                        updRequested = true;
                        prevLiveData = new LivePayload()
                        {
                            CurrJwd = LiveData.CurrJwd,
                            DictOptionsXml = LiveData.DictOptionsXml,
                            DictShape = LiveData.DictShape,
                            SvgPreview = LiveData.SvgPreview
                        };

                        // Aggiornati parametri di ingresso selezionati
                        UpdateSelParameter();
                        // provo a deserializzare SE necessario
                        if (needDeser)
                        {
                            JsonWindow WindowFromJson = new JsonWindow("", "", "", "");
                            try
                            {
                                WindowFromJson = JsonConvert.DeserializeObject<JsonWindow>(LiveData.CurrJwd, new PolymorphicJsonConverter()) ?? new JsonWindow("", "", "", "");
                                setCurrWindow(WindowFromJson);
                                //SOLO SE non sono in edit...
                                if (!editLock)
                                {
                                    currStep = CompileStep.Tree;
                                }
                            }
                            // altrimenti errore!
                            catch (Exception ex)
                            {
                                listErrLink.Add("Window", $"Deserializing Error:{Environment.NewLine}{ex}");
                                // uso un oggetto "basico" per non fermarmi
                                //string jwd = "{\r\n  \"ProfilePath\": \"Profilo78\",\r\n  \"Material\": \"Pino\",\r\n  \"ColorMaterial\": \"Black\",\r\n  \"Glass\": \"Vetro BE 2S 4T/16/4T\",\r\n  \"AreaList\": [\r\n    {\r\n      \"Shape\": \"RECTANGLE\",\r\n      \"DimensionList\": [\r\n        {\r\n          \"Index\": 1,\r\n          \"Name\": \"Width\",\r\n          \"Value\": 800.0\r\n        },\r\n        {\r\n          \"Index\": 2,\r\n          \"Name\": \"Height\",\r\n          \"Value\": 1200.0\r\n        }\r\n      ],\r\n      \"JointList\": [\r\n        {\r\n          \"Index\": 1,\r\n          \"JointType\": \"FULL_H\"\r\n        },\r\n        {\r\n          \"Index\": 2,\r\n          \"JointType\": \"FULL_H\"\r\n        },\r\n        {\r\n          \"Index\": 3,\r\n          \"JointType\": \"FULL_H\"\r\n        },\r\n        {\r\n          \"Index\": 4,\r\n          \"JointType\": \"FULL_H\"\r\n        }\r\n      ],\r\n      \"BottomRail\": false,\r\n      \"BottomRailQty\": 0,\r\n      \"GroupId\": 1,\r\n      \"AreaList\": [\r\n        {\r\n          \"FillType\": \"GLASS\",\r\n          \"GroupId\": 7,\r\n          \"AreaList\": [],\r\n          \"AreaType\": \"FILL\"\r\n        }\r\n      ],\r\n      \"AreaType\": \"FRAME\"\r\n    }\r\n  ]\r\n}";
                                //WindowFromJson = JsonConvert.DeserializeObject<JsonWindow>(jwd, new PolymorphicJsonConverter()) ?? new JsonWindow("", "", "", "");
                                //setCurrWindow(WindowFromJson);
                                //await DoPreviewSvg(true);
                                Window window = new Window();
                                Frame frame = new Frame(null, window);
                                List<FrameDimension> DimensionList = new List<FrameDimension>
                                    {
                                        new FrameDimension(frame, 1, "Width", 800, false),
                                        new FrameDimension(frame, 1, "Height", 1200, true)
                                     };
                                List<Joint> JointList = new List<Joint>
                                    {
                                        new Joint(frame, 1, Joints.FULL_H),
                                        new Joint(frame, 2, Joints.FULL_H),
                                        new Joint(frame, 3, Joints.FULL_H),
                                        new Joint(frame, 4, Joints.FULL_H)
                                     };
                                //FrameArcElement ae = new FrameArcElement(frame, window, 10, true, true);
                                JsonWindow jsonWindow = new JsonWindow("Profilo78", "Pino", "Black", "Vetro BE 2S 4T/16/4T");
                                JsonFrame jsonFrame = new JsonFrame(Shapes.RECTANGLE, null, false, 0, 1);
                                jsonWindow.AreaList.Add(jsonFrame);
                                //jsonFrame.ArcElement = ae.Serialize();
                                foreach (var Dimension in DimensionList)
                                    jsonFrame.DimensionList.Add(Dimension.Serialize());
                                foreach (var Joint in JointList)
                                    jsonFrame.JointList.Add(Joint.Serialize());
                                jsonFrame.AreaList.Add(Fill.CreateFill(frame, FillTypes.GLASS).Serialize(true));
                                string jwd = JsonConvert.SerializeObject(jsonWindow);
                                WindowFromJson = JsonConvert.DeserializeObject<JsonWindow>(jwd, new PolymorphicJsonConverter()) ?? new JsonWindow("", "", "", "");
                                setCurrWindow(WindowFromJson);
                                await DoPreviewSvg(true);
                            }
                        }
                        else
                        {
                            // usando m_currWindow (preesistente) impostare i parametri...
                            UpdateDict();
                        }
                    }
                    checkWarnings();
                    if (SashList.Count > 0)
                    {
                        currAntaIndex = 0;
                    }
                    if (updRequested)
                    {
                        // se mancasse dizionario forme chiamo quello
                        if (LiveData.DictShape.Count == 0 && listErrLink.Count == 0)
                        {
                            if (firstDisplay && isRendered)
                            {
                                firstDisplay = false;
                                // preview SVG senza HW
                                await DoPreviewSvg(true, true);
                            }
                            List<int> reqList = SashList.Select(x => x.GroupId).ToList();
                            if (reqList.Count > 0)
                            {
                                //prevReq = (int)DataReq.ReqShape;
                                await DoReqShape(reqList);
                            }
                        }
                        else
                        {
                            // chiedo SVG
                            //prevReq = (int)DataReq.ReqSvg;
                            if (prevReq != (int)DataReq.ReqSvg || !prevLiveData.JwdEqual(LiveData.CurrJwd))
                            {
                                if (prevReq != (int)DataReq.ReqHwOpt)
                                    await DoPreviewSvg(true);
                                else if (LiveData.DictOptionsXml.Count > 0)
                                    await DoPreviewSvg(true);
                            }
                        }
                    }
                }
                else
                {
                    checkErrorPre();
                }
                isLoading = false;
            }
        }

        /// <summary>
        /// Metodo per costruire oggetti della Window
        /// </summary>
        /// <param name="WindowFromJson"></param>
        protected void setCurrWindow(JsonWindow WindowFromJson)
        {
            if (m_CurrWindow != null)
            {
                m_CurrWindow = null;
            }
            m_CurrWindow = WindowFromJson.Deserialize();
            FrameWindow = m_CurrWindow.AreaList[0];
            if (m_PreviousWindow != null)
            {
                for (int i = 0; i < 2; i++)
                    m_CurrWindow.AreaList.First().DimensionList[i].dDimension = m_PreviousWindow.AreaList.First().DimensionList[i].dDimension;
                if (m_CurrWindow.AreaList.First().Shape == Shapes.TRIANGLE)
                {
                    for (int i = 0; i < 2; i++)
                        m_CurrWindow.AreaList.First().JointList[i].SetSelJointType(m_PreviousWindow.AreaList.First().JointList[i].SelJointType);
                }
                else
                {
                    for (int i = 0; i < 4; i++)
                        m_CurrWindow.AreaList.First().JointList[i].SetSelJointType(m_PreviousWindow.AreaList.First().JointList[i].SelJointType);
                }
            }
            if (m_CurrWindow != null)
            {
                // Aggiornamento liste sash, split, splitted, fill e itemTable
                UpdateLists();
            }
            if (SashList.Count > 0)
                currAntaIndex = 0;
            // Aggiorno window con dati shape e hw option
            UpdateDict();
        }

        /// <summary>
        /// Aggiornamento dei dati con informazioni ricevute dai dizionari
        /// </summary>
        protected void UpdateDict()
        {
            // se ho i dizionari delle forme le aggiungo
            if (LiveData.DictShape.Count > 0)
            {
                // Inserisco le forme ricevuto nei sash group
                foreach (var item in LiveData.DictShape)
                {
                    Sash sashFromGroupId = SashList.First(x => x.GroupId == item.Key);
                    sashFromGroupId.SashShape = item.Value;
                    sashFromGroupId.UpdateShape(item.Value);
                }
                if (prevReq == (int)DataReq.ReqShape)
                {
                    if (reqHwOpt > 0)
                    {
                        List<int> reqList = SashList.Select(x => x.GroupId).ToList();
                        _ = DoReqOptHardware(reqList);
                    }
                }
            }
            // se ho le opzioni hw le aggiungo
            if (LiveData.DictOptionsXml.Count > 0)
            {
                loadListRem("LoadHwOpt");
                foreach (var item in SashList)
                {
                    if (LiveData.DictOptionsXml.ContainsKey(item.GroupId))
                    {
                        item.SetHardwareOption(LiveData.DictOptionsXml[item.GroupId]);
                    }
                }
            }
        }

        /// <summary>
        /// Metodo che resetta le liste (sash, split, splitted, fill e itemTable) e le crea nuovamente
        /// </summary>
        protected void UpdateLists()
        {
            m_maxCol = 0;
            m_maxRow = 0;
            m_FillList = new List<Fill>();
            m_SashList = new List<Sash>();
            m_SplitList = new List<Split>();
            m_SplittedList = new List<Splitted>();
            m_ItemTableList = new List<ItemTable>();
            CreateWindowsList((m_CurrWindow!).AreaList.First(), false);
            CreateElementTable(m_CurrWindow.AreaList.First(), 1, 1, 1, 1);
        }

        /// <summary>
        /// Metodo per settare i parmateri di ingresso selezionati
        /// </summary>
        protected void UpdateSelParameter()
        {
            Frame.m_AllThresholdList = ListPayload.Threshold;
            Sash.m_HardwareCompleteList = ListPayload.Hardware;
            Sash.s_FamilyHardwareList = ListPayload.FamilyHardware;
            if (CurrSelection != null && CurrSelection.IsValid())
            {
                SelFamilyHardware = CurrSelection.FamilyHardware ?? "";
                SelColorMaterial = CurrSelection.ColorMaterial ?? "";
                SelMaterial = CurrSelection.Material ?? "";
                SelGlass = CurrSelection.Glass ?? "";
                SelProfile = CurrSelection.Profile ?? "";
            }
        }

        #endregion Protected Methods

        #region Private Fields

        private int currAntaIndex = 0;

        private int currFillIndex = -1;

        private int currSashIndex = -1;

        private int currSplitIndex = -1;

        private CompileStep currStep;

        private bool editLock = false;

        private bool firstDisplay = true;

        /// <summary>
        /// Booleana fase loading
        /// </summary>
        private bool isLoading = false;

        private bool isRendered = false;

        /// <summary>
        /// ELenco errori di coerenza/link dati (vanno risolti per disegnare/procedere)
        /// </summary>
        private Dictionary<string, string> listErrLink = new Dictionary<string, string>();

        /// <summary>
        /// Elenco errori preliminari (mancano elementi di base di validazione modello dati))
        /// </summary>
        private Dictionary<string, string> listErrPre = new Dictionary<string, string>();

        /// <summary>
        /// Elenco warnings non bloccanti
        /// </summary>
        private Dictionary<string, string> listWarnings = new Dictionary<string, string>();

        private List<Fill> m_FillList = new List<Fill>();

        private Frame? m_Frame;

        private List<ItemTable> m_ItemTableList = new List<ItemTable>();

        private int m_maxCol = 0;

        private int m_maxRow = 0;

        private List<Sash> m_SashList = new List<Sash>();

        private List<Split> m_SplitList = new List<Split>();

        private List<Splitted> m_SplittedList = new List<Splitted>();

        #endregion Private Fields

        #region Private Properties

        private Window? m_CurrWindow { get; set; } = null;

        private Window? m_PreviousWindow { get; set; } = null;

        /// <summary>
        /// Salvataggio JWD precedente x evitare loop su update (aggiornato dopo chiamate redis)
        /// </summary>
        private string prevJwd { get; set; } = "";

        /// <summary>
        /// Salvataggio tipo di domanda precedente
        /// </summary>
        private int prevReq { get; set; } = 0;
        private int reqHwOpt { get; set; } = 0;

        #endregion Private Properties

        #region Private Methods

        /// <summary>
        /// Metodo per andare allo step successivo
        /// </summary>
        /// <param name="newStep"> step successivo </param>
        private void AdvStep(CompileStep newStep)
        {
            currStep = newStep;
            currSashIndex = -1;
            currFillIndex = -1;
            currSplitIndex = -1;
        }

        /// <summary>
        /// Verifica errori prelimionari per mostrare dove sia il problema
        /// </summary>
        private void checkErrorPre()
        {
            // verifico 1:1 le liste e indico cosa manca
            if (ListPayload.Hardware == null || ListPayload.Hardware.Count == 0)
            {
                listErrPre.Add("Hardware", "Missing Hardware List!");
            }
            else
            {
                if (ListPayload.FamilyHardware == null || ListPayload.FamilyHardware.Count == 0)
                {
                    listErrPre.Add("FamilyHardware", "Missing Family HW List!");
                }
            }
            if (ListPayload.Glass == null || ListPayload.Glass.Count == 0)
            {
                listErrPre.Add("Glass", "Missing Glass List!");
            }
            if (ListPayload.Material == null || ListPayload.Material.Count == 0)
            {
                listErrPre.Add("Material", "Missing Material List!");
            }
            if (ListPayload.ColorMaterial == null || ListPayload.ColorMaterial.Count == 0)
            {
                listErrPre.Add("ColorMaterial", "Missing ColorMaterial List!");
            }
            if (ListPayload.Profile == null || ListPayload.Profile.Count == 0)
            {
                listErrPre.Add("Profile", "Missing Profile List!");
            }
        }

        /// <summary>
        /// Verifica warning minori (es coerenza colori...)
        /// </summary>
        private void checkWarnings()
        {
            // verifico 1:1 le liste e i valori siano coerenti...
            if (ListPayload.ColorMaterial != null && ListPayload.ColorMaterial.Count > 0)
            {
                // verifico colore attuale sia consistente...
                if (m_CurrWindow != null)
                {
                    if (!ListPayload.ColorMaterial.Contains(m_CurrWindow.sColorMaterial))
                    {
                        listWarnings.Add("ColorMaterial", $"Missing Color: {m_CurrWindow.sColorMaterial}");
                    }
                    if (!ListPayload.Glass.Contains(m_CurrWindow.sGlass))
                    {
                        listWarnings.Add("Glass", $"Missing Glass: {m_CurrWindow.sGlass}");
                    }
                    if (!ListPayload.Material.Contains(m_CurrWindow.sMaterial))
                    {
                        listWarnings.Add("Material", $"Missing Material: {m_CurrWindow.sMaterial}");
                    }
                    if (!ListPayload.Profile.Contains(m_CurrWindow.sProfilePath))
                    {
                        listWarnings.Add("Profile", $"Missing Profile: {m_CurrWindow.sProfilePath}");
                    }
                }
            }
        }

        /// <summary>
        /// Helper aggiunta elemento a lista caricamento
        /// </summary>
        /// <param name="loadCode"></param>
        private void loadListAdd(string loadCode)
        {
            if (!currLoading.Contains(loadCode))
            {
                currLoading.Add(loadCode);
            }
        }

        /// <summary>
        /// Helper rimozione elemento a lista caricamento
        /// </summary>
        /// <param name="loadCode"></param>
        private void loadListRem(string loadCode)
        {
            if (currLoading.Contains(loadCode))
            {
                currLoading.Remove(loadCode);
            }
        }

        /// <summary>
        /// Metodo per cambiare step
        /// </summary>
        /// <param name="newStep"> step successivo </param>
        private void NextStep(CompileStep newStep, int Index = 1)
        {
            editLock = true;
            currStep = newStep;
            switch (newStep)
            {
                case CompileStep.Sash:
                    {
                        currSashIndex = Index;
                        currFillIndex = -1;
                        currSplitIndex = -1;
                        break;
                    }
                case CompileStep.Fill:
                    {
                        currFillIndex = Index;
                        currSashIndex = -1;
                        currSplitIndex = -1;
                        break;
                    }
                case CompileStep.Split:
                    {
                        currSplitIndex = Index;
                        currSashIndex = -1;
                        currFillIndex = -1;
                        break;
                    }
            }
        }

        /// <summary>
        /// Metodo per cambiare step
        /// </summary>
        /// <param name="Args"></param>
        private void NextStepArgs(DataNextStep Args)
        {
            CompileStep newStep = Args.currCompileStep;
            int Index = Args.index;
            NextStep(newStep, Index);
        }

        /// <summary>
        /// Richiesta reset dizionario Shape con action
        /// </summary>
        /// <param name="args"></param>
        private async Task ReqResetDict(DataUpdateRes args)
        {
            await EC_ActionReq.InvokeAsync(args.req);
        }

        /// <summary>
        /// Ritorno step Tree
        /// </summary>
        /// <param name="args"></param>
        private void ReturnTree(bool args)
        {
            AdvStep(CompileStep.Tree);
        }

        private Area SearchArea(Area currentArea, int idSearch, Area itemSearch)
        {
            if (currentArea.GroupId == idSearch && currentArea.AreaType.Equals(itemSearch.AreaType))
            {
                return currentArea;
            }
            foreach (Area child in currentArea.AreaList)
            {
                Area found = SearchArea(child, idSearch, itemSearch);
                if (found != null)
                {
                    return found;
                }
            }
            return null;
        }

        /// <summary>
        /// Calcola il css del tab selezionato
        /// </summary>
        /// <param name="testStep"> Step </param>
        /// <returns></returns>
        private string tabNavCss(CompileStep testStep, int Index = -1)
        {
            if (testStep == CompileStep.Sash)
            {
                if ((currSashIndex == 0 && Index == 0) || (currSashIndex == 1 && Index == 1))
                    return "nav-link active fw-bold";
                else
                    return "nav-link text-secondary";
            }
            else if (testStep == CompileStep.Fill)
            {
                if ((currFillIndex == 0 && Index == 0) || (currFillIndex == 1 && Index == 1))
                    return "nav-link active fw-bold";
                else
                    return "nav-link text-secondary";
            }
            else if (testStep == CompileStep.Split)
            {
                if ((currSplitIndex == 0 && Index == 0) || (currSplitIndex == 1 && Index == 1))
                    return "nav-link active fw-bold";
                else
                    return "nav-link text-secondary";
            }
            return (testStep == currStep) ? "nav-link active fw-bold" : "nav-link text-secondary";
        }

        /// <summary>
        /// Metodo per cambiare tutti i Fill e richiedere aggiornamento SVG
        /// </summary>
        /// <param name="reqFillType"> tipo di fill richiesto </param>
        /// <returns></returns>
        protected async Task ChangeAllFill(FillTypes reqFillType)
        {
            updateAllFill(FrameWindow, reqFillType);
            await DoPreviewSvg();
        }

        /// <summary>
        /// Metodo per aggiornare tutti i Fill al nuovo tipo
        /// </summary>
        /// <param name="area"> area corrente</param>
        /// <param name="type"> tipo a cui aggiornare</param>
        private void updateAllFill(Area area, FillTypes type)
        {
            if (area.AreaType.Equals(AreaTypes.FILL))
            {
                Fill fill = (Fill)area;
                fill.SetSelFillType(type);
                return;
            }
            foreach (Area child in area.AreaList)
            {
                updateAllFill(child, type);
            }
        }

        /// <summary>
        /// Aggiornamento Fill
        /// </summary>
        /// <param name="newFill"> Fill da aggiornare</param>
        /// <returns></returns>
        private async Task UpdatePreviewFill(Fill newFill)
        {
            if (newFill != null)
            {
                // cerco il record
                var currRec = (Fill)SearchArea(FrameWindow, newFill.GroupId, newFill);
                // lo aggiorno
                currRec = newFill;
                await DoPreviewSvg();
            }
        }

        /// <summary>
        /// Aggiornamento Frame
        /// </summary>
        /// <param name="newFrame"> nuovo frame</param>
        /// <returns></returns>
        private async Task UpdatePreviewFrame(DataUpdateFrame args)
        {
            Frame newFrame = args.currFrame;
            bool forceSvgNoHw = args.svgNoHw;
            if (newFrame != null)
            {
                // cerco il record
                var currRec = m_CurrWindow.AreaList.FirstOrDefault(x => x.GroupId == newFrame.GroupId);
                // lo aggiorno
                currRec = newFrame;
                if (forceSvgNoHw)
                    await DoPreviewSvg(true, true);
                else
                    await DoPreviewSvg();
            }
        }

        /// <summary>
        /// Aggiornamento opzioni dato nuovo frame
        /// </summary>
        /// <param name="newFrame"> nuovo frame </param>
        /// <returns></returns>
        private async Task UpdateHwOptionsFrame(Frame newFrame)
        {
            if (newFrame != null)
            {
                // cerco il record
                var currRec = m_CurrWindow.AreaList.FirstOrDefault(x => x.GroupId == newFrame.GroupId);
                // lo aggiorno
                currRec = newFrame;
                // resetto hw lst
                await EC_ActionReq.InvokeAsync(DataAction.ResetHwOpt);
                reqHwOpt++;
                if (prevReq == (int)DataReq.ReqShape)
                {
                    // richiesta calcolo opzioni hardware per la singola sash group
                    List<int> reqList = SashList.Select(x => x.GroupId).ToList();
                    // chiamo con gruppo della nuova sash
                    await DoReqOptHardware(reqList);
                }
            }
        }

        /// <summary>
        /// Aggiornamento opzioni data nuova sash group
        /// </summary>
        /// <param name="newSash"> nuovo frame </param>
        /// <returns></returns>
        private async Task UpdateHwOptionsSash(Sash newSash)
        {
            if (newSash != null)
            {
                // cerco il record
                var currRec = SearchArea(FrameWindow, newSash.GroupId, newSash);
                // lo aggiorno
                currRec = newSash;
                // resetto hw lst
                await EC_ActionReq.InvokeAsync(DataAction.ResetHwOpt);
                //reqHwOpt++;
                //if(prevReq == (int)DataReq.ReqShape)
                //{
                // richiesta calcolo opzioni hardware per la singola sash group
                List<int> reqList = SashList.Select(x => x.GroupId).ToList();
                // chiamo con gruppo della nuova sash
                await DoReqOptHardware(reqList);
                //}
            }
        }

        /// <summary>
        /// Richiesta opzioni hardware per la prima volta
        /// </summary>
        /// <param name="newSash"> nuovo frame </param>
        /// <returns></returns>
        private async Task ReqFirstOptionHw(Sash newSash)
        {
            if (newSash != null)
            {
                // cerco il record
                var currRec = SearchArea(FrameWindow, newSash.GroupId, newSash);
                // lo aggiorno
                currRec = newSash;
                // resetto hw lst
                await EC_ActionReq.InvokeAsync(DataAction.ResetHwOpt);
                // richiesta calcolo opzioni hardware per la singola sash group
                List<int> reqList = SashList.Select(x => x.GroupId).ToList();
                // chiamo con gruppo della nuova sash
                await DoReqOptHardware(reqList);
            }
        }

        /// <summary>
        /// Aggiornamento Frame
        /// </summary>
        /// <param name="newFrame"> nuovo frame</param>
        /// <returns></returns>
        private async Task UpdatePreviewSplit(DataUpdateSplit args)
        {
            Split newSplit = args.currSplit;
            bool forceSvgNoHw = args.svgNoHw;
            bool noSvg = args.noSvg;
            if (newSplit != null)
            {
                // cerco il record
                var currRec = SearchArea(FrameWindow, newSplit.GroupId, newSplit);
                // lo aggiorno
                currRec = newSplit;
                if (!noSvg)
                {
                    if (forceSvgNoHw)
                        await DoPreviewSvg(true, true);
                    else
                        await DoPreviewSvg();
                }
            }
        }

        /// <summary>
        /// Metodo per aggiornare Splitted
        /// </summary>
        /// <param name="currSplitted"> Splitted da aggiornare</param>
        /// <returns></returns>
        private async Task UpdatePreviewSplitted(Splitted currSplitted)
        {
            if (currSplitted != null)
            {
                var item = SearchArea(FrameWindow, currSplitted.GroupId, currSplitted);
                item = currSplitted;
                // ricalcolo liste
                UpdateLists();
                // richiedo update shape
                List<int> reqList = SashList.Select(x => x.GroupId).ToList();
                await DoPreviewSvg();
                await DoReqShape(reqList);
            }

        }

        /// <summary>
        /// Aggiornamento opzioni dato update sash
        /// </summary>
        /// <param name="newSash"> nuova sash </param>
        /// <returns></returns>
        private async Task UpdatePreviewSashGroup(DataUpdateSash args)
        {
            Sash newSash = args.currSash;
            bool svgNoHw = args.svgNoHw;
            bool noSvg = args.noSvg;
            if (svgNoHw)
            {
                Sash item = (Sash)SearchArea(FrameWindow, newSash.GroupId, newSash);
                if (newSash != null && item != null)
                {
                    item = newSash;
                    await DoPreviewSvg(true, true);
                }
            }
            else
            {
                Sash item = (Sash)SearchArea(FrameWindow, newSash.GroupId, newSash);
                if (newSash != null && item != null)
                {
                    item = newSash;
                    if (!noSvg)
                        await DoPreviewSvg();
                }
            }
        }

        /// <summary>
        /// Calcola bottone per tutti i Fill
        /// </summary>
        /// <returns></returns>
        private string buttonFillCss(FillTypes reqFillTypes)
        {
            foreach (var fill in FillList)
            {
                if (!fill.FillType.Equals(reqFillTypes))
                    return "btn btn-outline-secondary btn-sm";
            }
            return "btn btn-secondary btn-sm";
        }

        #endregion Private Methods
    }
}