using Egw.Window.Data;
using EgwCoreLib.Razor;
using Newtonsoft.Json;
using WebWindowComplex;
using WebWindowComplex.DTO;
using static EgwCoreLib.Lux.Core.Enums;
using static WebWindowComplex.LayoutConst;

namespace Lux.UI.Components.Compo.Offer
{
    public partial class OfferRowMan : IDisposable
    {
        #region Public Properties

        [Parameter]
        public OfferModel CurrRecord { get; set; } = default!;

        [Parameter]
        public DisplayMode DisplayMode { get; set; } = DisplayMode.Standard;

        [Parameter]
        public EventCallback<string> EC_Action { get; set; }

        [Parameter]
        public EventCallback<bool> EC_Updated { get; set; }

        #endregion Public Properties

        #region Public Methods

        /// <summary>
        /// Dispose sottoscrizione canale
        /// </summary>
        public void Dispose()
        {
            DLService.PipeUpdate.EA_NewMessage -= PipeUpdate_EA_NewMessage;
            DLService.PipePng.EA_NewMessage -= PipePng_EA_NewMessage;
            DLService.PipeSvg.EA_NewMessage -= PipeSvg_EA_NewMessage;
            DLService.PipeHwOpt.EA_NewMessage -= PipeHwOpt_EA_NewMessage;
            DLService.PipeProfElement.EA_NewMessage -= PipeProfElement_EA_NewMessage;
            DLService.PipeProfList.EA_NewMessage -= PipeProfList_EA_NewMessage;
            DLService.PipeShape.EA_NewMessage -= PipeShape_EA_NewMessage;
        }

        #endregion Public Methods

        #region Protected Methods

        /// <summary>
        /// Verifica after render x stato interattivo pagina
        /// </summary>
        /// <param name="firstRender"></param>
        protected override void OnAfterRender(bool firstRender)
        {
            if (firstRender)
            {
                // JS interop or data fetches go here
                isInteractive = true;
            }
        }

        /// <summary>
        /// init obj
        /// </summary>
        protected override async Task OnInitializedAsync()
        {
            ConfInit();
            prevJwd = "";
            await ReloadBaseList();
            DLService.PipeUpdate.EA_NewMessage += PipeUpdate_EA_NewMessage;
            DLService.PipePng.EA_NewMessage += PipePng_EA_NewMessage;
            DLService.PipeSvg.EA_NewMessage += PipeSvg_EA_NewMessage;
            DLService.PipeHwOpt.EA_NewMessage += PipeHwOpt_EA_NewMessage;
            DLService.PipeProfElement.EA_NewMessage += PipeProfElement_EA_NewMessage;
            DLService.PipeProfList.EA_NewMessage += PipeProfList_EA_NewMessage;
            DLService.PipeShape.EA_NewMessage += PipeShape_EA_NewMessage;
        }

        protected override async Task OnParametersSetAsync()
        {
            await ORService.FixImgTypeAsync(OfferID);
            await ReloadDataAsync();
            UpdateTable();
        }

        #endregion Protected Methods

        #region Private Fields

        private static Logger Log = LogManager.GetCurrentClassLogger();

        /// <summary>
        /// Boolean selezione prodotto da aggiungere (template)
        /// </summary>
        private bool addFromTemplate = false;

        private List<GenValueModel> AllColors = new();

        private List<EnvirParamModel> AllConfEnvir = new();

        private List<GlassModel> AllConfGlass = new();

        private List<HardwareModel> AllConfHardware = new();

        private List<WoodModel> AllConfWood = new();

        private List<OfferRowModel> AllRecords = new List<OfferRowModel>();

        private string apiUrl = "";

        private List<string> AvailColorMaterialList = new List<string>();

        private List<string> AvailFamilyHardwareList = new List<string>();

        private List<string> AvailGlassList = new List<string>();

        private List<Egw.Window.Data.Hardware> AvailHardwareList = new();

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

        /// <summary>
        /// Lista profili da Redis (old way)
        /// </summary>
        private List<string> AvailProfileListOld = new List<string>();

        private Dictionary<string, List<Threshold>> AvailThresholdDict = new Dictionary<string, List<Threshold>>();

        private List<string> AvailWoodList = new List<string>();

        /// <summary>
        /// Base path x network share files
        /// </summary>
        private string basePath = "unsafe_uploads";

        private string calcTag = "calc";

        private EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS cEnvir = EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WINDOW;

        /// <summary>
        /// Channel update HwOptions
        /// </summary>
        private string chHwOpt = "";

        /// <summary>
        /// Channel update PNG
        /// </summary>
        private string chPng = "";

        /// <summary>
        /// Channel update Profile List
        /// </summary>
        private string chProfElem = "";

        /// <summary>
        /// Channel update Profile List
        /// </summary>
        private string chProfList = "";

        /// <summary>
        /// Channel update Shape
        /// </summary>
        private string chShape = "";

        /// <summary>
        /// Channel update SVG
        /// </summary>
        private string chSvg = "";

        private List<AreaProfiles> currAreaProfiles = new();

        private List<BomItemDTO>? CurrBomList = null;

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

        /// <summary>
        /// Modalit� editint attiva
        /// </summary>
        private EditMode CurrEditMode = EditMode.None;

        private Dictionary<int, string> currGroupShape = new();

        private Dictionary<int, string> currHwOption = new();

        private int currPage = 1;

        /// <summary>
        /// Elenco delle richieste pensding da DB x RigaOfferta corrente
        /// </summary>
        private Dictionary<string, string> CurrPendReq = new();

        private string currPng = "";

        private List<ProfilePayload> currProfList = new();

        private string currSvg = "";

        /// <summary>
        /// Record in Edit corrente x modifica file/serializzato
        /// </summary>
        private OfferRowModel? EditRecord = null;

        /// <summary>
        /// Abilita edit massivo record ITEM
        /// </summary>
        private bool enableMassEdit = false;

        private string genericBasePath = "";

        private string imgBasePath = "";

        private bool isForceParamMode = false;

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

        private bool isLoading = false;

        private List<TemplateModel> ListAllCatalog = new();

        private List<TemplateModel> ListCataloghi = new();

        private List<OfferRowModel> ListRecords = new();

        private List<TemplateRowModel> ListTemplateAll = new();

        private int numRecord = 10;

        /// <summary>
        /// Versione originale (pre edit)
        /// </summary>
        private string origJwd = "";

        private List<string> PreparedFile = new();

        /// <summary>
        /// Versione precedente JWD x test e confronto
        /// </summary>
        private string prevJwd = "";

        /// <summary>
        /// Dizionario richieste
        /// </summary>
        private Dictionary<string, string> reqDict = new Dictionary<string, string>();

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

        private int totalCount = 0;

        private BootstrapModal Modal = new();
        private string mTitle = "";
        private string mMessage = "";
        private BootstrapModal.ModalMode mMode = BootstrapModal.ModalMode.ND;

        private Dictionary<bool, string> modalOpt = new Dictionary<bool, string>();

        #endregion Private Fields

        #region Private Properties

        private Dictionary<string, List<Threshold>> AvailThreshold { get; set; } = new Dictionary<string, List<Threshold>>()
        {
            {"Profilo78",  new List<Threshold>() { new Threshold(3, "Bottom")}},
            {"ProfiloSaomad",  new List<Threshold>(){ new Threshold(3, "Bottom")}}
#if false
            {"Profilo78",  new List<Threshold>() { new Threshold(3, "Bottom"), new Threshold(1, "Threshold")}},
            {"ProfiloSaomad",  new List<Threshold>(){ new Threshold(3, "Bottom"), new Threshold(2, "BottomWaterdrip"), new Threshold(1, "Threshold")}}
#endif
        };

        [Inject]
        private IConfigDataService CDService { get; set; } = default!;

        [Inject]
        private IConfGlassService CGService { get; set; } = null!;

        [Inject]
        private IConfiguration Config { get; set; } = default!;

        [Inject]
        private IConfProfileService CPService { get; set; } = null!;

        [Inject]
        private ICalcRuidService CRService { get; set; } = default!;

        [Inject]
        private ICalcRequestService CService { get; set; } = default!;

        [Inject]
        private IWebHostEnvironment CurrEnv { get; set; } = default!;

        [Inject]
        private IConfWoodService CWService { get; set; } = null!;

        [Inject]
        private IDataLayerServices DLService { get; set; } = default!;

        [Inject]
        private IEnvirParamService EPService { get; set; } = null!;

        [Inject]
        private IFileService FService { get; set; } = default!;

        /// <summary>
        /// Costo totale calcolato x offerta
        /// </summary>
        private double GrandTotCost
        {
            get => AllRecords != null && AllRecords.Count > 0 ? AllRecords.Sum(x => x.TotalCost) : 0;
        }

        /// <summary>
        /// Margine medio calcolato x offerta
        /// </summary>
        private double GrandTotMargin
        {
            get
            {
                double answ = 0;
                if (AllRecords != null && AllRecords.Count > 0)
                {
                    double totPrice = AllRecords.Sum(x => x.TotalPrice);
                    double totCost = AllRecords.Sum(x => x.TotalCost);
                    if (totPrice > 0)
                    {
                        answ = (totPrice - totCost) / totPrice;
                    }
                }
                return answ;
            }
        }

        /// <summary>
        /// Importo totale calcolato x offerta
        /// </summary>
        private double GrandTotNumItems
        {
            get
            {
                double answ = 0;
                if (AllRecords != null && AllRecords.Count > 0)
                {
                    answ = AllRecords.Sum(x => x.ProdItemQtyTot);
                }
                return answ;
            }
        }

        /// <summary>
        /// Importo totale calcolato x offerta
        /// </summary>
        private double GrandTotPrice
        {
            get => AllRecords != null && AllRecords.Count > 0 ? AllRecords.Sum(x => x.TotalPrice) : 0;
        }

        /// <summary>
        /// Num totale obj calcolato x offerta
        /// </summary>
        private double GrandTotQty
        {
            get => AllRecords != null && AllRecords.Count > 0 ? AllRecords.Sum(x => x.Qty) : 0;
        }

        [Inject]
        private IGenValService GVService { get; set; } = default!;

        [Inject]
        private IWebHostEnvironment HostEnv { get; set; } = default!;

        [Inject]
        private IImageCacheService ICService { get; set; } = default!;

        [Inject]
        private IItemService ItemService { get; set; } = null!;

        [Inject]
        private IJSRuntime JSRuntime { get; set; } = default!;

        private string noteCss => EditRecord == null ? "btn-success" : "btn-primary bg-gradient";

        /// <summary>
        /// ID Offerta corrente
        /// </summary>
        private int OfferID
        {
            get => CurrRecord.OfferID;
        }

        [Inject]
        private IOfferRowService ORService { get; set; } = default!;

        [Inject]
        private IOfferService OService { get; set; } = default!;

        [Inject]
        private ITemplateRowService TRService { get; set; } = default!;

        [Inject]
        private ITemplateService TService { get; set; } = default!;

        #endregion Private Properties

        #region Private Methods

        /// <summary>
        /// Effettua vera richiesta della BOM
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        private async Task callBomUpdate(OfferRowModel currRec)
        {
            // salvo richiesta BOM su record
            currRec.AwaitBom = true;
            currRec.AwaitPrice = true;
            await ORService.UpdateAwaitStateAsync(currRec.OfferRowID, true, true);

            // preparo la domanda serializzata
            Dictionary<string, string> DictExec = new Dictionary<string, string>();
            // verifico parametri da conf envir...
            var envRec = AllConfEnvir.FirstOrDefault(x => x.EnvirID == currRec.Envir);
            string serKey = envRec != null ? envRec.SerStrucKey : "SerializedData";
            // cablata la BOM
            DictExec.Add("Mode", $"{(int)Egw.Window.Data.Enums.QuestionModes.BOM}");
            // UID cablato x ora...
            DictExec.Add("UID", currRec.OfferRowUID);
            // aggiungo file secondo ambiente...
            switch (currRec.Envir)
            {
                case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WINDOW:
                    DictExec.Add(serKey, currRec.SerStruct);
                    break;

                case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.BEAM:
                case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WALL:
                case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.CABINET:
                    // rileggo da file...
                    string folderPath = FolderPath(currRec.OfferID);
                    string rawData = FService.LoadFileContent(folderPath, currRec.FileResource);
                    DictExec.Add(serKey, rawData);
                    DictExec.Add("FileName", currRec.FileName);
                    break;

                case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.NULL:
                default:
                    break;
            }

            CalcRequestDTO req = new CalcRequestDTO()
            {
                EnvType = currRec.Envir,
                DictExec = DictExec
            };

            await InvokeAsync(StateHasChanged);

            // chiamo la chiamata POST alla API, che manda la richiesta via REDIS
            await CService.CallRestPost($"{apiUrl}/{genericBasePath}", $"{calcTag}/{currRec.OfferRowUID}", req);
        }

        /// <summary>
        /// Effettua vera richiesta update IMG
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        private async Task callImgUpdate(OfferRowModel currRec)
        {
            // preparo la domanda serializzata
            Dictionary<string, string> DictExec = new Dictionary<string, string>();
            // verifico parametri da conf envir...
            var envRec = AllConfEnvir.FirstOrDefault(x => x.EnvirID == currRec.Envir);
            string serKey = envRec != null ? envRec.SerStrucKey : "SerializedData";
            // cablata la BOM
            DictExec.Add("Mode", $"{(int)Egw.Window.Data.Enums.QuestionModes.PREVIEW}");
            // UID cablato x ora...
            DictExec.Add("UID", currRec.OfferRowUID);
            // aggiungo file secondo ambiente...
            switch (currRec.Envir)
            {
                case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WINDOW:
                    DictExec.Add(serKey, currRec.SerStruct);
                    break;

                case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.BEAM:
                case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WALL:
                case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.CABINET:
                    // rileggo da file...
                    string folderPath = FolderPath(currRec.OfferID);
                    string rawData = FService.LoadFileContent(folderPath, currRec.FileResource);
                    DictExec.Add(serKey, rawData);
                    DictExec.Add("FileName", currRec.FileName);
                    break;

                case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.NULL:
                default:
                    break;
            }

            CalcRequestDTO req = new CalcRequestDTO()
            {
                EnvType = currRec.Envir,
                DictExec = DictExec
            };

            await InvokeAsync(StateHasChanged);

            // chiamo la chiamata POST alla API, che manda la richiesta via REDIS
            await CService.CallRestPost($"{apiUrl}/{genericBasePath}", $"{calcTag}/{currRec.OfferRowUID}", req);
        }

        /// <summary>
        /// Effettua vera richiesta della BOM
        /// </summary>
        /// <returns></returns>
        private async Task callRefreshProfList()
        {
            Dictionary<string, string> DictExec = new Dictionary<string, string>();
            var cMode = Egw.Window.Data.Enums.QuestionModes.CONFIG;
            var cSubMode = Egw.Window.Data.Enums.QuestionConfSubModes.PROFILELIST;
            // compongo righiesta
            string reqUid = "Default";
            DictExec.Add("Mode", $"{(int)cMode}");
            DictExec.Add("UID", reqUid);
            // creo registrazione richiesta...
            var ruid = await CRService.AddRequestAsync($"{cEnvir}", $"{cMode}-{cSubMode}", reqUid);
            // aggiungo RUID effettivo
            DictExec.Add("RUID", ruid);
            DictExec.Add("SubMode", $"{(int)cSubMode}");
            CalcRequestDTO req = new CalcRequestDTO()
            {
                EnvType = cEnvir,
                DictExec = DictExec
            };
            // chiamo la chiamata POST alla API, che manda la richiesta via REDIS
            await CService.CallRestPost($"{apiUrl}/{genericBasePath}", $"{calcTag}/{reqUid}", req);
        }

        /// <summary>
        /// Chiude edit andando eventualmente a salvare
        /// </summary>
        /// <param name="args"></param>
        /// <returns></returns>
        private async Task CloseEdit(bool doSave)
        {
            // Proseguo solo se sono in interattivo (NO prerender pagina)
            if (isInteractive)
            {
                // ...se ho editing
                if (EditRecord != null)
                {
                    bool updateBom = false;
                    // SE richiesto salvataggio...
                    if (doSave)
                    {
                        // salvo su DB!
                        await ORService.UpdateSerStructDirtyAsync(EditRecord.OfferRowID, prevJwd, CurrPendReq);
                        // salvo nel record corrente!
                        EditRecord.SerStruct = prevJwd;
                        updateBom = true;
                    }
                    else
                    // altrimenti ricalcolo valore salvato
                    {
                        prevJwd = EditRecord.SerStruct;
                        CurrData.CurrJwd = EditRecord.SerStruct;
                    }
                    if (updateBom)
                    {
                        await callBomUpdate(EditRecord);
                    }
                    // aggiorno nel dizionari
                    if (reqDict.ContainsKey("SerializedData"))
                    {
                        reqDict["SerializedData"] = prevJwd;
                    }

                    if (reqDict != null && reqDict.Count > 0)
                    {
                        // chiamo richiesta update
                        CalcRequestDTO calcRequestDTO = new CalcRequestDTO();
                        calcRequestDTO.EnvType = EditRecord.Envir;
                        calcRequestDTO.DictExec = reqDict;
                        // chiamo la chiamata POST alla API, che manda la richiesta via REDIS
                        await ICService.CallRestPost($"{apiUrl}/{genericBasePath}", $"{calcTag}/{EditRecord.OfferRowUID}", calcRequestDTO);
                    }
                    EditRecord = null;
                    CurrEditMode = EditMode.None;
                }
            }
        }

        /// <summary>
        /// Chiude edit con preprocess x caso JWD
        /// </summary>
        /// <param name="args"></param>
        /// <returns></returns>
        private Task CloseEditJwd(DataSave infoSave)
        {
            prevJwd = infoSave.currJwd;
            return CloseEdit(infoSave.ForceSave);
        }

        private void ClosePopup()
        {
            CurrEditMode = EditMode.None;
            EditRecord = null;
            addFromTemplate = false;
        }

        private void ConfInit()
        {
            basePath = Config.GetValue<string>("ServerConf:FileSharePath") ?? "unsafe_uploads";
            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") ?? "calc";
            chHwOpt = Config.GetValue<string>("ServerConf:ChannelHwOpt") ?? "";
            chPng = Config.GetValue<string>("ServerConf:ChannelPng") ?? "";
            chProfElem = Config.GetValue<string>("ServerConf:ChannelProfElem") ?? "";
            chProfList = Config.GetValue<string>("ServerConf:ChannelProfList") ?? "";
            chShape = Config.GetValue<string>("ServerConf:ChannelShape") ?? "";
            chSvg = Config.GetValue<string>("ServerConf:ChannelSvg") ?? "";
        }

        private string cssReqPend(bool isDirty)
        {
            return isDirty ? "border border-warning rounded border-3" : "";
        }

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

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

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

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

                default:
                    break;
            }
        }

        /// <summary>
        /// Aggiunge una nuova riga vuota come nota sotto il record selezionato oppure in coda...
        /// </summary>
        /// <returns></returns>
        private async Task DoAddNote()
        {
            int numRow = AllRecords.Count + 1;
            if (EditRecord != null)
            {
                numRow = EditRecord.RowNum + 1;
            }
            OfferRowModel newNote = new OfferRowModel()
            {
                Note = $"--- Nuova nota | {DateTime.Now:ddd yyyy.MM.dd HH:mm:ss}---",
                OfferID = CurrRecord.OfferID,
                Envir = CurrRecord.Envir,
                RowNum = numRow,
                OfferRowUID = "",
                SellingItemID = null,
                Qty = 0,
                BomCost = 0,
                BomPrice = 0,
                StepCost = 0,
                StepPrice = 0
            };
            await ORService.UpsertAsync(newNote);
            await ReloadDataAsync();
            UpdateTable();
        }

        /// <summary>
        /// Aggiunge una nuova riga ordine in coda...
        /// </summary>
        /// <returns></returns>
        private async Task DoAddOrderRow(TemplateRowModel selTemplate)
        {
            int numRow = AllRecords.Count + 1;
            if (EditRecord != null)
            {
                numRow = EditRecord.RowNum + 1;
            }
            // SOLO SE è un oggetto calcolabile (JWD, BTL...) richiedo update img e BOM
            bool needRecalc = (selTemplate.SellingItemNav != null && selTemplate.SellingItemNav.HasBOM);
            // creo riga!
            OfferRowModel newSOR = new OfferRowModel()
            {
                AwaitBom = needRecalc,
                AwaitPrice = needRecalc,
                OfferID = CurrRecord.OfferID,
                Envir = CurrRecord.Envir,
                Inserted = DateTime.Now,
                RowNum = numRow,
                OfferRowUID = "",
                Qty = 1,
                SellingItemID = selTemplate.SellingItemID,
                SerStruct = selTemplate.SerStruct,
                BomCost = 0,
                BomPrice = 0,
                StepCost = 0,
                StepPrice = 0
            };
            // SE FOSSE NON calcolabile aggiungo costi std
            if (!needRecalc && selTemplate.SellingItemNav != null)
            {
                // recupero costi da ancestor
                newSOR.BomCost = selTemplate.SellingItemNav?.Cost ?? 0;
                newSOR.BomPrice = newSOR.BomCost * (1 + selTemplate.SellingItemNav?.Margin) ?? 1;
                newSOR.BomOk = true;
                newSOR.ItemOk = true;
                newSOR.ProdItemQty = 1;
            }
            addFromTemplate = false;
            var dbRec = await ORService.UpsertAsync(newSOR);
            // chiamo ricalcolo BOM e IMG...
            if (dbRec != null)
            {
                // se ho parametri validi di preselezione li applico...
                if (!string.IsNullOrEmpty(CurrRecord.DictPresel) && CurrRecord.DictParameter.Count > 0)
                {
                    // in primis provo conversione diretta
                    var updAnsw = SerialMan.MassUpdate((string)dbRec.SerStruct, CurrRecord.DictParameter);
                    // salvo jwd + versione aggiornata parametri
                    await ORService.UpdateSerStructDirtyAsync(dbRec.OfferRowID, updAnsw.serializeStruct, updAnsw.DictParameter);
                    // devo rileggere dal DB
                    dbRec = await ORService.GetByIdAsync(dbRec.OfferRowID);
                }

                // SOLO SE è un oggetto calcolabile (JWD, BTL...) richiedo update img e BOM
                if (needRecalc && dbRec != null)
                {
                    await callBomUpdate(dbRec);
                    await callImgUpdate(dbRec);
                    // imposto ad editing record secondo tipo
                    if (dbRec.Envir == EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WINDOW)
                    {
                        DoEditJwd(dbRec);
                    }
                    else
                    {
                        DoEditFile(dbRec);
                    }
                }
            }
            await ReloadDataAsync();
            UpdateTable();
        }

        /// <summary>
        ///  Annullamento modifica
        /// </summary>
        /// <param name="curRec"></param>
        /// <returns></returns>
        private async Task DoCancel()
        {
            isLoading = true;
            CurrEditMode = EditMode.None;
            EditRecord = null;
            await Task.Delay(20);
            await OService.FlushCacheOffersAsync();
            await Task.Delay(20);
            await ReloadDataAsync();
            UpdateTable();
            isLoading = false;
        }

        /// <summary>
        /// Clona riga richiesta
        /// </summary>
        /// <param name="rec2clone"></param>
        private async Task DoClone(OfferRowModel rec2clone)
        {
            mTitle = "Attenzione";
            mMessage = "Confermi di voler duplicare la riga corrente?";
            mMode = BootstrapModal.ModalMode.Confirm;
            modalOpt = new();
            modalOpt.Add(true, "Si");
            modalOpt.Add(false, "No");
            if (!await Modal!.ShowAsync<bool>())
                return;

            // calcolo indice riga...
            int numRow = totalCount + 1;
            bool needRecalc = (rec2clone.SellingItemNav != null && rec2clone.SellingItemNav.HasBOM);
            OfferRowModel newRec = new OfferRowModel()
            {
                AwaitBom = needRecalc,
                AwaitPrice = needRecalc,
                Envir = rec2clone.Envir,
                FileName = rec2clone.FileName,
                FileResource = rec2clone.FileResource,
                FileSize = rec2clone.FileSize,
                Inserted = DateTime.Now,
                ItemBOM = rec2clone.ItemBOM,
                ItemSteps = rec2clone.ItemSteps,
                Modified = DateTime.Now,
                Note = rec2clone.Note,
                OfferID = OfferID,
                OfferRowUID = "",
                Qty = rec2clone.Qty,
                RowNum = numRow,
                SellingItemID = rec2clone.SellingItemID,
                SerStruct = rec2clone.SerStruct,
                StepCost = rec2clone.StepCost,
                StepPrice = rec2clone.StepPrice,
                BomCost = needRecalc ? 0 : rec2clone.BomCost,
                BomPrice = needRecalc ? 0 : rec2clone.BomPrice,
                BomOk = needRecalc ? false : true,
                ItemOk = needRecalc ? false : true,
                ProdItemQty = needRecalc ? 0 : rec2clone.ProdItemQty
            };

            // salvo sul DB
            await ORService.UpsertAsync(newRec);
            // chiamo update record che non hanno UID x questo ordine
            await ORService.FixImgTypeAsync(OfferID);
            var list2fix = await ORService.FixUidAsync(OfferID);
            if (list2fix != null && list2fix.Count > 0)
            {
                // rileggo i miei record...
                await ReloadDataAsync();
                var listCalc = SorListCalc();
                foreach (var item in listCalc)
                {
                    // se è con BOM calcolabile...
                    if (item.SellingItemNav != null && item.SellingItemNav.HasBOM)
                    {
                        // se UID e' tra quelli da ricalcolare ed e' calcolabile...
                        if (list2fix.Contains(item.OfferRowUID))
                        {
                            // chiedo BOM e immagine
                            await callBomUpdate(item);
                        }
                    }
                }
            }
            await ReloadDataAsync();
            UpdateTable();
        }

        /// <summary>
        /// Eliminazione riga offerta
        /// </summary>
        /// <param name="rec2del"></param>
        /// <returns></returns>
        private async Task DoDelete(OfferRowModel rec2del)
        {
            mTitle = "Attenzione";
            mMessage = "Confermi di voler eliminare la riga corrente?\n" +
                        $" Codice: {rec2del.OfferRowUID} | {rec2del.Note}\n" +
                        $"Importo tot: {rec2del.TotalPrice}";
            mMode = BootstrapModal.ModalMode.Confirm;
            modalOpt = new();
            modalOpt.Add(true, "Si");
            modalOpt.Add(false, "No");
            if (!await Modal!.ShowAsync<bool>())
                return;

            await ORService.DeleteAsync(rec2del);
            // elimino cache img
            await ICService.DeleteSvgAsync(rec2del.OfferRowUID, rec2del.Envir);
            await ReloadDataAsync();
            UpdateTable();
        }

        /// <summary>
        /// Va in edit della riga richiesta
        /// </summary>
        /// <param name="curRec"></param>
        private void DoEdit(OfferRowModel curRec)
        {
            // imposto edit record
            EditRecord = curRec;
            /// modalita edit: gestione valori campi record
            CurrEditMode = EditMode.RecData;
            isLoading = false;
        }

        /// <summary>
        /// Edit del file:
        /// - abilitazione fileUpload
        /// - anteprima grande (live)
        /// </summary>
        /// <param name="curRec"></param>
        private void DoEditFile(OfferRowModel curRec)
        {
            EditRecord = curRec;
            /// modalit�edit: gestione JWD
            CurrEditMode = EditMode.File;
        }

        /// <summary>
        /// Apre editor finestre del record richiesto
        /// </summary>
        /// <param name="curRec"></param>
        private void DoEditJwd(OfferRowModel curRec)
        {
            /// modalit�edit: gestione JWD
            CurrEditMode = EditMode.SerStruc;
            EditRecord = curRec;
            // recupero dictReqPending correnti
            CurrPendReq = curRec.DictPendingPresel;
            // preparazione dati da record corrente
            PrepareWindowData(EditRecord.SerStruct);
            // reset prev
            prevJwd = "";
        }

        private async Task DoForceParam(Dictionary<string, bool> writeSet)
        {
            mTitle = "Attenzione";
            mMessage = $"Confermi di voler forzare {writeSet.Count} parametro/i selezionati per l'offerta?";
            mMode = BootstrapModal.ModalMode.Confirm;
            modalOpt = new();
            modalOpt.Add(true, "Si");
            modalOpt.Add(false, "No");
            if (!await Modal!.ShowAsync<bool>())
                return;
            // recupero obj dizionario x i parametri compresi...
            ParamDict CurrSel = new ParamDict(CurrRecord.DictPresel);
            // li incrocerò con i parametri da forzare ricevuti...

            // metto a waiting tutte le righe con bom...
            var listCalc = SorListCalc();
            foreach (var item in listCalc)
            {
                await ORService.UpdateAwaitStateAsync(item.OfferRowID, true, true);

                Dictionary<string, string> dict2write = new();
                // inserisco solo se valorizzati e selezionati
                if (writeSet.ContainsKey("Color") && writeSet["Color"] && !string.IsNullOrEmpty(CurrSel.GetVal("Color")))
                {
                    dict2write.Add("Color", CurrSel.GetVal("Color"));
                }
                if (writeSet.ContainsKey("Glass") && writeSet["Glass"] && !string.IsNullOrEmpty(CurrSel.GetVal("Glass")))
                {
                    dict2write.Add("Glass", CurrSel.GetVal("Glass"));
                }

                if (writeSet.ContainsKey("Profile") && writeSet["Profile"] && !string.IsNullOrEmpty(CurrSel.GetVal("Profile")))
                {
                    dict2write.Add("Profile", CurrSel.GetVal("Profile"));
                }

                if (writeSet.ContainsKey("Wood") && writeSet["Wood"] && !string.IsNullOrEmpty(CurrSel.GetVal("Wood")))
                {
                    dict2write.Add("Wood", CurrSel.GetVal("Wood"));
                }
                var updAnsw = SerialMan.MassUpdate((string)item.SerStruct, dict2write);
                await ORService.UpdateSerStructDirtyAsync(item.OfferRowID, updAnsw.serializeStruct, updAnsw.DictParameter ?? new Dictionary<string, string>());
            }
            await InvokeAsync(StateHasChanged);

            // verifica preliminare UID
            await ORService.FixUidAsync(OfferID);
            await ORService.FixImgTypeAsync(OfferID);

            // ricalcolo di tutte le BOM e relativi prezzi...
            foreach (var item in listCalc)
            {
                // chiedo BOM e immagine
                await callBomUpdate(item);
            }

            // chiudo blocco forza parametri
            isForceParamMode = false;
        }

        private async Task DoRecalcOffer(bool forceResetCalc)
        {
            isLoading = true;
            if (forceResetCalc)
            {
                await setAwaitPrice(true, false);
                UpdateTable();
                await InvokeAsync(StateHasChanged);
                await Task.Delay(300);
            }
            await OService.UpdateCostAsync(OfferID);
            if (forceResetCalc)
            {
                await Task.Delay(300);
                await setAwaitPrice(false, true);
            }

            // rileggo dati
            await ReloadDataAsync();
            UpdateTable();
            isLoading = false;
            await EC_Updated.InvokeAsync(true);
        }

        /// <summary>
        /// Salvataggio edit record + reload
        /// </summary>
        /// <param name="curRec"></param>
        /// <returns></returns>
        private async Task DoSave(OfferRowModel curRec)
        {
            isLoading = true;
            // salvo record modificato...
            await ORService.UpsertAsync(curRec);
            // reset
            CurrEditMode = EditMode.None;
            EditRecord = null;
            await OService.FlushCacheOffersAsync();
            await ReloadDataAsync();
            UpdateTable();
            isLoading = false;
        }

        /// <summary>
        /// Salva record ed avanza compilazione
        /// </summary>
        /// <param name="updRec"></param>
        /// <returns></returns>
        private async Task DoSave(OfferModel updRec)
        {
            mTitle = "Salvataggio offerta";
            mMessage = "Confermi di voler salvare parametri per l'offerta?";
            mMode = BootstrapModal.ModalMode.Confirm;
            modalOpt = new();
            modalOpt.Add(true, "Si");
            modalOpt.Add(false, "No");
            if (!await Modal!.ShowAsync<bool>())
                return;
            // salvo record
            await OService.UpsertAsync(updRec);
        }

        /// <summary>
        /// Seleziono riga senza cambiare modalit� editing
        /// </summary>
        /// <param name="curRec"></param>
        private void DoSelect(OfferRowModel curRec)
        {
            // imposto edit record
            EditRecord = curRec;
            /// modalit�edit: gestione valori campi record
            CurrEditMode = EditMode.None;
        }

        private async Task DoSelectItem()
        {
            addFromTemplate = true;
            ListCataloghi = ListAllCatalog.Where(x => x.Envir == CurrRecord.Envir).ToList();
        }

        /// <summary>
        /// Imposta modalita edit ciclo di lavoro
        /// </summary>
        /// <param name="currRow"></param>
        private Task DoSwapJobCycle(OfferRowModel currRow)
        {
            CurrEditMode = EditMode.JobCycle;
            return selectBom(currRow);
        }

        /// <summary>
        /// Imposta modalita ad edit BOM
        /// </summary>
        /// <param name="currRow"></param>
        private Task DoSwapMat(OfferRowModel currRow)
        {
            CurrEditMode = EditMode.BOM;
            return selectBom(currRow);
        }

        /// <summary>
        /// Aggiorna valore corrente reqPending x salvare poi con JWD su richiesta
        /// </summary>
        /// <param name="newPendReq"></param>
        /// <returns></returns>
        private void DoUpdatePend(Dictionary<string, string> newPendReq)
        {
            CurrPendReq = newPendReq;
#if false
            if (EditRecord != null)
            {
                // aggiorno record richieste!
                await ORService.UpdatePendReqAsync(EditRecord.OfferRowID, newPendReq);
                //await ReloadDataAsync();
                //UpdateTable();
            }
            await Task.Delay(10);
#endif
        }

        /// <summary>
        /// Prepara URL x download file JWD
        /// </summary>
        /// <param name="currUid"></param>
        /// <param name="objType"></param>
        /// <param name="envir"></param>
        /// <returns></returns>
        private string DownloadUrl(string currUid, string objType = "SOR", EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS envir = EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WINDOW)
        {
            return $"{apiUrl}/file/{currUid}?objType={objType}&env={envir}";
        }

        /// <summary>
        /// Salvataggio del JWD aggiornato nella mia riga di offerta
        /// </summary>
        /// <param name="CurrArgs"></param>
        private async Task ExecRequest(Dictionary<string, string> CurrArgs)
        {
            // Proseguo solo se sono in interattivo (NO prerender pagina)
            if (isInteractive)
            {
                // ...se ho editing
                if (EditRecord != null)
                {
                    // SE contiene il mio Jwd...
                    if (CurrArgs.ContainsKey("SerializedData"))
                    {
                        string serStruct = CurrArgs["SerializedData"];
                        // controllo SE variato...
                        if (!prevJwd.Equals(serStruct) || !EgwCoreLib.Utils.DictUtils.DictAreEqual(reqDict, CurrArgs))
                        {
                            // aggiorno val prev
                            reqDict = CurrArgs;
                            prevJwd = serStruct;
                            // aggiorno live data
                            CurrData.CurrJwd = serStruct;
                            // chiamo richiesta update
                            CalcRequestDTO calcRequestDTO = new CalcRequestDTO();
                            calcRequestDTO.EnvType = EditRecord.Envir;
                            calcRequestDTO.DictExec = reqDict;
                            // chiamo la chiamata POST alla API, che manda la richiesta via REDIS
                            await ICService.CallRestPost($"{apiUrl}/{genericBasePath}", $"{calcTag}/{EditRecord.OfferRowUID}", calcRequestDTO);
#if false
                        // salvo su DB!
                        await DLService.OffertRowUpdateSerStruct(EditRecord.OfferRowID, serStruct);
#endif
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Path da parent record
        /// </summary>
        /// <param name="objID"></param>
        /// <returns></returns>
        private string FolderPath(int objID)
        {
            return $"SO-{objID:X8}";
        }

        /// <summary>
        /// Svuota cache corrente + rilegge dati
        /// </summary>
        private async Task ForceReloadData()
        {
            isLoading = true;
            CurrEditMode = EditMode.None;
            EditRecord = null;
            await Task.Delay(20);
            await OService.FlushCacheOffersAsync();
            await Task.Delay(20);
            await ReloadDataAsync();
            UpdateTable();
            isLoading = false;
        }

        /// <summary>
        /// Display fileSize scalato
        /// </summary>
        /// <param name="size"></param>
        /// <returns></returns>
        private string fSize(long size)
        {
            return EgwCoreLib.Utils.FileHelpers.SizeSuffix(size, 1);
        }

        /// <summary>
        /// Formattazione testo come html x display
        /// </summary>
        private MarkupString HtmlConv(string rawData)
        {
            return (MarkupString)rawData.Replace(Environment.NewLine, "<br />").Replace("\n", "<br />");//.Replace(" ", "&nbsp;");
        }

        /// <summary>
        /// Calcola src immagine direttamente da modello dati + base path
        /// </summary>
        /// <param name="imgUrl"></param>
        /// <returns></returns>
        private string imgSrc(string imgUrl)
        {
            return $"{apiUrl}/{imgBasePath}/{imgUrl}";
        }

        /// <summary>
        /// Aggiornamento costing completo:
        /// - verifica UID
        /// - ricalcolo BOM
        /// - update prezzi
        /// </summary>
        /// <returns></returns>
        private async Task OfferUpdateAllCosting()
        {
            mTitle = "Attenzione";
            mMessage = "Confermi di voler ricalcolare/validare in toto l'offerta?";
            mMode = BootstrapModal.ModalMode.Confirm;
            modalOpt = new();
            modalOpt.Add(true, "Si");
            modalOpt.Add(false, "No");
            if (!await Modal!.ShowAsync<bool>())
                return;
            // metto a waiting tutte le righe con bom...
            var listCalc = SorListCalc();
            foreach (var item in listCalc)
            {
                await ORService.UpdateAwaitStateAsync(item.OfferRowID, true, true);
            }
            await InvokeAsync(StateHasChanged);

            // verifica preliminare UID
            await ORService.FixUidAsync(OfferID);
            await ORService.FixImgTypeAsync(OfferID);

            // fixme todo da riverificare con calcolo BOM funzionante
#if false
            // rileggo i record...
            await ReloadDataAsync();
#endif
            // ricalcolo di tutte le BOM e relativi prezzi...
            foreach (var item in listCalc)
            {
                // verifico SE sia calcolabile...
                if (item.CalcEnabled)
                {
                    // chiedo BOM e immagine
                    await callBomUpdate(item);
                }
            }
#if false
            await DoRecalcOffer();
#endif
        }

        /// <summary>
        /// Verifica e ricalcolo dei prezzi degli items nell'offerta
        /// </summary>
        /// <returns></returns>
        private async Task OfferUpdatePrices()
        {
            mTitle = "Attenzione";
            mMessage = "Confermi di voler ricalcolare a costi correnti offerta?";
            mMode = BootstrapModal.ModalMode.Confirm;
            modalOpt = new();
            modalOpt.Add(true, "Si");
            modalOpt.Add(false, "No");
            if (!await Modal!.ShowAsync<bool>())
                return;
            await DoRecalcOffer(true);
        }

        /// <summary>
        /// Ricevuto HwOpt, processo
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void PipeHwOpt_EA_NewMessage(object? sender, EventArgs e)
        {
            // vale SOLO SE sono in editing...
            if (EditRecord != null)
            {
                // aggiorno visualizzazione
                PubSubEventArgs currArgs = (PubSubEventArgs)e;
                // conversione on-the-fly SVG da mostrare
                if (!string.IsNullOrEmpty(currArgs.newMessage))
                {
                    if (currArgs.msgUid.Equals($"{chHwOpt}:{EditRecord.OfferRowUID}"))
                    {
                        // se non è vuoto deserializzo
                        if (currArgs.newMessage.Count() > 2)
                        {
                            var rawDict = JsonConvert.DeserializeObject<Dictionary<int, string>>(currArgs.newMessage) ?? new Dictionary<int, string>();
                            currHwOption = rawDict;
                        }
                        else
                        {
                            currHwOption = new Dictionary<int, string>();
                        }
                        // salvo in live data...
                        CurrData.DictOptionsXml = currHwOption;
                    }
                    await InvokeAsync(StateHasChanged);
                }
            }
        }

        private async void PipePng_EA_NewMessage(object? sender, EventArgs e)
        {
            // vale SOLO SE sono in editing...
            if (EditRecord != null)
            {
                // aggiorno visualizzazione
                PubSubEventArgs currArgs = (PubSubEventArgs)e;
                // conversione on-the-fly SVG da mostrare
                if (!string.IsNullOrEmpty(currArgs.newMessage))
                {
                    if (currArgs.msgUid.Equals($"{chPng}:{EditRecord.OfferRowUID}"))
                    {
                        currPng = currArgs.newMessage;
                        // non devo passarlo al componente...
#if false
                        // salvo in live data...
                        CurrData.SvgPreview = currSvg;
#endif
                    }
                    await InvokeAsync(StateHasChanged);
                }
            }
        }

        /// <summary>
        /// Ricevuto ProfElem, processo
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void PipeProfElement_EA_NewMessage(object? sender, EventArgs e)
        {
            // vale SOLO SE sono in editing...
            if (EditRecord != null)
            {
                // aggiorno visualizzazione
                PubSubEventArgs currArgs = (PubSubEventArgs)e;
                // conversione on-the-fly SVG da mostrare
                if (!string.IsNullOrEmpty(currArgs.newMessage))
                {
                    if (currArgs.msgUid.StartsWith($"{chProfElem}:{EditRecord.OfferRowUID}"))
                    {
                        // deserializzo il dizionario delle risposte...
                        var rawDict = JsonConvert.DeserializeObject<List<AreaProfiles>>(currArgs.newMessage);
                        currAreaProfiles = rawDict ?? new List<AreaProfiles>();
                        CurrData.ProfElementList = currAreaProfiles;
                    }
                    await InvokeAsync(StateHasChanged);
                }
            }
        }

        /// <summary>
        /// Ricevuta profile list, processo
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void PipeProfList_EA_NewMessage(object? sender, EventArgs e)
        {
            // vale SOLO SE sono in editing...
            if (EditRecord != null)
            {
                // aggiorno visualizzazione
                PubSubEventArgs currArgs = (PubSubEventArgs)e;
                // conversione on-the-fly SVG da mostrare
                if (!string.IsNullOrEmpty(currArgs.newMessage))
                {
                    if (currArgs.msgUid.Equals($"{chProfList}:{EditRecord.OfferRowUID}"))
                    {
                        try
                        {
                            // nuova gestione da DB: attendo 500ms che il DB sia aggiornato
                            await Task.Delay(500);
                            // rileggo DB x info profili
                            AvailProfileList = await CPService.GetAllAsync();
                            // converto i profili nel nuovo formato x payload...
                            var profList = AvailProfileList.Select(x => new ProfilePayload()
                            {
                                ProfileName = x.Code,
                                ThresholdList = x.ThresholdList,
                                ParameterDict = x.ProfileDataDict
                            }).ToList();
                            SetupList.ProfileList = profList;
                        }
                        catch
                        { }
                    }
                    await InvokeAsync(StateHasChanged);
                }
            }
        }

        /// <summary>
        /// Ricevuta shape, procersso
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void PipeShape_EA_NewMessage(object? sender, EventArgs e)
        {
            // vale SOLO SE sono in editing...
            if (EditRecord != null)
            {
#if false
                // aggiorno visualizzazione
                PubSubEventArgs currArgs = (PubSubEventArgs)e;
                // conversione on-the-fly SVG da mostrare
                if (!string.IsNullOrEmpty(currArgs.newMessage))
                {
                    if (currArgs.msgUid.Equals($"{shapeChannel}:{EditRecord.OfferRowUID}"))
                    {
                        currGroupShape = currArgs.newMessage;
                        // salvo in live data...
                        CurrData.DictShape = currGroupShape;
                    }
                    await InvokeAsync(StateHasChanged);
                }
#endif

                // aggiorno visualizzazione
                PubSubEventArgs currArgs = (PubSubEventArgs)e;
                // conversione on-the-fly SVG da mostrare
                if (!string.IsNullOrEmpty(currArgs.newMessage))
                {
                    if (currArgs.msgUid.StartsWith($"{chShape}:{EditRecord.OfferRowUID}"))
                    {
                        // deserializzo il dizionario delle risposte...
                        var rawDict = JsonConvert.DeserializeObject<Dictionary<int, string>>(currArgs.newMessage);
#if false
                    int groupId = 0;
                    // verifica del groupID...
                    int.TryParse(currArgs.msgUid.Replace($"{shapeChannel}:{windowUid}:", ""), out groupId);
                    if (currGroupShape.ContainsKey(groupId))
                    {
                        currGroupShape[groupId] = currArgs.newMessage;
                    }
                    else
                    {
                        currGroupShape.Add(groupId, currArgs.newMessage);
                    }
#endif
                        currGroupShape = rawDict ?? new Dictionary<int, string>();
                        CurrData.DictShape = currGroupShape;
                    }
                    await InvokeAsync(StateHasChanged);
                }
            }
        }

        /// <summary>
        /// Ricevuto SVG, se � il mio lo aggiorno...
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void PipeSvg_EA_NewMessage(object? sender, EventArgs e)
        {
            // vale SOLO SE sono in editing...
            if (EditRecord != null)
            {
                // aggiorno visualizzazione
                PubSubEventArgs currArgs = (PubSubEventArgs)e;
                // conversione on-the-fly SVG da mostrare
                if (!string.IsNullOrEmpty(currArgs.newMessage))
                {
                    if (currArgs.msgUid.Equals($"{chSvg}:{EditRecord.OfferRowUID}"))
                    {
                        currSvg = currArgs.newMessage;
                        // salvo in live data...
                        CurrData.SvgPreview = currSvg;
                    }
                    await InvokeAsync(StateHasChanged);
                }
            }
        }

        /// <summary>
        /// Task verifica update ricevuti
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void PipeUpdate_EA_NewMessage(object? sender, EventArgs e)
        {
            // aggiorno visualizzazione
            PubSubEventArgs currArgs = (PubSubEventArgs)e;
            // conversione on-the-fly SVG da mostrare
            if (!string.IsNullOrEmpty(currArgs.newMessage))
            {
                // cerco se faccia parte dei record correnti...
                var recFound = AllRecords.Any(x => x.OfferRowUID == currArgs.newMessage);
                if (recFound)
                {
                    isLoading = true;
                    await Task.Delay(1);
                    // se si tratta dell'UID corrente --> fa update
                    await DoRecalcOffer(false);
                    await InvokeAsync(StateHasChanged);
                }
            }
            await Task.Delay(1);
        }

        /// <summary>
        /// Preparazione dati x componente edit JWD
        /// </summary>
        /// <param name="currJwd"></param>
        private void PrepareWindowData(string currJwd)
        {
            // converto i profili nel nuovo formato x payload...
            var profList = AvailProfileList.Select(x => new ProfilePayload()
            {
                ProfileName = x.Code,
                ThresholdList = x.ThresholdList,
                ParameterDict = x.ProfileDataDict
            }).ToList();

            // preparo conf oggetti x controllo
            SetupList = new BaseListPayload()
            {
                ColorMaterial = AvailColorMaterialList,
                FamilyHardware = AvailFamilyHardwareList,
                Glass = AvailGlassList,
                Hardware = AvailHardwareList,
                Wood = AvailWoodList,
                ProfileList = profList
            };
            CurrData = new LivePayload()
            {
                CurrJwd = currJwd,
                SvgPreview = "" //currSvg
            };
        }

        /// <summary>
        /// init classi configurazione
        /// </summary>
        /// <returns></returns>
        private async Task ReloadBaseList()
        {
            // leggo cataloghi e template relativi...
            ListAllCatalog = await TService.GetAllAsync();
            ListTemplateAll = await TRService.GetAllAsync();

            // lettura config setup varie da DB/Cache Redis
            AllConfEnvir = await EPService.GetAllAsync();
            AllConfGlass = await CGService.GetAllAsync();
            AvailProfileList = await CPService.GetAllAsync();

            // FixMe Todo: eliminare da REDIS e usare elenco DB solamente...
            var rawProfiles = await CDService.ProfileListAsync(cEnvir, "Default");
            // se fosse vuoto chiamo update...
            if (rawProfiles == null || rawProfiles.Count == 0)
            {
                await callRefreshProfList();
                // aspetto 200ms... e richiedo!
                await Task.Delay(200);
                rawProfiles = await CDService.ProfileListAsync(cEnvir, "Default");
            }
            AvailProfileListOld = rawProfiles;

            var rawHw = await CDService.HwModelListAsync(cEnvir, "HW.AGB");
            // hw filtro solo validi...
            AllConfHardware = rawHw
                        .Where(x => !x.FamilyName.Equals(x.Description, StringComparison.OrdinalIgnoreCase))
                        .ToList();
            AllConfWood = await CWService.GetAllAsync();
            AllColors = await GVService.GetFiltAsync("WoodCol");
            // conversione tipi
            AvailGlassList = AllConfGlass
                                .Select(x => x.Description)
                                .ToList();
            AvailFamilyHardwareList = AllConfHardware
                                        .DistinctBy(x => x.FamilyName)
                                        .OrderBy(x => x.FamilyName)
                                        .Select(x => x.FamilyName)
                                        .ToList();
            AvailHardwareList = AllConfHardware
                                .Select(x => new Egw.Window.Data.Hardware(x.Id, x.FamilyName, x.Description, x.OpeningType, x.Shape, x.SashQty, x.SashPosition))
                                .ToList();
            AvailWoodList = AllConfWood
                                .Select(x => x.Description)
                                .ToList();
            // FixMe Todo: aggiunta profili (manca anche nel costruttore...)
            AvailColorMaterialList = AllColors
                                        .OrderBy(x => x.Index)
                                        .Select(x => x.ValString)
                                        .ToList();
        }

        /// <summary>
        /// Legge i dati dei record completi
        /// </summary>
        private async Task ReloadDataAsync()
        {
            if (OfferID > 0)
            {
                AllRecords = await ORService.GetByParentAsync(OfferID);
                totalCount = AllRecords.Count();
            }
        }

        private Task ReqEditRow()
        {
            return EC_Action.InvokeAsync("EditRow");
        }

        /// <summary>
        /// Lancia la richiesta di ricaolo della BOM dal JWD (o equivalente)
        /// </summary>
        /// <returns></returns>
        private async Task RequestBom(OfferRowModel currRec)
        {
            mTitle = "Attenzione";
            mMessage = "Confermi di voler ricalcolare la BOM?";
            mMode = BootstrapModal.ModalMode.Confirm;
            modalOpt = new();
            modalOpt.Add(true, "Si");
            modalOpt.Add(false, "No");
            if (!await Modal!.ShowAsync<bool>())
                return;
            await callBomUpdate(currRec);
        }

        /// <summary>
        /// Css di verifica riga selezionata
        /// </summary>
        /// <param name="selRow"></param>
        /// <returns></returns>
        private string RowClass(OfferRowModel selRow)
        {
            return EditRecord != null && EditRecord.OfferRowID == selRow.OfferRowID ? "table-info" : "";
        }

        /// <summary>
        /// Salvataggio dei dati del file caricato
        /// </summary>
        /// <param name="fileDict">Dizionario info file</param>
        private void SaveFile(Dictionary<string, string> fileDict)
        {
            // verifico di essere in edit...
            if (EditRecord != null)
            {
                string folderPath = FolderPath(EditRecord.OfferID);
                // verifico di avere parametri...
                if (fileDict != null && fileDict.Count > 0)
                {
                    string secureName = "";
                    string content = "";
                    if (fileDict.ContainsKey("secureName"))
                    {
                        secureName = fileDict["secureName"];
                    }
                    if (fileDict.ContainsKey("content"))
                    {
                        content = fileDict["content"];
                    }
                    if (!string.IsNullOrEmpty(folderPath) && !string.IsNullOrEmpty(secureName) && !string.IsNullOrEmpty(content))
                    {
                        // salvo!
                        FService.SaveFileContent(folderPath, secureName, content);
                    }
                }
                // altrimenti signifca cleanup eventuale vecchio file...
                else
                {
                    FService.DeleteOldFile(folderPath, EditRecord.FileResource);
                }
            }
        }

        /// <summary>
        /// Selezione e fix dati BOM
        /// </summary>
        /// <param name="currRow"></param>
        /// <returns></returns>
        private async Task selectBom(OfferRowModel currRow)
        {
            EditRecord = currRow;
            //CurrBomList = DLService.OffertGetBomList(EditRecord);
            CurrBomList = BomCalculator.GetBomList(EditRecord.ItemBOM);
            if (CurrBomList.Any(x => x.ItemID == 0))
            {
                CurrBomList = await ItemService.GetBomFixItemIdAsync(CurrBomList);
            }
        }

        private async Task setAwaitPrice(bool awaitPrice, bool flushCache)
        {
            foreach (var item in AllRecords)
            {
                item.AwaitPrice = awaitPrice;
                await ORService.UpdateAwaitStateAsync(item.OfferRowID, null, awaitPrice, flushCache);
            }
        }

        /// <summary>
        /// Verifia ammissibilit� display btn ricalcolo BOM da item
        /// </summary>
        /// <param name="reqItem"></param>
        /// <returns></returns>
        private bool ShowBom(OfferRowModel reqItem)
        {
            bool answ = false;
            if (DisplayMode == EgwCoreLib.Lux.Core.Enums.DisplayMode.Edit)
            {
                switch (reqItem.Envir)
                {
                    case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WINDOW:
                        answ = !string.IsNullOrEmpty(reqItem.SerStruct) && reqItem.SerStruct.Length > 2;
                        break;

                    case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.BEAM:
                    case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WALL:
                    case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.CABINET:
                        // da cambiare con ricerca file su disco?!?
                        answ = !string.IsNullOrEmpty(reqItem.FileResource) && !string.IsNullOrEmpty(reqItem.FileName);
                        break;

                    case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.NULL:
                    default:
                        break;
                }
            }
            return answ;
        }

        /// <summary>
        /// Elenco SalesOfferRows calcolabili:
        /// - contengono serializzazione come JWD
        /// - contengono file come BTL
        /// </summary>
        private List<OfferRowModel> SorListCalc()
        {
            var rawList = AllRecords
                                .Where(x => (!string.IsNullOrEmpty(x.SerStruct) && x.SerStruct.Length > 2) || (!string.IsNullOrEmpty(x.FileName) && !string.IsNullOrEmpty(x.FileResource)))
                                .ToList();
            return rawList ?? new List<OfferRowModel>();
        }

        /// <summary>
        /// Toggle visibilit� modifica file indicando ID della OfferRow corrente (o zero se deselect)
        /// </summary>
        private void ToggleFileEdit(OfferRowModel? currRec)
        {
            CurrEditMode = currRec == null ? EditMode.None : EditMode.File;
            EditRecord = currRec;
        }

        private void ToggleForceParam()
        {
            isForceParamMode = !isForceParamMode;
        }

#if false
        /// <summary>
        /// Forza parametri generali selezionati nell'offerta
        /// </summary>
        /// <returns></returns>
        private async Task OfferForceParameters()
        {
            // recupero obj dizionario x i parametri compresi...
            ParamDict CurrSel = new ParamDict(CurrRecord.DictPresel);
            // metto a waiting tutte le righe con bom...
            var listCalc = SorListCalc();
            foreach (var item in listCalc)
            {
                await ORService.UpdateAwaitStateAsync(item.OfferRowID, true, true);
                // poich� non � gestito evento ritorno update window interno si "scassa" --> try catch/ if FALSE
                try
                {
                    string rColor = CurrSel.GetVal("Color");
                    string rGlass = CurrSel.GetVal("Glass");
                    string rProfile = CurrSel.GetVal("Profile");
                    string rWood = CurrSel.GetVal("Wood");
                    var newSerStruct = SerialMan.MassUpdate((string)item.SerStruct, null, null, rColor, rWood, rGlass, rProfile);
                    await ORService.UpdateSerStructAsync(item.OfferRowID, newSerStruct);
                }
                catch
                { }
            }
            await InvokeAsync(StateHasChanged);

            // verifica preliminare UID
            await ORService.FixUidAsync(OfferID);
            await ORService.FixImgTypeAsync(OfferID);

            // ricalcolo di tutte le BOM e relativi prezzi...
            foreach (var item in listCalc)
            {
                // chiedo BOM e immagine
                await callBomUpdate(item);
            }

            //await DoRecalcTemplate();
        }
#endif
#if false
        /// <summary>
        /// Aggiunge una nuova riga ordine in coda...
        /// </summary>
        /// <returns></returns>
        protected async Task DoAddOrderRowFromSellItem(int sellItemID)
        {
            int numRow = AllRecords.Count + 1;
            if (EditRecord != null)
            {
                numRow = EditRecord.RowNum + 1;
            }
            OfferRowModel newSOR = new OfferRowModel()
            {
                AwaitBom = true,
                AwaitPrice = true,
                OfferID = CurrRecord.OfferID,
                Envir = CurrRecord.Envir,
                Inserted = DateTime.Now,
                RowNum = numRow,
                OfferRowUID = "",
                Qty = 1,
                SellingItemID = sellItemID,
                BomCost = 0,
                BomPrice = 0,
                StepCost = 0,
                StepPrice = 0
            };
            // se è window aggiungo "{}" come serStruct sennò non la prende bene...
            if (CurrRecord.Envir == EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WINDOW)
            {
                newSOR.SerStruct = "{}";
            }
            addFromTemplate = false;
            await DLService.OffertRowUpsert(newSOR);
            await ReloadDataAsync();
            UpdateTable();
        }
#endif
#if false
        /// <summary>
        /// Calcolo URL immagine
        /// </summary>
        /// <param name="imgUid"></param>
        /// <param name="env"></param>
        /// <returns></returns>
        protected string imgUrl(string imgUid, string env)
        {
            // cast string su env..
            EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS envir = EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WINDOW;
            Enum.TryParse(env, out envir);
            return ICService.ImageUrl($"{apiUrl}/{imgBasePath}", false, imgUid, envir);
        }
#endif

        /// <summary>
        /// Salva nel record corrente la BOM aggiornata e poi ricalcola importo...
        /// </summary>
        /// <param name="newBomList"></param>
        /// <exception cref="NotImplementedException"></exception>
        private async Task UpdateBom(List<BomItemDTO> newBomList)
        {
            if (EditRecord != null)
            {
                // salvo BOM nel record corrente...
                bool fatto = await ORService.UpdateBomAsync(EditRecord.OfferRowID, newBomList);
                // ricalcolo offerta completa
                await ReloadDataAsync();
                UpdateTable();
                // rilegge il record da elenco appena rinfrescato...
                int offerRowId = EditRecord.OfferRowID;
                var updRec = AllRecords.FirstOrDefault(x => x.OfferRowID == offerRowId);
                if (updRec != null)
                {
                    CurrBomList = new List<BomItemDTO>();
                    // fa refresh dei dati della BOM visualizzata
                    await selectBom(updRec);
                    await InvokeAsync(StateHasChanged);
                }
            }
        }

        /// <summary>
        /// Filtro e paginazione
        /// </summary>
        private void UpdateTable()
        {
            // fix paginazione
            ListRecords = AllRecords
                            .OrderBy(x => x.RowNum)
                            .Skip(numRecord * (currPage - 1))
                            .Take(numRecord)
                            .ToList();
            isLoading = false;
        }

        /// <summary>
        /// Esegue lettura file + invio richiesta specifica
        /// </summary>
        /// <param name="e"></param>
        /// <returns></returns>

        private async Task UploadFile(InputFileChangeEventArgs e)
        {
            // Proseguo solo se sono in interattivo (NO prerender pagina)
            if (isInteractive)
            {
                if (EditRecord != null)
                {
                    // init dizionari arg richiesta update
                    Dictionary<string, string> fileArgs = new Dictionary<string, string>();

                    // leggo il contenuto del PRIMO (singolo) file
                    IBrowserFile file = e.File;
                    // limite file size (al momento 10 MB)
                    var maxAllowedSize = 10 * 1024 * 1024;

                    using var stream = file.OpenReadStream(maxAllowedSize);
                    using var reader = new StreamReader(stream);
                    string rawContent = await reader.ReadToEndAsync();

                    // calcolo il nome del file trusted...
                    string trustedFileName = Path.GetRandomFileName();
                    EditRecord.FileResource = trustedFileName;
                    EditRecord.FileName = file.Name;
                    EditRecord.FileSize = rawContent.LongCount();
                    // salvo sul DB i dati (nome, nome sicuro, size...)
                    await ORService.UpdateFileDataAsync(EditRecord);

                    // parametri richiesta
                    fileArgs.Add("Mode", $"{(int)Egw.Window.Data.Enums.QuestionModes.PREVIEW}");
                    fileArgs.Add("SubMode", "2");
                    fileArgs.Add("FileName", $"{file.Name}");
                    fileArgs.Add("Height", "1200");
                    fileArgs.Add("Width", "1800");
                    //fileArgs.Add("Btl", rawContent);
                    fileArgs.Add("SerializedData", rawContent);
                    // invio!
                    CalcRequestDTO calcRequestDTO = new CalcRequestDTO();
                    calcRequestDTO.EnvType = EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.BEAM;
                    calcRequestDTO.DictExec = fileArgs;
                    await ICService.CallRestPost($"{apiUrl}/{genericBasePath}", $"{calcTag}/{EditRecord.OfferRowUID}", calcRequestDTO);

                    // ora chiedo anche la BOM!

#if false
                // salvo in locale il file: SISTEMARE PERMESSI
                saveFileContent(EditFileRecord.OfferRowUID, trustedFileName, rawContent);
#endif
                }
            }
        }

        #endregion Private Methods
    }
}