using IOB_UT_NEXT.Config;
using IOB_UT_NEXT.Config.Mem;
using IOB_UT_NEXT.Objects;
using IOB_UT_NEXT.Services.Cache;
using IOB_UT_NEXT.Services.Core;
using IOB_UT_NEXT.Services.Data;
using IOB_UT_NEXT.Services.Files;
using MapoSDK;
using Newtonsoft.Json;
using NLog;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net.NetworkInformation;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text.Json;
using System.Text.Json.Serialization;
using static IOB_UT_NEXT.Config.BaseAlarmConf;

namespace IOB_UT_NEXT.Iob
{
    /// <summary>
    /// Classe di base per IOB
    /// </summary>
    public class BaseObj
    {
        #region Public Fields

        /// <summary>
        /// valore booleano di check se sia stato AVVIATO l'adapter (Running)
        /// </summary>
        public bool adpRunning = false;

        /// <summary>
        /// valore booleano di check se l'adapter STIA SALVANDO
        /// </summary>
        public bool adpSaving = false;

        /// <summary>
        /// valore booleano (richiesta di riavvio automatico)
        /// </summary>
        public bool adpTryRestart;

        /// <summary>
        /// Livello minimo allarmi da considerare x invio
        /// </summary>
        public AlarmLevel alarmLevelMin = AlarmLevel.Alarm;

        /// <summary>
        /// Struttura allarmi mappati
        /// </summary>
        public List<BaseAlarmConf> alarmMaps = new List<BaseAlarmConf>();

        /// <summary>
        /// Tipo di allarmi gestiti
        /// rif: BaseAlarmConf.AlarmBlockType.[Bitmap/ActiveList]
        /// </summary>
        public AlarmBlockType alarmType = AlarmBlockType.Bitmap;

        /// <summary>
        /// Conteggio ATTUALE ore macchina IN LAVORO
        /// </summary>
        public double contOreMaccLav;

        /// <summary>
        /// Conteggio ATTUALE ore macchina ON
        /// </summary>
        public double contOreMaccOn;

        /// <summary>
        /// contatore x simulazione valori input
        /// </summary>
        public int countSim = 0;

        /// <summary>
        /// ODL attualmente sulla macchina
        /// </summary>
        public Int32 currIdxODL = 0;

        /// <summary>
        /// Modo corrente (da classe ENUM)
        /// </summary>
        public CNC_MODE currMode;

        /// <summary>
        /// ODL corrente caricato sulla macchina (stringa, da chiamata MP/IO)
        /// </summary>
        public string currODL = "";

        /// <summary>
        /// Indica se sia richiesto campionamento memoria PERIODICO
        /// </summary>
        public bool doSampleMemory;

        /// <summary>
        /// Indica se si debba leggere e fare DUMP delle aree di memoria (1 volta solo all'avvio x debug...)
        /// </summary>
        public bool doStartMemDump;

        /// <summary>
        /// Collettore di tutte le variabili scadenza DateTime
        /// </summary>
        public DateTimeHelper DtHelp;

        /// <summary>
        /// Abilitazione lettura PrgName
        /// </summary>
        public bool enablePrgName = true;

        /// <summary>
        /// Abilitazione invio pezzi "in blocco" per recupero contapezzi
        /// </summary>
        public bool enableSendPzCountBlock = false;

        /// <summary>
        /// Determina se sia encessario convertire valori little/big endian (SIEMENS=true, OSAI=FALSE)
        /// </summary>
        public bool hasBigEndian = false;

        /// <summary>
        /// Configurazione gerarchica completa (v 4.x.x.x)
        /// </summary>
        public IobConfTree IOBConfFull;

        /// <summary>
        /// dataOra ultima verifica CNC disconnesso...
        /// </summary>
        public DateTime lastDisconnCheck;

        /// <summary>
        /// Data/ora ultima volta che IOB è stato dichiarato online
        /// </summary>
        public DateTime lastIobOnline = DateTime.Now.AddHours(-1);

        /// <summary>
        /// Ultima verifica status IOB x forzare display status SRV
        /// </summary>
        public DateTime lastIobStatusDisplUpdate = DateTime.Now;

        /// <summary>
        /// dataOra ultimo log periodico...
        /// </summary>
        public DateTime lastPeriodicLog;

        /// <summary>
        /// dataOra ultimo PING inviato verso il PLC...
        /// </summary>
        public DateTime lastPING = DateTime.Now.AddHours(-1);

        /// <summary>
        /// DataOra ultima lettura da PLC
        /// </summary>
        public DateTime lastReadPLC;

        /// <summary>
        /// ULtimo valore inviato (in caso di disconnessione lo reinvia x garantire watchdog...)
        /// </summary>
        public string lastSignInVal = "";

        /// <summary>
        /// DateTime Ultimo valore simulazione generato
        /// </summary>
        public DateTime lastSim;

        /// <summary>
        /// dataOra ultimo segnale inviato al SERVER...
        /// </summary>
        public DateTime lastWatchDog;

        /// <summary>
        /// dataOra ultimo segnale inviato a macchina/PLC...
        /// </summary>
        public DateTime lastWatchDogPLC = DateTime.Now;

        /// <summary>
        /// Massimo numero di px da inviare in blocco
        /// </summary>
        public int maxSendPzCountBlock = 10;

        /// <summary>
        /// Struttura memoria PLC x lettura/scrittura da JSON file
        /// </summary>
        public plcMemMapExt memMap;

        /// <summary>
        /// Minimo numero di px da inviare in blocco
        /// </summary>
        public int minSendPzCountBlock = 1;

        /// <summary>
        /// Variabile booleana che indica se sia necessario fare refresh del contapezzi
        /// </summary>
        public bool needRefreshPzCount = true;

        /// <summary>
        /// Determina se utilizzare blocchi di memoria IOT contigui (e quindi processing
        /// "monoblocco" semplificato"=
        /// </summary>
        public bool procIotMem = false;

        /// <summary>
        /// Coda valori ALLARMI ove gestiti...
        /// </summary>
        public DataQueue QueueAlarm;

        /// <summary>
        /// Oggetto della coda degli elementi letti di tipo FluxLog (e non ancora trasmessi)
        /// </summary>
        public DataQueue QueueFLog;

        /// <summary>
        /// Oggetto della coda degli elementi letti (e non ancora trasmessi)
        /// </summary>
        public DataQueue QueueIN;

        /// <summary>
        /// Coda valori MESSAGGI/EVENTI (da non sottocampionare come samples)...
        /// </summary>
        public DataQueue QueueMessages;

        /// <summary>
        /// Coda degli esiti di ping x calcolo stato macchina
        /// </summary>
        public DataQueue QueuePing;

        /// <summary>
        /// Oggetto della coda degli elementi di tipo RawTransf (e non ancora trasmessi)
        /// NB: sono salvati serializzati come stringhe
        /// </summary>
        public DataQueue QueueRawTransf;

        /// <summary>
        /// Coda delle richieste dal server (Task2Exe)
        /// </summary>
        public DataQueue QueueSrvReq;

        // = new DataQueue("000", "QueueRawTransf", false);
        /// <summary>
        /// Coda delle risposte al server (Task2Exe)
        /// </summary>
        public DataQueue QueueSrvResp;

        /// <summary>
        /// Coda valori LOG UTENTE (da non sottocampionare come samples)...
        /// </summary>
        public DataQueue QueueULog;

        /// <summary>
        /// alias booleano false = R
        /// </summary>
        public bool R = false;

        // = new DataQueue("000", "QueueULog", false);
        /// <summary>
        /// 32 byte input base (es strobe, 8 word da 32 bit di flags...)
        /// </summary>
        public byte[] RawInput = new byte[32];

        /// <summary>
        /// 32 byte output base (es ack, 8 word da 32 bit di flags...)
        /// </summary>
        public byte[] RawOutput = new byte[32];

        /// <summary>
        /// Oggetto connessione REDIS
        /// </summary>
        public RedisIobCache redisMan;

        /// <summary>
        /// Oggetto cronometro x campionamento durate chiamate
        /// </summary>
        public Stopwatch sw = new Stopwatch();

        /// <summary>
        /// Imposta veto lettura dati (es per DB a 2 sec)
        /// </summary>
        public DateTime vetoDataRead = DateTime.Now;

        /// <summary>
        /// Imposta veto SYNC dati (es per DB 2 DB a 10 sec)
        /// </summary>
        public DateTime vetoDataSync = DateTime.Now;

        /// <summary>
        /// Veto (in sec) a nuovi ping (x IOB PING, FTP...)
        /// </summary>
        public int vetoPingSec = 1;

        /// <summary>
        /// Veto specifico per la gestione (svuotamento) coda contapezzi (es in fase di attrezzaggio e reset lenti)
        /// Tipicamente impostato a DelayReadPzCountSetup dopo attrezzaggio...
        /// </summary>
        public DateTime vetoQueuePzCount = DateTime.Now;

        /// <summary>
        /// Imposta veto chiamata split (durante chiamata, per 60 sec)
        /// </summary>
        public DateTime vetoSplit = DateTime.Now.AddMinutes(1);

        /// <summary>
        /// alias booleano true = W
        /// </summary>
        public bool W = true;

        #endregion Public Fields

        #region Public Properties

        /// <summary>
        /// Verifica se sia in modalità DEMO avanzata (campionamento da set di valori ammessi...)
        /// </summary>
        public static bool DemoInSample => baseUtils.CRB("DemoInSample");

        /// <summary>
        /// Verifica se sia in modalità DEMO x dati OUTPUT
        /// </summary>
        public static bool DemoOut => utils.CRB("DemoOut");

        /// <summary>
        /// Indicazione VETO PING a server sino alla data-ora indicata
        /// </summary>
        public static DateTime dtVetoPing
        {
            get => utils.dtVetoPing;
            set => utils.dtVetoPing = value;
        }

        /// <summary>
        /// Indicazione VETO accodamento valori INGRESSI/EVENTI sino alla data-ora indicata
        /// </summary>
        public static DateTime dtVetoQueueIN
        {
            get => utils.dtVetoQueueIN;
            set => utils.dtVetoQueueIN = value;
        }

        /// <summary>
        /// Indicazione VETO invio a server sino alla data-ora indicata
        /// </summary>
        public static DateTime dtVetoSend
        {
            get => utils.dtVetoSend;
            set => utils.dtVetoSend = value;
        }

        /// <summary>
        /// Verifica se sia abilitato test lettura blocchi memoria all'avvio
        /// </summary>
        public static bool EnableTest => baseUtils.CRB("enableTest");

        /// <summary>
        /// stato Online/Offline del server MP IO (su REDIS)
        /// </summary>
        public static bool MPOnline
        {
            get => utils.MPIO_Online;
            set => utils.MPIO_Online = value;
        }

        #endregion Public Properties

        #region Public Methods

        /// <summary>
        /// processa dataLayer e se necessario salva/mostra
        /// </summary>
        public static void checkSavePersDataLayer()
        {
        }

        public static string GetMACAddress()
        {
            NetworkInterface[] nics = NetworkInterface.GetAllNetworkInterfaces();
            String sMacAddress = string.Empty;
            foreach (NetworkInterface adapter in nics)
            {
                if (string.IsNullOrEmpty(sMacAddress))// only return MAC Address from first card
                {
                    IPInterfaceProperties properties = adapter.GetIPProperties();
                    //sMacAddress = adapter.GetPhysicalAddress().ToString();
                    sMacAddress = string.Join(":", (from z in adapter.GetPhysicalAddress().GetAddressBytes() select z.ToString("X2")).ToArray());
                }
            }
            return sMacAddress;
        }

        #endregion Public Methods

        #region Protected Fields

        /// <summary>
        /// Variabile numero errori vari (in lettura) --&gt; se supera soglia maxErroriCheck --&gt; disconnette
        /// </summary>
        protected static int numErroriCheck = 0;

        /// <summary>
        /// Valore di attesa (random) dopo ogni invio x evitare congestione send...
        /// </summary>
        protected static int urlRandWait = 0;

        /// <summary>
        /// Stato connessione con macchina gestita
        /// </summary>
        protected bool _connOk = false;

        /// <summary>
        /// valore booleano di check se sia in fase di COMUNICAZIONE ATTIVA con il PLC/NC
        /// </summary>
        protected bool adpCommAct;

        /// <summary>
        /// porta x adapter (x restart)
        /// </summary>
        protected int adpPortNum;

        /// <summary>
        /// DataOra ultimo avvio adapter x watchdog
        /// </summary>
        protected DateTime adpStartRun;

        /// <summary>
        /// Vettore 32 BIT valori in ingresso al filtro
        /// </summary>
        protected int B_input;

        /// <summary>
        /// Vettore 32 BIT valori in uscita dal filtro
        /// </summary>
        protected int B_output;

        /// <summary>
        /// Vettore 32 BIT valori precedenti
        /// </summary>
        protected int B_previous = -1;

        /// <summary>
        /// Cod grupo IOB x creazione PODL al volo
        /// </summary>
        protected string CodGruppoIob = "ND-00";

        /// <summary>
        /// Num errori check alive
        /// </summary>
        protected int currAliveErrors = 0;

        /// <summary>
        /// Dizionario valori impostati x produzione
        /// </summary>
        protected Dictionary<string, string> currProdData = new Dictionary<string, string>();

        /// <summary>
        /// num corrente errori read PLC
        /// </summary>
        protected int currReadErrors = 0;

        /// <summary>
        /// num errori send
        /// </summary>
        protected int currSendErrors = 0;

        /// <summary>
        /// Tempo di attesa in minuti x lettura contapezzi standard (da .ini / OptPar)
        /// </summary>
        protected double delayMinReadPzCount = 0;

        /// <summary>
        /// Fattore di demoltiplicazione dei DynData x ridurre campionamento
        /// </summary>
        protected int demFactDynData = 1;

        /// <summary>
        /// Disabilitazione gestione ODL (lettura e gestione)
        /// </summary>
        protected bool disableOdl = false;

        /// <summary>
        /// Boolean x indicare contapezzi disabilitato forzatamente da IOB
        /// </summary>
        protected bool disablePzCountByIob = false;

        /// <summary>
        /// Veto x esecuzione task AutoDossier
        /// </summary>
        protected DateTime dtVetoAutoDossier = DateTime.Now;

        /// <summary>
        /// Veto x lettura contapezzi (in caso di autoODL con attesa reset ad esempio...)
        /// </summary>
        protected DateTime dtVetoReadPzCount = DateTime.Now;

        /// <summary>
        /// DataOra x veto all'invio dataItem
        /// </summary>
        protected DateTime dtVetoSenDataItem = DateTime.Now;

        /// <summary>
        /// Veto x esecuzione Task2Exe troppo frequenti
        /// </summary>
        protected DateTime dtVetoTask2Exe = DateTime.Now;

        /// <summary>
        /// Determina se sia prevista gestione PODL (creazione/avvio/chiusura) come Soitaab
        /// </summary>
        protected bool EnabelPodlManFull = false;

        /// <summary>
        /// Abilita riscrittura memoria se trova differenze lettura/richiesti
        /// </summary>
        protected bool ENABLE_MEM_REWRITE = true;

        /// <summary>
        /// Abilitazione restart (da opt par...)
        /// </summary>
        protected bool enableCliRestart = false;

        /// <summary>
        /// Boolean x indicare contapezzi abilitato a livello di conf applicazione
        /// </summary>
        protected bool enablePzCountByApp = true;

        /// <summary>
        /// Abilitazione invio dataitem
        /// </summary>
        protected bool enableSendDataItem = true;

        /// <summary>
        /// Abilitazione gestione slow data
        /// </summary>
        protected bool enableSlowData = false;

        //protected static Logger lg = LogManager.GetCurrentClassLogger();
        /// <summary>
        /// Abilitazione invio conf macchine
        /// </summary>
        protected bool enabSendMachineConf = true;

        /// <summary>
        /// dizionario (opzionale) xz decodifica file da importare
        /// </summary>
        protected Dictionary<string, int> FileDecod = new Dictionary<string, int>();

        /// <summary>
        /// DeadBand x riduzione dati FluxLog (se 0 non gestita)
        /// </summary>
        protected double fluxLogRedDeadBand = 0;

        /// <summary>
        /// Determina se sia gestita riduzione dati FluxLog
        /// </summary>
        protected bool fluxLogReduce = false;

        /// <summary>
        /// Dizionario dei valori FluxLog ultimi verificati x veto
        /// </summary>
        protected Dictionary<string, double> fluxLogReduceLast = new Dictionary<string, double>();

        /// <summary>
        /// Dizionario dei valori FluxLog ultimi tipo STRING verificati x veto
        /// </summary>
        protected Dictionary<string, string> fluxLogReduceLastString = new Dictionary<string, string>();

        /// <summary>
        /// Dizionario dei veto send x ogni variabile quando non variata
        /// </summary>
        protected Dictionary<string, DateTime> fluxLogReduceVeto = new Dictionary<string, DateTime>();

        /// <summary>
        /// Finestra in minuti x invio dati FluxLog quando invariati
        /// </summary>
        protected int fluxLogResendPeriod = 60;

        /// <summary>
        /// indica che è richiesto forzatamente reset contapezzi
        /// </summary>
        protected bool forcePzReset = false;

        /// <summary>
        /// indica che è richiesto forzatamente reset contapezzi
        /// </summary>
        protected DateTime forcePzResetUntil = DateTime.Now.AddMinutes(-1);

        /// <summary>
        /// DEADBAND globale se impostata (es x gestire variazioni minime valori FluxLog da inviare...)
        /// </summary>
        protected float GLOBAL_DBAND = 0;

        /// <summary>
        /// Determina se siano gestite le ricette
        /// </summary>
        protected bool hasRecipe = false;

        /// <summary>
        /// Array dei contatori x segnali blinking
        /// </summary>
        protected int[] i_counters;

        /// <summary>
        /// Indica impianto IN SETUP (fino a quando SMETTE di esserlo...)
        /// </summary>
        protected bool inSetup = false;

        /// <summary>
        /// ultimo tentativo connessione...
        /// </summary>
        protected DateTime lastConnectTry;

        /// <summary>
        /// Ultimo LOG registrazione avvio (x ridurre log notturni...)
        /// </summary>
        protected DateTime lastLogStartup = DateTime.Today.AddHours(-1);

        /// <summary>
        /// Dizionario ULTIMI valori impostati x produzione
        /// </summary>
        protected Dictionary<string, string> lastProdData = new Dictionary<string, string>();

        /// <summary>
        /// Ultimo invio contapezzi (x invio delayed)
        /// </summary>
        protected DateTime lastPzCountSend;

        /// <summary>
        /// Dizionario ultimi valori (string) delle TSS
        /// </summary>
        protected Dictionary<string, string> LastTSS = new Dictionary<string, string>();

        /// <summary>
        /// Dizionario ultimi valori (string) delle TSS
        /// </summary>
        protected Dictionary<string, DateTime> LastTSSSend = new Dictionary<string, DateTime>();

        /// <summary>
        /// Dizionario ultimi valori (double) delle TSVC
        /// </summary>
        protected Dictionary<string, double> LastTSVC = new Dictionary<string, double>();

        /// <summary>
        /// Ultima registrazione warning x ODL mancante (x scrivere solo ogni 15 secondi)
        /// </summary>
        protected DateTime lastWarnODL;

        /// <summary>
        /// ultima data-ora invio parametri write x ribadire status
        /// </summary>
        protected DateTime lastWriteParamsUpsert = DateTime.Now;

        /// <summary>
        /// Separatore linea (tipicamente x commenti)
        /// </summary>
        protected string lineSep = "--------------------------";

        /// <summary>
        /// Elenco parametri calcolati da inviare alla macchina (es ricetta con traduzione, RAMA/TFT)
        /// </summary>
        protected List<objItem> list2Write = new List<objItem>();

        /// <summary>
        /// Elenco delle eventuali condizioni di veto conditions attive
        /// </summary>
        protected List<string> ListVetoCond = new List<string>();

        /// <summary>
        /// Num massimo di errori in funzionalità check alive
        /// </summary>
        protected int maxAliveErrors = utils.CRI("maxAliveErrors");

        /// <summary>
        /// Soglia massima errori prima della disconnessione automatica in check
        /// </summary>
        protected int maxErroriCheck = utils.CRI("maxErroriCheck");

        /// <summary>
        /// Quantità massima per singola ricetta (per determinare num ricette da inviare)
        /// </summary>
        protected int maxQtyPerFile = 0;

        /// <summary>
        /// Dimensione coda di ping x valutazione
        /// </summary>
        protected int maxQueuePing = 11;

        /// <summary>
        /// Num massimo di errori di rete read (dal PLC)
        /// </summary>
        protected int maxReadErrors = utils.CRI("maxReadErrors");

        /// <summary>
        /// Periodo massimo (in sec) per letture dati in mancanza di eventi di aggiornamento
        /// </summary>
        protected int MaxSecReload = 120;

        /// <summary>
        /// Num massimodi errori di rete send al server
        /// </summary>
        protected int maxSendErrors = utils.CRI("maxSendErrors");

        /// <summary>
        /// Numero massimo di tentativi x test ping preliminare
        /// </summary>
        protected int maxTryPing = 1;

        protected string mem2trace = "";

        /// <summary>
        /// Tempo minimo ammissibile di risposta (es x errori ModBus che risponde troppo in fretta) in millisec
        /// </summary>
        protected int minRespTimeMs = 5;

        protected int minVetoSendDataItem = 60;

        /// <summary>
        /// indica se serva refresh parametri e quindi PLC...
        /// </summary>
        protected bool needRefresh = true;

        /// <summary>
        /// Indica se usare la parte numerica di un articolo come codice INT
        /// </summary>
        protected bool numArtCharTrim = false;

        /// <summary>
        /// Timeout x ping al server
        /// </summary>
        protected int pingServerMsTimeout = utils.CRI("PingMsTimeout");

        /// <summary>
        /// DataOra avvio Programma x check avvio
        /// </summary>
        protected DateTime prgStarted = DateTime.Now;

        /// <summary>
        /// Ritardo minimo x invio contapezzi
        /// </summary>
        protected int pzCountDelay = 2500;

        /// <summary>
        /// Indica se resettare allarmi all'avvio e inviare il reset appena parte adapter
        /// </summary>
        protected bool resetAlarmOnStart = false;

        /// <summary>
        /// Periodo di campionamento x refresh info
        /// </summary>
        protected int samplePeriod = 1000;

        /// <summary>
        /// MsSample Period base x campionamenti tpo OCP-UA
        /// </summary>
        protected int samplePeriodBase = 600;

        /// <summary>
        /// Dizionario di VC da trattare come TimeSeries (con conf decodificata + processing successivo...)
        /// </summary>
        protected Dictionary<string, VCData> TSVC_Data = new Dictionary<string, VCData>();

        /// <summary>
        /// Indica se usare archivio locale ricette vs scarico http/REST
        /// </summary>
        protected bool useLocalRecipe = true;

        /// <summary>
        /// Dizionario di VARIABILI da trattare come eventi (da inviare quando cambiano oppure a
        /// scadenza periodo...)
        /// </summary>
        protected Dictionary<string, EVData> VarArray = new Dictionary<string, EVData>();

        /// <summary>
        /// Dizionario dei divieti di invio x ogni counter gestito
        /// </summary>
        protected Dictionary<string, DateTime> VetoCounterSend = new Dictionary<string, DateTime>();

        /// <summary>
        /// Veto per registrazione completa log di startup (minuti)
        /// </summary>
        protected int vetoLogStartupDuration = 60;

        /// <summary>
        /// Durata in secondi del divieto accodamento segnali IN alla fase di startup
        /// </summary>
        protected int vetoQueueIn = 10;

        /// <summary>
        /// Periodo di veto prima di invio nuova conferma dei valori write correnti, default ogni 5 min
        /// </summary>
        protected double vetoSendWriteUpsert = 1;

        /// <summary>
        /// Periodo wathdog di default (2 sec se non specificato)
        /// </summary>
        protected int watchDogPeriod = 2;

        #endregion Protected Fields

        #region Protected Properties

        /// <summary>
        /// Dizionario condizioni di veto log x ogni tipo di messaggio (periodo differente secondo livello)
        /// </summary>
        protected Dictionary<string, DateTime> VetoLog { get; set; } = new Dictionary<string, DateTime>();

        /// <summary>
        /// Dizionario conteggio numero volte che si fa veto log x ogni tipo di messaggio
        /// </summary>
        protected Dictionary<string, int> VetoLogCount { get; set; } = new Dictionary<string, int>();

        #endregion Protected Properties

        #region Protected Methods

        /// <summary>
        /// Decodifica file MAP (caso <paramref name="ByteNum" />.bit)
        /// </summary>
        /// <param name="linea"></param>
        /// <param name="separator"></param>
        /// <param name="ByteNum">indirizzo Byte: indirizzo di partenza memoria</param>
        /// <param name="memSize">dimensione singolo slot in byte</param>
        /// <param name="BitNum">indirizzo bit: numero riga x calcolo indice bit</param>
        /// <returns></returns>
        protected static otherData decodeBitData(string linea, char separator, int ByteNum, int memSize, int BitNum)
        {
            if (linea != null)
            {
                string[] valori = linea.Split(separator);
                int shift = 0;
                try
                {
                    shift = Convert.ToInt32(valori[0]) - 1;
                }
                catch
                { }
                int resto = 0;
                Math.DivRem(BitNum, 8, out resto);
                string memAddr = string.Format("{0}.{1}", ByteNum + shift * memSize, resto);
                return new otherData(valori[0], memAddr, valori[1].Trim(), valori[2].Trim());
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// Decodifica file MAP generico
        /// </summary>
        /// <param name="linea"></param>
        /// <param name="separator"></param>
        /// <param name="memPre"></param>
        /// <param name="baseAddr"></param>
        /// <param name="memSize"></param>
        /// <returns></returns>
        protected static otherData decodeOtherData(string linea, char separator, string memPre, int baseAddr, int memSize)
        {
            if (linea != null)
            {
                string[] valori = linea.Split(separator);
                int shift = 0;
                try
                {
                    shift = Convert.ToInt32(valori[0]) - 1;
                }
                catch
                { }
                string memAddr = string.Format("{0}{1}", memPre, baseAddr + shift * memSize);
                return new otherData(valori[0], memAddr, valori[1].Trim(), valori[2].Trim());
            }
            else
            {
                return null;
            }
        }

        protected static long GetObjectSize(object genObj, bool isSerializable)
        {
            long result = 0;
            if (isSerializable)
            {
                using (var stream = new MemoryStream())
                {
                    var formatter = new BinaryFormatter();
                    formatter.Serialize(stream, genObj);
                    result = stream.Length;
                }
            }
            else
            {
                string rawVal = System.Text.Json.JsonSerializer.Serialize(genObj, options);
                result = rawVal.Length;
            }
            return result;
        }

        /// <summary>
        /// Verifica se ci sia veto log attivo e gestisce casistiche
        /// </summary>
        /// <param name="vetoSec"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        protected bool checkLogVeto(int vetoSec, ref string message)
        {
            // verifico SE si debba fare log, altrimenti metto in coda...
            bool doVeto = true;
            try
            {
                DateTime adesso = DateTime.Now;
                if (VetoLog.ContainsKey(message))
                {
                    // conteggio num veto a +1...
                    if (VetoLogCount.ContainsKey(message))
                    {
                        VetoLogCount[message]++;
                    }
                    else
                    {
                        VetoLogCount.Add(message, 1);
                    }
                    // controllo scadenza, quando superata soglia aggiorno messaggio con {n} x {messaggio}
                    if (adesso.Subtract(VetoLog[message]).TotalSeconds > vetoSec)
                    {
                        doVeto = false;
                        string newMessage = $"{VetoLogCount[message]} x {message}";
                        VetoLog.Remove(message);
                        VetoLogCount.Remove(message);
                        message = newMessage;
                    }
                }
                else
                {
                    // primo --> loggo
                    doVeto = false;
                    VetoLog.Add(message, adesso.AddSeconds(vetoSec));
                    if (VetoLogCount.ContainsKey(message))
                    {
                        VetoLogCount[message]++;
                    }
                    else
                    {
                        VetoLogCount.Add(message, 0);
                    }
                }
            }
            catch (Exception exc)
            {
                lg.Error($"Eccezione in checkLogVeto: reset contatori VetoLog/VetoLogCount | message: {message}");
                lg.Error($"Raised Exc:{Environment.NewLine}{exc}");
                doVeto = false;
                // svuoto tutti i log veto...
                VetoLog = new Dictionary<string, DateTime>();
                VetoLogCount = new Dictionary<string, int>();
                lg.Error($"Effettuato reset contatori VetoLog/VetoLogCount");
            }
            // restituisco esito!
            return doVeto;
        }

        /// <summary>
        /// Recupera la chiave per le statistiche delle chiamate.
        /// </summary>
        protected string GetCallStatsKey() => redisMan.redHash($"IOB:Status:{IOBConfFull.General.FilenameIOB}:CallStats");

        /// <summary>
        /// Recupera la chiave per i dati di produzione correnti.
        /// </summary>
        protected string GetCurrProdDataKey() => redisMan.redHash($"IOB:Status:{IOBConfFull.General.FilenameIOB}:CurrProdData");

        /// <summary>
        /// Recupera la chiave per il flusso di memoria.
        /// </summary>
        protected string GetFluxMemKey() => redisMan.redHash($"IOB:Status:{IOBConfFull.General.FilenameIOB}:FluxMem");

        /// <summary>
        /// Recupera la chiave per l'invio dei PODL.
        /// </summary>
        protected string GetPOdlSentKey() => redisMan.redHash($"IOB:Status:{IOBConfFull.General.FilenameIOB}:POdlSent");

        /// <summary>
        /// Recupera un valore specifico dal hash dello stato dell'IOB.
        /// </summary>
        protected string GetStatusField(string field)
        {
            string baseKey = redisMan.redHash($"IOB:Status:{IOBConfFull.General.FilenameIOB}");
            return redisMan.redGetHashField(baseKey, field);
        }

        /// <summary>
        /// Recupera la chiave per le statistiche settimanali.
        /// </summary>
        protected string GetWeekStatsKey() => redisMan.redHash($"IOB:Status:{IOBConfFull.General.FilenameIOB}:WeekStats");

        /// <summary>
        /// Deserializza una stringa JSON in un oggetto.
        /// </summary>
        protected T JsonDeserialize<T>(string json) => DataSerializer.Deserialize<T>(json);

        /// <summary>
        /// Serializza un oggetto in formato JSON.
        /// </summary>
        protected string JsonSerialize<T>(T obj) => DataSerializer.Serialize(obj);

        /// <summary>
        /// Serializza un oggetto in formato JSON con opzioni serializzazione.
        /// </summary>
        protected string JsonSerialize<T>(T obj, Formatting reqFormat) => DataSerializer.Serialize(obj, reqFormat);

        /// <summary>
        /// Imposta un valore nel hash dello stato dell'IOB.
        /// </summary>
        protected void SetStatusField(string field, string value)
        {
            string baseKey = redisMan.redHash($"IOB:Status:{IOBConfFull.General.FilenameIOB}");
            redisMan.redSetHashField(baseKey, field, value);
        }

        /// <summary>
        /// Setup di tutti gli oggetti Queue, ma solo alcuni hanno coda REDIS (quelli senza sono "sacrificabili"
        /// </summary>
        protected void SetupQueue()
        {
            string codIob = IOBConfFull.General.FilenameIOB;
            bool useRedis = IOBConfFull.General.EnabRedisQue;
            // valutare se portare di nuovo in redis...
            QueueIN = new DataQueue(codIob, "QueueIN", useRedis, redisMan);
            QueueSrvResp = new DataQueue(codIob, "QueueServResp", useRedis, redisMan);
            // fix a NON redis
            QueueAlarm = new DataQueue(codIob, "QueueAlarm", false, redisMan);
            QueueFLog = new DataQueue(codIob, "QueueFLog", false, redisMan);
            //QueueFLog = new DataQueue(codIob, "QueueFLog", useRedis, redisMan);
            QueueMessages = new DataQueue(codIob, "QueueMessages", false, redisMan);
            QueuePing = new DataQueue(codIob, "QueuePing", false, redisMan);
            QueueRawTransf = new DataQueue(codIob, "QueueRawTransf", false, redisMan);
            QueueSrvReq = new DataQueue(codIob, "QueueServReq", false, redisMan);
            QueueULog = new DataQueue(codIob, "QueueULog", false, redisMan);
        }

        /// <summary>
        /// Deserializza una stringa XML in un oggetto.
        /// </summary>
        protected T XmlDeserialize<T>(string xml) => XmlDataSerializer.Deserialize<T>(xml);

        /// <summary>
        /// Serializza un oggetto in formato XML.
        /// </summary>
        protected string XmlSerialize<T>(T obj) => XmlDataSerializer.Serialize(obj);

        #endregion Protected Methods

        #region Private Fields

        /// <summary>
        /// wrapper di log
        /// </summary>
        private static readonly Logger lg = LogManager.GetCurrentClassLogger();

        private static readonly JsonSerializerOptions options = new JsonSerializerOptions
        {
            ReferenceHandler = ReferenceHandler.IgnoreCycles,
            WriteIndented = false // Optional: set to true for pretty-printing
        };

        #endregion Private Fields
    }
}