using MP.Core.DTO;
using MP.Core.Objects;
using MP.Data.DbModels;
using MP.Data.DbModels.Anag;
using MP.Data.MgModels;
using StackExchange.Redis;
using static MP.Core.Objects.Enums;

namespace MP.IOC.Data
{
    public interface IMpDataService
    {
        #region Public Methods

        /// <summary>
        /// Verifica se sia da reinviare un taskName alla macchina dall'elenco di quelli salvati (in
        /// modalit\u00e0 upsert) se non scaduti
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="taskKey">tipo task</param>
        /// <param name="taskVal">valore task</param>
        /// <returns>true se il task \u00e8 stato reinviato</returns>
        bool AddCheckTask4Machine(string idxMacchina, taskType taskKey, string taskVal);

        /// <summary>
        /// Aggiunge un parametro opzionale all'elenco dei saved task (in modalit\u00e0 upsert)
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="taskKey">chiave del parametro</param>
        /// <param name="taskVal">valore del parametro</param>
        /// <returns>true se inserito</returns>
        bool AddOptPar4Machine(string idxMacchina, string taskKey, string taskVal);

        /// <summary>
        /// Aggiunge un task all'elenco di quelli salvati (in modalit\u00e0 upsert)
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="taskKey">tipo task</param>
        /// <param name="taskVal">valore task</param>
        /// <returns>true se inserito</returns>
        bool AddTask4Machine(string idxMacchina, taskType taskKey, string taskVal);

        /// <summary>
        /// Aggiunge un set di task per macchina all'elenco di quelli salvati (in modalit\u00e0 upsert)
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="taskDict"> Dizionario di task tipo-valore da salvare</param>
        /// <returns>true se completato</returns>
        Task<bool> AddTask4MacListAsync(string idxMacchina, Dictionary<taskType, string> taskDict);

        /// <summary>
        /// Inserimento record allarme su DB
        /// </summary>
        /// <param name="dtRif">Data evento</param>
        /// <param name="idxMacchina">Nome macchina</param>
        /// <param name="memAddress">Indirizzo memoria PLC</param>
        /// <param name="memIndex">Indice memoria</param>
        /// <param name="statusVal">Stato valOut</param>
        /// <param name="valDecoded">Valore decodificato</param>
        /// <returns>true se inserito</returns>
        Task<bool> AlarmInsertAsync(DateTime dtRif, string idxMacchina, string memAddress, int memIndex, int statusVal, string valDecoded);

        /// <summary>
        /// Restituisce l'anagrafica STATI per intero con cache Fusion
        /// </summary>
        /// <returns>Lista di modelli AnagStatiModel</returns>
        Task<List<AnagStatiModel>> AnagStatiGetAllAsync();

        /// <summary>
        /// Restituisce i modelli di ultimo articolo per data macchina, con cache Fusion
        /// </summary>
        /// <param name="idxMacc">idx macchina</param>
        /// <returns>Lista di modelli AnagArticoliModel</returns>
        Task<List<AnagArticoliModel>> ArticoliGetLastByMaccAsync(string idxMacc);

        /// <summary>
        /// Effettua lo split dell'ODL corrente per la macchina, con eventuale conferma produzione e
        /// gestione slave
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="doConfirm">effettuare la conferma quantitativa</param>
        /// <param name="qtyFromLast">imposta la qty del prossimo ODL da quello che si chiude</param>
        /// <param name="matrOpr">matricola operatore</param>
        /// <param name="roundStep">Step di arrotondamento quantit\u00e0</param>
        /// <param name="keyRichiesta">Chiave esterna da associare all'ODL</param>
        /// <returns>"OK" se successo, "KO" altrimenti</returns>
        Task<string> AutoStartOdlAsync(string idxMacchina, bool doConfirm, bool qtyFromLast, int matrOpr, int roundStep = 100, string keyRichiesta = "");

        /// <summary>
        /// Calcola la ricetta su MongoDB dato modello ricetta corrente
        /// </summary>
        /// <param name="currRecipe">Modello ricetta da calcolare</param>
        /// <returns>Risultato del calcolo ricetta</returns>
        string CalcRecipe(RecipeModel currRecipe);

        /// <summary>
        /// Controlla se dal segnale di "microstato" deriva un evento da generare - modalit\u00e0 OFFLINE
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="valore">valore valOut ingresso</param>
        /// <param name="dtEve">data-ora evento (server)</param>
        /// <param name="contatore">sequenza dati inviati</param>
        /// <param name="datiMaccCache">dati macchina in cache (opzionale, se null fa lookup)</param>
        /// <returns>Risultato del processing</returns>
        Task<inputComandoMapo> CheckMicroStatoAsync(string idxMacchina, string valore, DateTime dtEve, string contatore, Dictionary<string, string>? datiMaccCache = null);

        /// <summary>
        /// Restituisce l'elenco completo delle configurazioni da DB, con cache Fusion
        /// </summary>
        /// <returns>Lista di modelli ConfigModel</returns>
        Task<List<ConfigModel>> ConfigGetAllAsync();

        /// <summary>
        /// Restituisce l'elenco delle decodifiche articoli filtrata per codice, con cache Fusion
        /// </summary>
        /// <param name="codArt">codice articolo (opzionale, se vuoto restituisce tutto)</param>
        /// <returns>Lista di modelli DecNumArticoliModel</returns>
        Task<List<DecNumArticoliModel>> DecNumArtGetFiltAsync(string codArt = "");

        /// <summary>
        /// Restituisce le date dei dossier per una macchina, con cache Fusion
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <returns>Lista di modelli DossierModel</returns>
        Task<List<DossierModel>> DossierLastByMachAsync(string idxMacchina);

        /// <summary>
        /// Task completo per sistemazione dossier quotidiani mancanti
        /// </summary>
        /// <param name="idxMacc">idx macchina</param>
        /// <returns>"OK" se completato</returns>
        Task<string> FixDailyDossierAsync(string idxMacc);

        /// <summary>
        /// Restituisce il codice valOut dell'ODL corrente (con cache redis interna)
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <returns>codice valOut dell'ODL corrente</returns>
        Task<string> GetCurrOdlAsync(string idxMacchina);

        /// <summary>
        /// Restituisce il modello dell'ultimo ODL per macchina, con cache Fusion
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <returns>Modello ODLExpModel</returns>
        Task<ODLExpModel> GetLastOdlAsync(string idxMacchina);

        /// <summary>
        /// Effettua il calcolo della data-ora di riferimento per il server, correggendo il delta
        /// tra orologio macchina e server
        /// </summary>
        /// <param name="dtEve">data-oras dell'evento (macchina)</param>
        /// <param name="dtCurr">data-ora corrente (server)</param>
        /// <returns>Data-ora evento corretta</returns>
        DateTime GetSrvDtEvent(string dtEve, string dtCurr);

        /// <summary>
        /// Restituisce se la macchina sia abilitata all'inserimento dati da IOB
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <returns>true se abilitato all'input</returns>
        Task<bool> IobInsEnabAsync(string idxMacchina);

        /// <summary>
        /// Restituisce se la macchina sia abilitata come master di un impianto
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <returns>true se \u00e8 master</returns>
        Task<bool> IobIsMasterAsync(string idxMacchina);

        /// <summary>
        /// Restituisce se la macchina sia abilitata all'inserimento nel Signal Log
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <returns>true se abilitato</returns>
        Task<bool> IobSLogEnabAsync(string idxMacchina);

        /// <summary>
        /// Restituisce i valori ammessi per una tabella/colonna (con cache redis interna)
        /// </summary>
        /// <param name="tabName">nome tabella</param>
        /// <param name="fieldName">nome campo</param>
        /// <returns>Lista di ListValuesModel</returns>
        Task<List<ListValuesModel>> ListValuesFilt(string tabName, string fieldName);

        /// <summary>
        /// Restituisce l'elenco completo delle relazioni macchine master-slave, con cache Fusion
        /// </summary>
        /// <returns>Lista di Macchine2SlaveModel</returns>
        Task<List<Macchine2SlaveModel>> Macchine2SlaveGetAllAsync();

        /// <summary>
        /// Restituisce le macchine filtrate per gruppo, con cache Fusion
        /// </summary>
        /// <param name="codGruppo">codice gruppo (o "*" per tutto)</param>
        /// <returns>Lista di MacchineModel</returns>
        Task<List<MacchineModel>> MacchineGetFilt(string codGruppo);

        /// <summary>
        /// Restituisce il path delle ricette di una macchina, con cache Fusion
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <returns>Path delle ricette</returns>
        Task<string> MacchineRecipeArchive(string idxMacchina);

        /// <summary>
        /// Restituisce la lista parametri correnti (ObjItemDTO) della macchina da Redis
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <returns>Lista di ObjItemDTO</returns>
        Task<List<ObjItemDTO>> MachineParamListAsync(string idxMacchina);

        /// <summary>
        /// Restituisce i parametri correnti della macchina che necessitano di write (writable + reqValue valorizzato)
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <returns>Lista di ObjItemDTO</returns>
        Task<List<ObjItemDTO>> MachineParamListPendingWriteAsync(string idxMacchina);

        /// <summary>
        /// Imposta i parametri correnti (ObjItemDTO) nella cache Redis della macchina
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="currData">dati parametri da impostare</param>
        /// <returns>true se salvato</returns>
        Task<bool> MachineParamListSetAsync(string idxMacchina, List<ObjItemDTO> currData);

        /// <summary>
        /// Effettua l'UPSERT degli elementi dei parametri macchina in Redis
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="innovations">nuovi elementi da aggiungere/aggiornare</param>
        /// <returns>true se completato</returns>
        Task<bool> MachineParamUpsertAsync(string idxMacchina, List<ObjItemDTO> innovations);

        /// <summary>
        /// Restituisce i campi DatiMacchine + StatoMacchine come dizionario (da Redis o DB)
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <returns>Dizionario KVP dei campi macchina</returns>
        Task<Dictionary<string, string>> mDatiMacchineAsync(string idxMacchina);

        /// <summary>
        /// Restituisce i parametri ottimizzati per la macchine (Redis hash sync)
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <returns>Dizionario KVP parametri</returns>
        Dictionary<string, string> mOptParMacchina(string idxMacchina);

        /// <summary>
        /// Restituisce i task salvati della macchina (Redis hash sync)
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <returns>Dizionario KVP dei task salvati</returns>
        Dictionary<string, string> mSavedTaskMacchina(string idxMacchina);

        /// <summary>
        /// Restituisce l'elenco dalla tabella MappaStatoExpl, con o senza cache
        /// </summary>
        /// <param name="forceDb">se true forza lettura database senza cache</param>
        /// <returns>Lista di MappaStatoExplModel</returns>
        Task<List<MappaStatoExplModel>> MseGetAllAsync(bool forceDb = false);

        /// <summary>
        /// Restituisce il dizionario KVP della tabella Multi State Machine Ingressi (da Redis)
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <returns>Array di KeyValuePair</returns>
        Task<KeyValuePair<string, string>[]> mTabMSMIAsync(string idxMacchina);

        /// <summary>
        /// Restituisce i task in esecuzione per la macchina (Redis hash sync)
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <returns>Dizionario KVP dei task</returns>
        Dictionary<string, string> mTaskMacchina(string idxMacchina);

        /// <summary>
        /// Restituisce i task in esecuzione per la macchina (Redis hash async)
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <returns>Dizionario KVP dei task</returns>
        Task<Dictionary<string, string>> mTaskMacchinaAsync(string idxMacchina);

        /// <summary>
        /// Generazione automatica ODL giornalieri per la macchina
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="dataInizio">data di inizio generazione</param>
        /// <param name="dataFine">data di fine generazione</param>
        /// <param name="codArticolo">codice articolo</param>
        /// <returns>true se generato con successo</returns>
        Task<bool> OdlAutoDayGenAsync(string idxMacchina, DateTime dataInizio, DateTime dataFine, string codArticolo);

        /// <summary>
        /// Generazione automatica ODL giornalieri completa con tutti i parametri PO/TC
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="dataInizio">data inizio</param>
        /// <param name="dataFine">data fine</param>
        /// <param name="codArticolo">codice articolo</param>
        /// <param name="pzPODL">pezzi per PODL</param>
        /// <param name="pzPallet">pezzi per pallet</param>
        /// <param name="keyRichiesta">chiave richiesta</param>
        /// <param name="tcAssegnato">TC assegnato</param>
        /// <param name="codGruppo">codice gruppo</param>
        /// <param name="flgCreaPODL">flag crea PODL</param>
        /// <param name="flgCheckTC">flag verifica TC</param>
        /// <returns>true se generato con successo</returns>
        Task<bool> OdlAutoDayGenFullAsync(string idxMacchina, DateTime dataInizio, DateTime dataFine, string codArticolo, int? pzPODL, int? pzPallet, string? keyRichiesta, int? tcAssegnato, string? codGruppo, bool flgCreaPODL, bool flgCheckTC);

        /// <summary>
        /// Restituisce l'ODL corrente per macchina, con cache Fusion
        /// </summary>
        /// <param name="IdxMacchina">idx macchina</param>
        /// <returns>Modello ODLExpModel</returns>
        Task<ODLExpModel> OdlCurrByMaccAsync(string IdxMacchina);

        /// <summary>
        /// Restituisce il modello PODL dato il suo indice, con cache Fusion
        /// </summary>
        /// <param name="idxPODL">indice PODL</param>
        /// <returns>Modello PODLModel</returns>
        Task<PODLModel> POdlGetByKey(int idxPODL);

        /// <summary>
        /// Restituisce i PODL per macchina/articolo, con cache Fusion
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="codArticolo">codice articolo</param>
        /// <param name="codGruppo">codice gruppo</param>
        /// <param name="onlyFree">solo PODL liberi</param>
        /// <returns>Lista di PODLExpModel</returns>
        Task<List<PODLExpModel>> POdlGetByMaccArtAsync(string idxMacchina, string codArticolo, string codGruppo, bool onlyFree);

        /// <summary>
        /// Processa la registrazione di un flusso (FL) da IOB
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="flux">codice flusso (es. Ingresso, Uscita)</param>
        /// <param name="valore">valore valOut del flusso</param>
        /// <param name="dtEve">data-ora dell'evento (macchina)</param>
        /// <param name="dtCurr">data-ora corrente (server)</param>
        /// <param name="contatore">contatore invio</param>
        /// <param name="disabKA">se true disabilita la scrittura del keepalive</param>
        /// <returns>"OK" se completato</returns>
        Task<string> ProcessFluxLogAsync(string idxMacchina, string flux, string valore, string dtEve, string dtCurr, int contatore, bool disabKA);

        /// <summary>
        /// Processa un input completo da IOB (verifica parametri, log segnali, processing microstato)
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="valore">valore valOut</param>
        /// <param name="dtEve">data-ora evento (macchina)</param>
        /// <param name="dtCurr">data-ora corrente (server)</param>
        /// <param name="contatore">contatore</param>
        /// <returns>"OK" se completato, error message in caso contrario</returns>
        Task<string> ProcessInputAsync(string idxMacchina, string valore, string dtEve, string dtCurr, string contatore);

        /// <summary>
        /// Processa un UserLog registrato da IOB (DI=dichiarazioni, RC=controlli, RS=scarti)
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="flux">tipo flusso: DI (Dichiarazione), RC (Controllo), RS (Scarto)</param>
        /// <param name="valore">valore/testo</param>
        /// <param name="dtEve">data-ora evento</param>
        /// <param name="dtCurr">data-ora corrente</param>
        /// <param name="contatore">contatore invio dati</param>
        /// <param name="matrOpr">matricola operatore</param>
        /// <param name="label">causale scarto o tagCode</param>
        /// <param name="valNum">esitoOk (0/1) o quantit\u00e0 scarto</param>
        /// <returns>"OK" se completato</returns>
        Task<string> ProcessUserLogAsync(string idxMacchina, string flux, string valore, string dtEve, string dtCurr, int contatore, int matrOpr, string label, int valNum);

        /// <summary>
        /// Restituisce il contapezzi salvato in Redis per la macchina
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <returns>Contatore pezzi (-1 se non trovato)</returns>
        Task<int> pzCounter(string idxMacchina);

        /// <summary>
        /// Restituisce il contapezzi come conteggio da TCRilevati (dal DB)
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <returns>Conteggio pezzi (-1 se non trovato)</returns>
        Task<int> PzCounterTcAsync(string idxMacchina);

        /// <summary>
        /// Ricerca la ricetta su MongoDB dato l'indice del PODL
        /// </summary>
        /// <param name="idxPODL">indice PODL di riferimento</param>
        /// <returns>Modello ricetta o null</returns>
        Task<RecipeModel?> RecipeGetByPODL(int idxPODL);

        /// <summary>
        /// Effettua il conteggio delle chiavi Redis che corrispondono a un pattern
        /// </summary>
        /// <param name="keyPattern">pattern di ricerca</param>
        /// <returns>Numero di chiavi trovate</returns>
        int RedisCountKey(string keyPattern);

        /// <summary>
        /// Elimina una chiave dalla memoria Redis
        /// </summary>
        /// <param name="keyVal">chiave da eliminare</param>
        /// <returns>true se eliminata</returns>
        bool RedisDelKey(string keyVal);

        /// <summary>
        /// Elimina una chiave dalla memoria Redis (async)
        /// </summary>
        /// <param name="keyVal">chiave da eliminare</param>
        /// <returns>true se eliminata</returns>
        Task<bool> RedisDelKeyAsync(RedisKey keyVal);

        /// <summary>
        /// Esegue il flush di tutte le chiavi Redis che corrispondono a un pattern
        /// </summary>
        /// <param name="pattern">pattern di ricerca</param>
        /// <returns>true se completato</returns>
        Task<bool> RedisFlushPatternAsync(RedisValue pattern);

        /// <summary>
        /// Leggo un hash Redis come array di KeyValuePair (sync)
        /// </summary>
        /// <param name="redKey">chiave Redis</param>
        /// <returns>Array di KeyValuePair</returns>
        KeyValuePair<string, string>[] RedisGetHash(RedisKey redKey);

        /// <summary>
        /// Leggo un hash Redis come array di KeyValuePair (async)
        /// </summary>
        /// <param name="redKey">chiave Redis</param>
        /// <returns>Array di KeyValuePair</returns>
        Task<KeyValuePair<string, string>[]> RedisGetHashAsync(RedisKey redKey);

        /// <summary>
        /// Leggo un hash Redis come dizionario (sync)
        /// </summary>
        /// <param name="hashKey">chiave Redis</param>
        /// <returns>Dizionario KVP</returns>
        Dictionary<string, string> RedisGetHashDict(RedisKey hashKey);

        /// <summary>
        /// Leggo un hash Redis come dizionario (async)
        /// </summary>
        /// <param name="hashKey">chiave Redis</param>
        /// <returns>Dizionario KVP</returns>
        Task<Dictionary<string, string>> RedisGetHashDictAsync(RedisKey hashKey);

        /// <summary>
        /// Leggo un singolo campo di un hash Redis (async)
        /// </summary>
        /// <param name="key">chiave Redis</param>
        /// <param name="hashField">nome campo hash</param>
        /// <returns>Valore del campo</returns>
        Task<RedisValue> RedisGetHashFieldAsync(RedisKey key, string hashField);

        /// <summary>
        /// Verifica se una chiave esista in Redis (sync)
        /// </summary>
        /// <param name="key">chiave Redis</param>
        /// <returns>true se la chiave esiste</returns>
        bool RedisKeyPresent(RedisKey key);

        /// <summary>
        /// Verifica se una chiave esista in Redis (async)
        /// </summary>
        /// <param name="key">chiave Redis</param>
        /// <returns>true se la chiave esiste</returns>
        Task<bool> RedisKeyPresentAsync(RedisKey key);

        /// <summary>
        /// Imposta un hash Redis con expiration opzionale (sync)
        /// </summary>
        /// <param name="redKey">chiave Redis</param>
        /// <param name="valori">array di coppie chiave-valore da inserire</param>
        /// <param name="expireSeconds">TTL in secondi (-1 = nessuna expiration)</param>
        void RedisSetHash(RedisKey redKey, KeyValuePair<string, string>[] valori, double expireSeconds = -1.0);

        /// <summary>
        /// Imposta un hash Redis con expiration opzionale (async)
        /// </summary>
        /// <param name="redKey">chiave Redis</param>
        /// <param name="valori">array di coppie chiave-valore da inserire</param>
        /// <param name="expireSeconds">TTL in secondi (-1 = nessuna expiration)</param>
        Task RedisSetHashAsync(RedisKey redKey, KeyValuePair<string, string>[] valori, double expireSeconds = -1.0);

        /// <summary>
        /// Imposta un hash Redis con expiration opzionale (sync) da dizionario
        /// </summary>
        /// <param name="redKey">chiave Redis</param>
        /// <param name="valori">dizionario di coppie chiave-valore da inserire</param>
        /// <param name="expireSeconds">TTL in secondi (-1 = nessuna expiration)</param>
        void RedisSetHashDict(RedisKey redKey, Dictionary<string, string> valori, double expireSeconds = -1.0);

        /// <summary>
        /// Imposta un hash Redis con expiration opzionale (async) da dizionario
        /// </summary>
        /// <param name="redKey">chiave Redis</param>
        /// <param name="valori">dizionario di coppie chiave-valore da inserire</param>
        /// <param name="expireSeconds">TTL in secondi (-1 = nessuna expiration)</param>
        Task RedisSetHashDictAsync(RedisKey redKey, Dictionary<string, string> valori, double expireSeconds = -1.0);

        /// <summary>
        /// Inserimento record RemoteRebootLog con eventuale pulizia dei record vecchi
        /// </summary>
        /// <param name="newRec">record da inserire</param>
        /// <returns>true se completato</returns>
        Task<bool> RemRebootLogAddAsync(RemoteRebootLogModel newRec);

        /// <summary>
        /// Elimina un task da elenco Redis per l'impianto indicato
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="tName">nome task da eliminare</param>
        /// <returns>Dizionario KVP rimanente</returns>
        Task<Dictionary<string, string>> RemTask2ExeMacchinaAsync(string idxMacchina, taskType tName);

        /// <summary>
        /// Resetta la tabella Multi State Machine Ingressi per macchina rileggendola dal DB
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <returns>Array di KVP della State Machine Ingressi</returns>
        Task<KeyValuePair<string, string>[]> resetMSMIAsync(string idxMacchina);

        /// <summary>
        /// Registra la movimentazione di un carico pezzi su Redis
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="qty">quantit\u00e0 da registrare</param>
        /// <returns>"OK" se completato</returns>
        Task<string> saveCaricoPezzi(string idxMacchina, string qty);

        /// <summary>
        /// Salva un elenco di dati macchina in DB
        /// </summary>
        /// <param name="id">identificativo della serie dati</param>
        /// <param name="dataList">elenco di dati macchina da salvare</param>
        /// <returns>true se salvato</returns>
        Task<bool> SaveDataItemsAsync(string id, List<MachDataItem> dataList);

        /// <summary>
        /// Salva i dati macchina-IOB (serializzazione JSON) su Redis
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="serData">dati JSON serializzati</param>
        /// <returns>true se salvato</returns>
        Task<bool> SaveMachine2Iob(string idxMacchina, string serData);

        /// <summary>
        /// Salva la configurazione della macchina come dizionario su Redis
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="currDict">dizionario di configurazione</param>
        /// <returns>true se salvato</returns>
        Task<bool> SaveMachineIobConf(string idxMacchina, Dictionary<string, string> currDict);

        /// <summary>
        /// Salva il segnale di "microstato" come record SignalLog su DB (async)
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="valore">valOut ingresso</param>
        /// <param name="dtEve">data-ora evento (server)</param>
        /// <param name="contatore">contatore sequenza dati inviati</param>
        /// <returns>true se salvato</returns>
        Task<bool> saveSigLogAsync(string idxMacchina, string valore, DateTime dtEve, int contatore);

        /// <summary>
        /// Scrive un evento di keepalive se non presente in Redis con TTL
        /// </summary>
        /// <param name="IdxMacchina">idx macchina</param>
        /// <param name="oraMacchina">ora macchina</param>
        Task ScriviKeepAliveAsync(string IdxMacchina, DateTime oraMacchina);

        /// <summary>
        /// Salva la configurazione YAML completa dell'IOB su Redis
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="iobConfFull">configurazione YAML completa</param>
        /// <returns>true se salvata</returns>
        Task<bool> SetIobConfYamlAsync(string idxMacchina, string iobConfFull);

        /// <summary>
        /// Salva la mappatura memoria PLC su Redis
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="currMap">mappatura PLC da salvare</param>
        /// <returns>true se salvata</returns>
        Task<bool> SetIobMemMap(string idxMacchina, PlcMemMapDto currMap);

        /// <summary>
        /// Restituisce la tabella key-value della State Machine Ingressi per famiglia,
        /// rileggendola dal DB e salvandola in Redis
        /// </summary>
        /// <param name="idxFamIn">idx famiglia ingressi</param>
        /// <returns>Array di KVP (currentMicroStato_nVal -> IdxTipoEv_nStato)</returns>
        Task<KeyValuePair<string, string>[]> StateMachInByKeyAsync(int idxFamIn);

        /// <summary>
        /// Effettua l'UPSERT degli oggetti corrente della macchina su Redis (legacy compatibilit\u00e0)
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="innovations">dati da aggiornare/aggiungere</param>
        /// <returns>true se completato</returns>
        Task<bool> UpsertCurrObjItemsAsync(string idxMacchina, List<ObjItemDTO> innovations);

        /// <summary>
        /// Restituisce il valore SPECIFICATO per la state machine ingressi in formato hash Redis
        /// </summary>
        /// <param name="idxFamIn">idx famiglia ingressi</param>
        /// <param name="idxMicroStato">idx microstato</param>
        /// <param name="valoreIn">valore ingresso</param>
        /// <returns>valore (IdxFamIn_nValore) dalla tab SMI Redis</returns>
        Task<string> ValoreSmiAsync(int idxFamIn, int idxMicroStato, int valoreIn);

        #endregion Public Methods
    }
}