using Egw.Window.Data;
using EgwCoreLib.Lux.Core;
using EgwCoreLib.Lux.Core.RestPayload;
using EgwCoreLib.Lux.Data.Services;
using Microsoft.AspNetCore.Components;
using Newtonsoft.Json;
using WebWindowComplex;
using WebWindowComplex.DTO;
using static WebWindowComplex.LayoutConst;

namespace Test.UI.Components.Pages
{
    public partial class TestError
    {

        #region Public Fields

        public string InitialJwd = "";

        #endregion Public Fields

        #region Public Methods

        public void Dispose()
        {
            DLService.PipeSvg.EA_NewMessage -= PipeSvg_EA_NewMessage;
            DLService.PipeShape.EA_NewMessage -= PipeShape_EA_NewMessage;
            DLService.PipeHwOpt.EA_NewMessage -= PipeHwOption_EA_NewMessage;
            DLService.PipeProfElement.EA_NewMessage -= PipeProfElement_EA_NewMessage;
        }

        #endregion Public Methods

        #region Protected Fields

        /// <summary>
        /// Predisposizione valori live SVG/JWD
        /// </summary>
        protected LivePayload CurrData = new LivePayload();

        /// <summary>
        /// Livello di accesso
        /// -- true: utente base (versione semplificata)
        /// -- false: utente avanzato (versione completa)
        /// </summary>
        protected bool User = false;

        protected Dictionary<int, string> currGroupShape = new Dictionary<int, string>();
        protected List<AreaProfiles> currElement = new List<AreaProfiles>();
        protected Dictionary<int, string> currHwOption = new Dictionary<int, string>();
        protected string currJwd = "...";
        protected Dictionary<string, string> m_CurrArgs = new Dictionary<string, string>();
        protected string prevJwd = "";

        /// <summary>
        /// Configurazione elenchi anagrafiche
        /// </summary>
        protected BaseListPayload SetupList = new BaseListPayload();

        #endregion Protected Fields

        #region Protected Properties

        protected List<string> AvailColorMaterialList { get; set; } = new List<string>()
        {
            new string("White"),
            new string("Black"),
            new string("Blu"),
            new string("Wood")
        };

        protected List<string> AvailFamilyHardwareList { get; set; } = new List<string>()
        {
            new string("ArTech"),
            new string("ArTechPlana")
        };

        protected List<string> AvailGlassList { get; set; } = new List<string>()
        {
            new string("Vetro BE 2S 4/12/4"),
            new string("Vetro BE 2S 4/16/4"),
            new string("Vetro BE 3S 4/12/4/12/4"),
            new string("Vetro BE 3S 4/16/4/16/4"),
            new string("Vetro BE 2S 4T/12/4T"),
            new string("Vetro BE 2S 4T/16/4T")
        };

        protected List<Hardware> AvailHardwareList { get; set; } = new List<Hardware>();

        protected List<string> AvailMaterialList { get; set; } = new List<string>()
        {
            new string("Pino"),
            new string("Abete")
        };

        /// <summary>
        /// Lista profili da DB
        /// </summary>
        private List<ProfilePayload> AvailProfileList = new List<ProfilePayload>();


        private List<Threshold> ThresholdProfilo78 = new List<Threshold>()
        {
            { new Threshold(3, "Bottom") },
            { new Threshold(1, "Threshold") }
        };

        private List<Threshold> ThresholdProfiloSaomad = new List<Threshold>()
        {
            { new Threshold(3, "Bottom") },
            { new Threshold(2, "BottomWaterdrip") },
            { new Threshold(1, "Threshold") }
        };

        private Dictionary<string, double> ParamProfilo78 = new Dictionary<string, double>()
        {
            {"Frame_Fill_Rail_DimMax", 85},
            {"Frame_Fill_Rail_DimMin", 70},
            {"Frame_Fill_Rail_DimStd", 72},
            {"Frame_Fixed_Bottom_DimMax", 80},
            {"Frame_Fixed_Bottom_DimMin", 70},
            {"Frame_Fixed_Bottom_DimStd", 78},
            {"Frame_Fixed_Top_DimMax", 80},
            {"Frame_Fixed_Top_DimMin", 70},
            {"Frame_Fixed_Top_DimStd", 78},
            {"Frame_Frame_Split_DimMax", 85},
            {"Frame_Frame_Split_DimMin", 55},
            {"Frame_Frame_Split_DimStd", 60},
            {"Frame_Mixed_Bottom_DimMax", 80},
            {"Frame_Mixed_Bottom_DimMin", 70},
            {"Frame_Mixed_Bottom_DimStd", 78},
            {"Frame_Mixed_Split_DimMax", 110},
            {"Frame_Mixed_Split_DimMin", 70},
            {"Frame_Mixed_Split_DimStd", 90},
            {"Frame_Mixed_Top_DimMax", 80},
            {"Frame_Mixed_Top_DimMin", 70},
            {"Frame_Mixed_Top_DimStd", 78},
            {"Frame_Rail_Bottom_DimMax", 80},
            {"Frame_Rail_Bottom_DimMin", 70},
            {"Frame_Rail_Bottom_DimStd", 78},
            {"Frame_Rail_DimMax", 78},
            {"Frame_Rail_DimMin", 68},
            {"Frame_Rail_DimStd", 72},
            {"Frame_Sash_Bottom_DimMax", 80},
            {"Frame_Sash_Bottom_DimMin", 70},
            {"Frame_Sash_Bottom_DimStd", 78},
            {"Frame_Sash_Horizontal_DimMax", 110},
            {"Frame_Sash_Horizontal_DimMin", 75},
            {"Frame_Sash_Horizontal_DimStd", 95},
            {"Frame_Sash_Threshold_DimMax", 26},
            {"Frame_Sash_Threshold_DimMin", 24},
            {"Frame_Sash_Threshold_DimStd", 25},
            {"Frame_Sash_Top_DimMax", 80},
            {"Frame_Sash_Top_DimMin", 70},
            {"Frame_Sash_Top_DimStd", 78},
            {"Frame_Sash_Vertical_DimMax", 110},
            {"Frame_Sash_Vertical_DimMin", 85},
            {"Frame_Sash_Vertical_DimStd", 95},
            {"Frame_Slide_Bottom_DimMax", 60},
            {"Frame_Slide_Bottom_DimMin", 50},
            {"Frame_Slide_Bottom_DimStd", 55},
            {"Frame_Slide_Fixed_DimMax", 60},
            {"Frame_Slide_Fixed_DimMin", 50},
            {"Frame_Slide_Fixed_DimStd", 55},
            {"Frame_Slide_MovableBack_Bottom_DimMax", 60},
            {"Frame_Slide_MovableBack_Bottom_DimMin", 50},
            {"Frame_Slide_MovableBack_Bottom_DimStd", 55},
            {"Frame_Slide_MovableBack_Threshold_DimMax", 10},
            {"Frame_Slide_MovableBack_Threshold_DimMin", 3},
            {"Frame_Slide_MovableBack_Threshold_DimStd", 4},
            {"Frame_Slide_Movable_DimMax", 60},
            {"Frame_Slide_Movable_DimMin", 50},
            {"Frame_Slide_Movable_DimStd", 55},
            {"Frame_Slide_Threshold_DimMax", 10},
            {"Frame_Slide_Threshold_DimMin", 3},
            {"Frame_Slide_Threshold_DimStd", 4},
            {"Frame_Slide_Top_DimMax", 60},
            {"Frame_Slide_Top_DimMin", 50},
            {"Frame_Slide_Top_DimStd", 55},
            {"Sash_Fill_Rail_DimMax", 80},
            {"Sash_Fill_Rail_DimMin", 70},
            {"Sash_Fill_Rail_DimStd", 78},
            {"Sash_Frame_Bottom_DimMax", 80},
            {"Sash_Frame_Bottom_DimMin", 70},
            {"Sash_Frame_Bottom_DimStd", 78},
            {"Sash_Frame_Top_DimMax", 80},
            {"Sash_Frame_Top_DimMin", 70},
            {"Sash_Frame_Top_DimStd", 78},
            {"Sash_French_In_DimMax", 80},
            {"Sash_French_In_DimMin", 70},
            {"Sash_French_In_DimStd", 78},
            {"Sash_French_Out_DimMax", 80},
            {"Sash_French_Out_DimMin", 70},
            {"Sash_French_Out_DimStd", 78},
            {"Sash_Rail_Bottom_DimMax", 80},
            {"Sash_Rail_Bottom_DimMin", 70},
            {"Sash_Rail_Bottom_DimStd", 78},
            {"Sash_Rail_DimMax", 80},
            {"Sash_Rail_DimMin", 70},
            {"Sash_Rail_DimStd", 78},
            {"Sash_Sash_Active_DimMax", 80},
            {"Sash_Sash_Active_DimMin", 70},
            {"Sash_Sash_Active_DimStd", 78},
            {"Sash_Sash_Inactive_DimMax", 80},
            {"Sash_Sash_Inactive_DimMin", 70},
            {"Sash_Sash_Inactive_DimStd", 78},
            {"Sash_Sash_Split_DimMax", 70},
            {"Sash_Sash_Split_DimMin", 50},
            {"Sash_Sash_Split_DimStd", 60},
            {"Sash_Slide_Active_DimMax", 90},
            {"Sash_Slide_Active_DimMin", 70},
            {"Sash_Slide_Active_DimStd", 80},
            {"Sash_Slide_Active_In_DimMax", 90},
            {"Sash_Slide_Active_In_DimMin", 70},
            {"Sash_Slide_Active_In_DimStd", 80},
            {"Sash_Slide_Fixed_Bottom_DimMax", 150},
            {"Sash_Slide_Fixed_Bottom_DimMin", 120},
            {"Sash_Slide_Fixed_Bottom_DimStd", 135},
            {"Sash_Slide_Fixed_Side_DimMax", 90},
            {"Sash_Slide_Fixed_Side_DimMin", 70},
            {"Sash_Slide_Fixed_Side_DimStd", 80},
            {"Sash_Slide_Fixed_Top_DimMax", 90},
            {"Sash_Slide_Fixed_Top_DimMin", 70},
            {"Sash_Slide_Fixed_Top_DimStd", 80},
            {"Sash_Slide_Inactive_DimMax", 90},
            {"Sash_Slide_Inactive_DimMin", 70},
            {"Sash_Slide_Inactive_DimStd", 80},
            {"Sash_Slide_MovableBack_Bottom_DimMax", 150},
            {"Sash_Slide_MovableBack_Bottom_DimMin", 120},
            {"Sash_Slide_MovableBack_Bottom_DimStd", 135},
            {"Sash_Slide_MovableBack_Side_DimMax", 90},
            {"Sash_Slide_MovableBack_Side_DimMin", 70},
            {"Sash_Slide_MovableBack_Side_DimStd", 80},
            {"Sash_Slide_MovableBack_Top_DimMax", 90},
            {"Sash_Slide_MovableBack_Top_DimMin", 70},
            {"Sash_Slide_MovableBack_Top_DimStd", 80},
            {"Sash_Slide_Movable_Bottom_DimMax", 150},
            {"Sash_Slide_Movable_Bottom_DimMin", 120},
            {"Sash_Slide_Movable_Bottom_DimStd", 135},
            {"Sash_Slide_Movable_Side_DimMax", 90},
            {"Sash_Slide_Movable_Side_DimMin", 70},
            {"Sash_Slide_Movable_Side_DimStd", 80},
            {"Sash_Slide_Movable_Top_DimMax", 90},
            {"Sash_Slide_Movable_Top_DimMin", 70},
            {"Sash_Slide_Movable_Top_DimStd", 80},
            {"Frame_BottomRail_Overlap", 33.2},
            {"French_In_Overlap", 26},
            {"French_Out_Overlap", 26},
            {"Mixed_Bottom_Overlap", 26},
            {"Mixed_Split_Bottom_Overlap", 41},
            {"Mixed_Split_Top_Overlap", 41},
            {"Mixed_Top_Overlap", 41},
            {"NO_Mixed_Bottom_Overlap", 26},
            {"NO_Mixed_Split_Bottom_Overlap", 41},
            {"NO_Mixed_Split_Top_Overlap", 41},
            {"NO_Slide_MovableBack_Threshold_Overlap", 0},
            {"NO_Slide_Threshold_Overlap", 0},
            {"Sash_Active_Overlap", 26},
            {"Sash_Inactive_Overlap", 26},
            {"Sash_BottomRail_Overlap", 24.5},
            {"Sash_Bottom_Overlap", 26},
            {"Sash_Horizontal_Bottom_Overlap", 26},
            {"Sash_Horizontal_Top_Overlap", 41},
            {"Sash_Threshold_Overlap", 18},
            {"Sash_Top_Overlap", 41},
            {"Sash_Vertical_Overlap", 41},
            {"Slide_Active_Overlap", 80},
            {"Slide_Bottom_Overlap", 0},
            {"Slide_Fixed_Overlap", -5},
            {"Slide_MovableBack_Bottom_Overlap", 0},
            {"Slide_MovableBack_Threshold_Overlap", 0},
            {"Slide_Movable_Overlap", -5},
            {"Slide_Threshold_Overlap", 0},
            {"Slide_Top_Overlap", -12}
        };

        private Dictionary<string, double> ParamProfiloSaomad = new Dictionary<string, double>()
        {
            {"Frame_Frame_Split_DimMax", 85},
            {"Frame_Frame_Split_DimMin", 55},
            {"Frame_Frame_Split_DimStd", 60},
            {"Frame_Mixed_Bottom_DimMax", 80},
            {"Frame_Mixed_Bottom_DimMin", 70},
            {"Frame_Mixed_Bottom_DimStd", 78},
            {"Frame_Mixed_Split_DimMax", 110},
            {"Frame_Mixed_Split_DimMin", 70},
            {"Frame_Mixed_Split_DimStd", 90},
            {"Frame_Mixed_Top_DimMax", 80},
            {"Frame_Mixed_Top_DimMin", 70},
            {"Frame_Mixed_Top_DimStd", 78},
            {"Frame_Rail_Bottom_DimMax", 80}
        };

        [Inject]
        protected IConfiguration Config { get; set; } = null!;

        [Inject]
        protected DataLayerServices DLService { get; set; } = null!;

        [Inject]
        protected ImageCacheService ICService { get; set; } = null!;

        protected MarkupString JsonSer
        {
            get => (MarkupString)currJwd.Replace(Environment.NewLine, "<br/>").Replace(" ", "&nbsp;");
        }

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

        #endregion Protected Properties

        #region Protected Methods

        protected override void OnAfterRender(bool firstRender)
        {
            if (firstRender)
            {
                // JS interop or data fetches go here
                isInteractive = true;
            }
        }

        protected override async Task OnInitializedAsync()
        {
            ConfInit();
            User = false;
            Random random = new Random();
            CalcUid = Convert.ToString(random.Next(1000, 10000));
            windowUid = CalcUid;
            //initialJwd = File.ReadAllText("Data\\AntaDoppiaInglesine.jwd");
            InitialJwd = File.ReadAllText("Data\\AntaDoppia.jwd");
            currJwd = InitialJwd;
            // rileggo altri dati
            await ReloadData();
            // costruisco lista profili
            ProfilePayload pp1 = new ProfilePayload()
            {
                ProfileName = "Profilo78",
                ThresholdList = ThresholdProfilo78,
                ParameterDict = ParamProfilo78
            };
            ProfilePayload pp2 = new ProfilePayload()
            {
                ProfileName = "ProfiloSaomad",
                ThresholdList = ThresholdProfiloSaomad,
                ParameterDict = ParamProfiloSaomad
            };
            AvailProfileList = new List<ProfilePayload> { pp1, pp2 };
            // preparo conf oggetti x controllo
            SetupList = new BaseListPayload()
            {
                ColorMaterial = AvailColorMaterialList,
                FamilyHardware = AvailFamilyHardwareList,
                Glass = AvailGlassList,
                Hardware = AvailHardwareList,
                Wood = AvailMaterialList,
                ProfileList = AvailProfileList
            };
            CurrData = new LivePayload()
            {
                CurrJwd = InitialJwd,
                SvgPreview = currSvg,
                DictShape = currGroupShape,
                DictOptionsXml = currHwOption
            };
            DLService.PipeSvg.EA_NewMessage += PipeSvg_EA_NewMessage;
            DLService.PipeShape.EA_NewMessage += PipeShape_EA_NewMessage;
            DLService.PipeHwOpt.EA_NewMessage += PipeHwOption_EA_NewMessage;
            DLService.PipeProfElement.EA_NewMessage += PipeProfElement_EA_NewMessage;
        }

        #endregion Protected Methods

        #region Private Fields

        private string apiUrl = "";
        private string calcTag = "";
        private string CalcUid = "CurrWindow";
        private string windowUid = "CurrWindow";
        private string cFileHardware = "Hardware/Setup.json";
        private string currSvg = "";
        private string GenericBasePath = "";

        //private string colorMassUpdate;
        //private string familyHWMassUpdate;
        //private string glassMassUpdate;
        //private Hardware hardwareMassUpdate;
        //private string materialMassUpdate;
        //private string profileMassUpdate;

        /// <summary>
        /// Semaforo x definire se sia già in modalità ionterattiva o di prerendering
        /// </summary>
        private bool isInteractive = false;

        private string outClose = "";
        private string outSave = "";

        private string imgBasePath = "";

        private string channelHwOpt = "";
        private string channelShape = "";
        private string channelProfList = "";
        private string channelProfElem = "";
        private string channelSvg = "";


        #endregion Private Fields

        #region Private Methods

        /// <summary>
        /// Effettua chiusura oggetto con eventuale save
        /// </summary>
        /// <param name="reqSave"></param>
        private void CloseObj(DataSave reqSave)
        {
            currJwd = reqSave.currJwd;
            outClose = !reqSave.ForceSave ? "Richiesto chiusura!" : "";
            outSave = reqSave.ForceSave ? "Richiesto salvataggio!" : "";
        }

        private void ConfInit()
        {
            apiUrl = Config.GetValue<string>("ServerConf:Prog.ApiUrl") ?? "";
            imgBasePath = Config.GetValue<string>("ServerConf:ImageBaseUrl") ?? "";
            GenericBasePath = Config.GetValue<string>("ServerConf:GenericBaseUrl") ?? "";
            calcTag = Config.GetValue<string>("ServerConf:CalcTag") ?? "";
            channelSvg = Config.GetValue<string>("ServerConf:ChannelSvg") ?? "";
            channelShape = Config.GetValue<string>("ServerConf:ChannelShape") ?? "";
            channelHwOpt = Config.GetValue<string>("ServerConf:ChannelHwOpt") ?? "";
            channelProfElem = Config.GetValue<string>("ServerConf:ChannelProfElem") ?? "";
            channelProfList = Config.GetValue<string>("ServerConf:ChannelProfList") ?? "";
        }

        /// <summary>
        /// Esecuzione azione richiesta
        /// </summary>
        /// <param name="actReq">Azione richiesta</param>
        private void DoAction(DataAction actReq)
        {
            switch (actReq)
            {
                case DataAction.None:
                    break;

                case DataAction.ResetDictShape:
                    CurrData.DictShape = new Dictionary<int, string>();
                    break;

                case DataAction.ResetHwOpt:
                    CurrData.DictOptionsXml = new Dictionary<int, string>();
                    break;

                case DataAction.ResetDimElem:
                    CurrData.ProfElementList = new List<AreaProfiles>();
                    break;

                default:
                    break;
            }
        }

        /// <summary>
        /// Esecuzione richiesta
        /// </summary>
        /// <param name="CurrArgs"></param>
        /// <returns></returns>
        private async Task ExecRequest(Dictionary<string, string> CurrArgs)
        {
            // Proseguo solo se sono in interattivo (NO prerender pagina)
            if (isInteractive)
            {
                outClose = "";
                outSave = "";
                // verifico se contiene JWD, lo aggiorno
                if (CurrArgs.ContainsKey("SerializedData"))
                {
                    currJwd = CurrArgs["SerializedData"];
                    CurrData.CurrJwd = currJwd;
                }
                // se il SSE variato --> invio
                if (!currJwd.Equals(prevJwd) || !EgwCoreLib.Utils.DictUtils.DictAreEqual(m_CurrArgs, CurrArgs))
                {
                    m_CurrArgs = CurrArgs;
                    prevJwd = currJwd;
                    CalcRequestDTO calcRequestDTO = new CalcRequestDTO();
                    calcRequestDTO.EnvType = EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WINDOW;
                    calcRequestDTO.DictExec = m_CurrArgs;
                    // chiamo la chiamata POST alla API, che manda la richiesta via REDIS
                    await ICService.CallRestPost($"{apiUrl}/{GenericBasePath}", $"{calcTag}/{CalcUid}", calcRequestDTO);
                }
            }
        }

        private async void PipeHwOption_EA_NewMessage(object? sender, EventArgs e)
        {
            // aggiorno visualizzazione
            PubSubEventArgs currArgs = (PubSubEventArgs)e;
            // conversione on-the-fly SVG da mostrare
            if (!string.IsNullOrEmpty(currArgs.newMessage))
            {
                if (currArgs.msgUid.StartsWith($"{channelHwOpt}:{windowUid}") && currArgs.newMessage.Length > 2)
                {
                    // deserializzo il dizionario delle risposte...
                    Dictionary<int, string> rawDict = JsonConvert.DeserializeObject<Dictionary<int, string>>(currArgs.newMessage) ?? new Dictionary<int, string>();
                    if (rawDict.Count > 0)
                        currHwOption = rawDict;
                }
                else
                {
                    currHwOption = new Dictionary<int, string>();
                }
                CurrData.DictOptionsXml = currHwOption;
                await InvokeAsync(StateHasChanged);
            }
            await Task.Delay(1);
        }

        private async void PipeShape_EA_NewMessage(object? sender, EventArgs e)
        {
            // aggiorno visualizzazione
            PubSubEventArgs currArgs = (PubSubEventArgs)e;
            // conversione on-the-fly SVG da mostrare
            if (!string.IsNullOrEmpty(currArgs.newMessage) && currArgs.newMessage.Length > 2)
            {
                if (currArgs.msgUid.StartsWith($"{channelShape}:{windowUid}"))
                {
                    // deserializzo il dizionario delle risposte...
                    var rawDict = JsonConvert.DeserializeObject<Dictionary<int, string>>(currArgs.newMessage);
                    currGroupShape = rawDict ?? new Dictionary<int, string>();
                    CurrData.DictShape = currGroupShape;
                }
                await InvokeAsync(StateHasChanged);
            }
            await Task.Delay(1);
        }

        private async void PipeProfElement_EA_NewMessage(object? sender, EventArgs e)
        {
            // aggiorno visualizzazione
            PubSubEventArgs currArgs = (PubSubEventArgs)e;
            // conversione on-the-fly SVG da mostrare
            if (!string.IsNullOrEmpty(currArgs.newMessage) && currArgs.newMessage.Length > 2)
            {
                if (currArgs.msgUid.StartsWith($"{channelProfElem}:{windowUid}"))
                {
                    // deserializzo il dizionario delle risposte...
                    var rawDict = JsonConvert.DeserializeObject<List<AreaProfiles>>(currArgs.newMessage);
                    currElement = rawDict ?? new List<AreaProfiles>();
                    CurrData.ProfElementList = currElement;
                }
                await InvokeAsync(StateHasChanged);
            }
            await Task.Delay(1);
        }

        private async void PipeSvg_EA_NewMessage(object? sender, EventArgs e)
        {
            // aggiorno visualizzazione
            PubSubEventArgs currArgs = (PubSubEventArgs)e;
            // conversione on-the-fly SVG da mostrare
            if (!string.IsNullOrEmpty(currArgs.newMessage))
            {
                if (currArgs.msgUid.Equals($"{channelSvg}:{windowUid}"))
                {
                    currSvg = currArgs.newMessage;
                    CurrData.SvgPreview = currArgs.newMessage;
                }
                await InvokeAsync(StateHasChanged);
            }
            await Task.Delay(1);
        }

        /// <summary>
        /// Rilettura dati
        /// </summary>
        /// <returns></returns>
        private Task ReloadData()
        {
            AvailHardwareList = new List<Hardware>();
            if (File.Exists(cFileHardware))
            {
                string rawValHW = File.ReadAllText(cFileHardware);
                var rawListHW = JsonConvert.DeserializeObject<List<Hardware>>(rawValHW) ?? new List<Hardware>();
                foreach (var item in rawListHW)
                {
                    AvailHardwareList.Add(item);
                }
            }
            return Task.Delay(100);
        }

        private void updateInfoJwd(string currSer, string? newFamilyHardware, Hardware? newHardware, string? newColorMaterial, string? newMaterial, string? newGlass, string? newProfile)
        {
            Dictionary<string, string> DictParam = new Dictionary<string, string>();
            if (!string.IsNullOrEmpty(newFamilyHardware))
                DictParam.Add("FamilyHardware", newFamilyHardware!);
            if (!string.IsNullOrEmpty(newColorMaterial))
                DictParam.Add("Color", newColorMaterial!);
            if (!string.IsNullOrEmpty(newMaterial))
                DictParam.Add("Material", newMaterial!);
            if (!string.IsNullOrEmpty(newGlass))
                DictParam.Add("Glass", newGlass!);
            if (!string.IsNullOrEmpty(newProfile))
                DictParam.Add("Profile", newProfile!);
            var dp = SerialMan.MassUpdate(currSer, DictParam);
            CurrData.CurrJwd = dp.serializeStruct;
            //var newJwd = SerialMan.MassUpdate(currSer, shape, newFamilyHardware, newHardware, newColorMaterial, newMaterial, newGlass, newProfile);
            //CurrData.CurrJwd = newJwd;
        }

        private void RemoveParams(Microsoft.AspNetCore.Components.Web.MouseEventArgs args)
        {
            SetupList = new BaseListPayload();
        }
        private Task RemoveJwd()
        {
            //initialJwd = "{}";
            //currJwd = initialJwd;
            CurrData.CurrJwd = "{}";
            // rileggo altri dati
            return ReloadData();
        }
        #endregion Private Methods
    }
}