using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using MP.Core.Objects;
using MP.Data.DbModels;
using MP.Data.Repository.IOC;
using Newtonsoft.Json;
using NLog;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Threading.Tasks;
using ZiggyCreatures.Caching.Fusion;
using static MP.Core.Objects.Enums;

namespace MP.Data.Services.IOC
{
    public class IocService : BaseServ, IIocService
    {
        #region Public Constructors

        public IocService(
            IConfiguration config,
            IConnectionMultiplexer redis,
            IIocRepository repo,
            IServiceScopeFactory scopeFactory,
            //Microsoft.Extensions.Caching.Memory.IMemoryCache cache
            IFusionCache cache) : base(config, redis)
        {
            _className = "IocServ";
            int.TryParse(config.GetValue<string>("ServerConf:redisLongTimeCache"), out redisLongTimeCache);
            int.TryParse(config.GetValue<string>("ServerConf:redisShortTimeCache"), out redisShortTimeCache);
            _repo = repo;
            _scopeFactory = scopeFactory;
            _cache = cache;
        }

        #endregion Public Constructors

        #region Public Methods

        /// <inheritdoc />
        public async Task<bool> CheckCambiaStatoBatchAsync(tipoInputEvento tipoInput, string IdxMacchina, DateTime InizioStato, int IdxTipo, string CodArt, string Value, int MatrOpr, string pallet)
        {
            bool success = await _repo.CheckCambiaStatoBatchAsync(tipoInput, IdxMacchina, InizioStato, IdxTipo, CodArt, Value, MatrOpr, pallet);
            return success;
        }

        /// <inheritdoc />
        public async Task<bool> ClearFusionCache()
        {
            bool fatto = false;
            await _cache.ClearAsync();
            fatto = true;
            return fatto;
        }

        /// <inheritdoc />
        public async Task<bool> EvListMicroStatoInsertAsync(MicroStatoMacchinaModel newRecMsm, EventListModel newRecEv)
        {
            bool success = await _repo.EvListMicroStatoInsertAsync(newRecMsm, newRecEv);
            return success;
        }

        /// <inheritdoc />
        public async Task<string> GetCurrOdlAsync(string idxMacchina)
        {
            string result = "";
            string currKey = $"{MP.Data.Utils.redisOdlCurrByMac}:{idxMacchina}";
            // cerco in redis dato valOut sel macchina...
            RedisValue rawData = _redisDb.StringGet(currKey);
            if (rawData.HasValue)
            {
                result = $"{rawData}";
            }
            else
            {
                result = await GetCurrOdlByProdAsync(idxMacchina);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                _redisDb.StringSet(currKey, rawData, getRandTOut(redisLongTimeCache));
            }
            return result;
        }

        /// <inheritdoc />
        public async Task<Dictionary<string, string>> GetTask2ExeMacchinaAsync(string idxMacchina)
        {
            var currHash = MP.Data.Utils.RedKeyTask2ExeMacc(idxMacchina, MpIoNS);
            return await RedisGetHashDictAsync(currHash);
        }

        /// <inheritdoc />
        public async Task<bool> IobInsEnabAsync(string idxMacchina)
        {
            string cacheKey = $"IOC_IobInsEnab_{idxMacchina}";
            return await GetOrFetchAsync(cacheKey, async () =>
            {
                var key = MP.Data.Utils.RedKeyDatiMacc(idxMacchina, MpIoNS);

                string? val = await _redisDb.HashGetAsync(key, "insEnabled");

                if (val == null)
                {
                    var data = await ResetDatiMacchinaAsync(idxMacchina);
                    data.TryGetValue("insEnabled", out val);
                }

                return val != null && (val == "1" || val.ToLower() == "true");
            }, TimeSpan.FromSeconds(5));
        }

        /// <inheritdoc />
        public async Task<bool> MicroStatoMacchinaUpsertAsync(MicroStatoMacchinaModel newRec)
        {
            bool success = await _repo.MicroStatoMacchinaUpsertAsync(newRec);
            return success;
        }

        /// <inheritdoc />
        public async Task<string> ProcessInputAsync(string idxMacchina, string valore, string dtEve, string dtCurr, string contatore)
        {
            string answ = "";
            if (ValidateInputParams(idxMacchina, valore, dtEve, dtCurr))
            {
                DateTime dataOraEvento = ParseEventTime(dtEve, dtCurr);

                // se abilitato registro evento sul DB
                if (await IobSLogEnabAsync(idxMacchina))
                {
                    int cntVal = 0;
                    int.TryParse(contatore, out cntVal);
                    await saveSigLogAsync(idxMacchina, valore, dataOraEvento, cntVal);
                }
                // continuo col resto
                try
                {
                    // scrivo keep alive!!! (se necessario, altrimenti è in cache...)
                    await ScriviKeepAliveAsync(idxMacchina, DateTime.Now);
                    // Cache dati macchina per evitare lookup ridondanti
                    Dictionary<string, string> datiMacc = await mDatiMacchineAsync(idxMacchina);
                    // verifico se sia una macchina MULTI....
                    if (isMulti(idxMacchina, datiMacc))
                    {
                        // inizio preprocessing
                        string newVal = "";
                        // processo OGNI macchina a stati dell'impianto... (KEY:IdxMacchina / IdxMacchina#qualcosa, Val = IdxFamIn)
                        foreach (var item in await mTabMSMIAsync(idxMacchina))
                        {
                            newVal = preProcInput(item.Key, valore, datiMacc);
                            // ora processo e salvo il valOut del microstato...
                            // INTERNAMENTE gestisce i casi DB/REDIS secondo necessità
                            await CheckMicroStatoAsync(item.Key, newVal, dataOraEvento, contatore, datiMacc);
                        }
                    }
                    else
                    {
                        // ora processo e salvo il valOut del microstato... INTERNAMENTE
                        // gestisce i casi DB/REDIS secondo necessità
                        await CheckMicroStatoAsync(idxMacchina, valore, dataOraEvento, contatore, datiMacc);
                    }
                    // forzo RESET dati macchina...
                    await ResetDatiMacchinaAsync(idxMacchina);
                    // registro in risposta che è andato tutto bene...
                    answ = "OK";
                }
                catch (Exception exc)
                {
                    string errore = $"Errore: {Environment.NewLine}{exc}";
                    Log.Error(errore);
                    answ = errore;
                }
            }
            return answ;
        }

        /// <inheritdoc />
        public async Task<int> PzCounterTcAsync(string idxMacchina)
        {
            int answ = -1;
            DateTime dataRif = DateTime.Now;
            var datiProd = await StatoProdMacchinaAsync(idxMacchina, dataRif);
            if (datiProd != null)
            {
                answ = datiProd.PzTotODL;
            }
            return answ;
        }

        /// <inheritdoc />
        public async Task<string> SaveCounterAsync(string idxMacchina, string counter)
        {
            string answ = "0";
            // inizio processing vero e proprio INPUT...
            if (string.IsNullOrEmpty(idxMacchina))
            {
                string errore = "Errore: parametro macchina vuoto";
                Log.Warn(errore);
                answ = errore;
            }
            else
            {
                if (string.IsNullOrEmpty(counter))
                {
                    string errore = "Errore: parametro counter vuoto";
                    Log.Warn(errore);
                    answ = errore;
                }
                else
                {
                    int newCounter = -1;
                    int.TryParse(counter, out newCounter);
                    // se il conteggio è >= 0 SALVO come nuovo conteggio...
                    if (newCounter >= 0)
                    {
                        var currKey = MP.Data.Utils.RedKeyPzCount(idxMacchina, MpIoNS);
                        RedisValue rawData = await _redisDb.StringGetAsync(currKey);
                        if (rawData.HasValue)
                        {
                            // salvo per + tempo...
                            await _redisDb.StringSetAsync(currKey, answ.ToString());
                            answ = counter;
                        }
                        else
                        {
                            int currCount = await PzCounterTcAsync(idxMacchina);
                            answ = currCount.ToString();
                            // salvo per meno tempo...
                            await _redisDb.StringSetAsync(currKey, answ);
                        }
                    }
                }
            }
            return answ;
        }

        /// <inheritdoc />
        public async Task ScriviKeepAliveAsync(string IdxMacchina, DateTime oraMacchina)
        {
            // cerco se ho keep alive in redis,
            var currKey = MP.Data.Utils.RedKeyHash($"KeepAlive:{IdxMacchina}");
            bool keyPresent = await _redisDb.KeyExistsAsync(currKey);
            // se NON presente salvo in REDIS con TTL 10 sec e sul DB...
            if (!keyPresent)
            {
                DateTime adesso = DateTime.Now;
                await _redisDb.StringSetAsync(currKey, adesso.ToString("s"), TimeSpan.FromSeconds(30));
                // effettuo scrittura sul DB
                await _repo.KeepAliveUpsertAsync(IdxMacchina, DateTime.Now, oraMacchina);
            }
        }

        #endregion Public Methods

        #region Protected Fields

        protected Random rand = new Random();

        #endregion Protected Fields

        #region Protected Methods

        /// <summary>
        /// Restituisce un timeout dai minuti richiesti + tempo random 1..60 sec
        /// </summary>
        /// <param name="stdMinutes"></param>
        /// <returns></returns>
        protected TimeSpan getRandTOut(double stdMinutes)
        {
            double rndValue = stdMinutes + (double)rand.Next(1, 60) / 60;
            return TimeSpan.FromMinutes(rndValue);
        }

        #endregion Protected Methods

        #region Private Fields

        private static Logger Log = LogManager.GetCurrentClassLogger();

        private readonly IFusionCache _cache;

        private readonly string _className;

        private readonly IIocRepository _repo;
        private readonly IServiceScopeFactory _scopeFactory;

        /// <summary>
        /// Provider CultureInfo x parse valori(es dataora)
        /// </summary>
        private CultureInfo ciProvider = CultureInfo.InvariantCulture;

        /// <summary>
        /// Formato dataora standard x parsing
        /// </summary>
        private string dtFormat = "yyyyMMddHHmmssfff";

        private int redisLongTimeCache = 5;

        private int redisShortTimeCache = 2;

        #endregion Private Fields

        #region Private Methods

        /// <summary>
        /// controlla se da il segnale di "microstato" deriva un evento da generare - modalità OFFLINE
        /// </summary>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="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></returns>
        private async Task<inputComandoMapo> CheckMicroStatoAsync(string idxMacchina, string valore, DateTime dtEve, string contatore, Dictionary<string, string>? datiMaccCache = null)
        {
            // recupero SE IMPIEGATO REDIS i valori del Dictionary della macchina...
            Dictionary<string, string> datiMacc = datiMaccCache ?? await mDatiMacchineAsync(idxMacchina);

            // processing
            inputComandoMapo answ = new inputComandoMapo();

            // SE no trovassi verifico se esista la macchina altrimenti la creo... REDIS compliant
            if (!datiMacc.ContainsKey(idxMacchina))
            {
                await verificaIdxMacchinaAsync(idxMacchina);
            }

            // continuo processing...
            string CodArticolo = datiMacc["CodArticolo"];
            if (string.IsNullOrEmpty(CodArticolo))
            {
                var allDatiMacch = await _repo.DatiMacchineGetAllAsync();
                var recMacc = allDatiMacch.FirstOrDefault(x => x.IdxMacchina == idxMacchina);
                if (recMacc != null)
                {
                    CodArticolo = recMacc.CodArticoloA;
                }
            }
            // preparo gestione val ingresso
            int? valINT = 0;
            int idxTipoEv = 0;
            int next_idxMS = 0;
            try
            {
                valINT = int.Parse(valore, NumberStyles.HexNumber);
                int idxFamIn = Convert.ToInt32(datiMacc["IdxFamIn"]);
                int idxMicroStato = Convert.ToInt32(datiMacc["IdxMicroStato"]);
                int valIOB = Convert.ToInt32(valINT);
                next_idxMS = idxMicroStato;
                // recupero singolo valOut (stringa) x chiave
                string todoSMI = await ValoreSmiAsync(idxFamIn, idxMicroStato, valIOB);
                // solo se ho trovato un risultato nella tab SMI della famiglia macchina...
                if (!string.IsNullOrEmpty(todoSMI) && todoSMI.Contains("_"))
                {
                    // splitto e salvo valori OUT...
                    string[] valori = todoSMI.Split('_');
                    idxTipoEv = Convert.ToInt32(valori[0]);
                    next_idxMS = Convert.ToInt32(valori[1]);
                }
            }
            catch (Exception exc)
            {
                Log.Error($"[ChkMiSt_5a] - - Eccezione in recupero riga Trans ingressi | idxMacchina {idxMacchina} | valINT {valINT}:{Environment.NewLine}{exc}", Environment.NewLine, exc, valINT, idxMacchina);
            }

            // effettuo update vari SU DB!!!
            MicroStatoMacchinaModel newRecMsm = new MicroStatoMacchinaModel()
            {
                IdxMacchina = idxMacchina,
                IdxMicroStato = next_idxMS,
                InizioStato = dtEve,
                Value = valore
            };
            if (idxTipoEv > 0)
            {
                // preparo record
                string valEsteso = string.Format("[{0}] {1}", contatore.PadLeft(3, '0'), valore);
                // creo evento
                EventListModel newRecEv = new EventListModel()
                {
                    CodArticolo = CodArticolo,
                    IdxMacchina = idxMacchina,
                    IdxTipo = idxTipoEv,
                    InizioStato = dtEve,
                    MatrOpr = 0,
                    pallet = "-",
                    Value = valEsteso
                };
                // salva e processa evento + microstato
                answ = await scriviRigaEventoAsync(newRecMsm, newRecEv);
            }
            else
            {
                await _repo.MicroStatoMacchinaUpsertAsync(newRecMsm);
            }
            return answ;
        }

        /// <summary>
        /// Elenco completo config da DB
        /// </summary>
        private async Task<List<ConfigModel>> ConfigGetAllAsync()
        {
            return await GetOrFetchAsync("IOC_ConfigAll", async () =>
            {
                List<ConfigModel>? result = new List<ConfigModel>();
                // cerco in redis...
                RedisValue rawData = await _redisDb.StringGetAsync(MP.Data.Utils.redisConfKey);
                string source = "DB";
                if (!string.IsNullOrEmpty($"{rawData}"))
                {
                    result = JsonConvert.DeserializeObject<List<ConfigModel>>($"{rawData}");
                    source = "REDIS";
                }
                else
                {
                    result = await _repo.ConfigGetAllAsync();
                    rawData = JsonConvert.SerializeObject(result);
                    await _redisDb.StringSetAsync(MP.Data.Utils.redisConfKey, rawData, getRandTOut(redisLongTimeCache));
                }
                Log.Debug($"ConfigGetAllAsync Read from {source}");
                if (result == null)
                {
                    result = new List<ConfigModel>();
                }
                return result;
            }, TimeSpan.FromMinutes(1));
        }

        /// <summary>
        /// Helper standardizzazione valOut dataora ricevuto da IOB remoti
        /// </summary>
        /// <param name="s"></param>
        /// <returns></returns>
        private string dtFormStd(string? s)
        {
            return s?.Length > 17 ? s[..17] : s?.PadRight(17, '0') ?? string.Empty;
        }

        /// <summary>
        /// Recupero info ODL corrente da dati prod macchina
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        private async Task<string> GetCurrOdlByProdAsync(string idxMacchina)
        {
            string answ = "";
            // recupero stato...
            var datiProd = await StatoProdMacchinaAsync(idxMacchina, DateTime.Now);
            if (datiProd != null)
            {
                answ = datiProd.IdxOdl.ToString();
            }
            // ultimo controllo su idxOdl...
            answ = answ == "" ? "0" : answ;
            // restituisco!
            return answ;
        }

        /// <summary>
        /// Implementa gestione recupero cache da memoria o da obj esterno + cache memoria
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="cacheKey"></param>
        /// <param name="fetchFunc"></param>
        /// <param name="expiration"></param>
        /// <returns></returns>
        private async Task<T> GetOrFetchAsync<T>(string cacheKey, Func<Task<T>> fetchFunc, TimeSpan expiration)
        {
            // GetOrSetAsync di Fusion cache:
            // - TryGetValue, se mancasse crea un lock solo per QUELLA key
            // - Esegue fetchFunc (la logica Redis + DB)
            // - Salva in memoria e rilascia il lock
            return await _cache.GetOrSetAsync<T>(
                cacheKey,
                async ct => await fetchFunc(),
                options => options.SetDuration(expiration)
            );
        }

        /// <summary>
        /// Restituisce il valOut booleano se la macchina sia abilitata all'inserimento COMPLETO nel
        /// Signal Log
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        private async Task<bool> IobSLogEnabAsync(string idxMacchina)
        {
            bool answ = false;
            // ORA recupero da memoria redis...
            try
            {
                var currHash = MP.Data.Utils.RedKeyDatiMacc(idxMacchina, MpIoNS);
                RedisValue rawData = await _redisDb.HashGetAsync(currHash, (RedisValue)"sLogEnabled");
                // se è vuoto... leggo da DB e popolo!
                if (!rawData.HasValue)
                {
                    await ResetDatiMacchinaAsync(idxMacchina);
                    // riprovo
                    rawData = await _redisDb.HashGetAsync(currHash, (RedisValue)"sLogEnabled");
                }

                // provo conversione
                bool.TryParse($"{rawData}", out answ);
            }
            catch (Exception exc)
            {
                Log.Error($"Errore IobSLogEnabAsync | idxMacchina {idxMacchina}:{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Restituisce il valOut booleano se la macchina sia di tipo MULTI (con più state machine x INGRESSI)
        /// usando dati macchina in cache per evitare lookup ridondanti
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="datiMacc"></param>
        /// <returns></returns>
        private bool isMulti(string idxMacchina, Dictionary<string, string> datiMacc)
        {
            bool answ = false;
            try
            {
                answ = Convert.ToBoolean(datiMacc.ContainsKey("Multi") && datiMacc["Multi"] == "1");
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in isMulti{Environment.NewLine}{exc}");
            }
            return answ;
        }

        private async Task<HashSet<string>> ListMasterAsync()
        {
            return await GetOrFetchAsync("IOC_ListMaster", async () =>
            {
                HashSet<string> result = new();
                string currKey = $"{MP.Data.Utils.redisBaseAddr}:ListMaster";
                RedisValue rawData = await _redisDb.StringGetAsync(currKey);
                if (rawData.HasValue)
                {
                    result = JsonConvert.DeserializeObject<HashSet<string>>($"{rawData}") ?? new();
                }
                else
                {
                    var fullList = await Macchine2SlaveGetAllAsync();
                    result = fullList.Select(x => x.IdxMacchina).ToHashSet<string>();
                    rawData = JsonConvert.SerializeObject(result);
                    await _redisDb.StringSetAsync(currKey, rawData, getRandTOut(redisLongTimeCache * 10));
                }
                return result;
            }, TimeSpan.FromMinutes(15));
        }

        private async Task<HashSet<string>> ListSlaveAsync()
        {
            return await GetOrFetchAsync("IOC_ListSlave", async () =>
            {
                HashSet<string> result = new();
                string currKey = $"{MP.Data.Utils.redisBaseAddr}:ListSlave";
                RedisValue rawData = await _redisDb.StringGetAsync(currKey);
                if (rawData.HasValue)
                {
                    result = JsonConvert.DeserializeObject<HashSet<string>>($"{rawData}") ?? new();
                }
                else
                {
                    var fullList = await Macchine2SlaveGetAllAsync();
                    result = fullList.Select(x => x.IdxMacchinaSlave).Distinct().ToHashSet<string>();
                    rawData = JsonConvert.SerializeObject(result);
                    await _redisDb.StringSetAsync(currKey, rawData, getRandTOut(redisLongTimeCache * 10));
                }
                return result;
            }, TimeSpan.FromMinutes(15));
        }

        /// <summary>
        /// Elenco completo valori Macchine 2 Slave
        /// </summary>
        /// <returns></returns>
        private async Task<List<Macchine2SlaveModel>> Macchine2SlaveGetAllAsync()
        {
            return await GetOrFetchAsync("IOC_M2SlaveGetAll", async () =>
            {
                List<Macchine2SlaveModel>? result = new List<Macchine2SlaveModel>();
                string currKey = $"{MP.Data.Utils.redisBaseAddr}:M2STab";
                // cerco in redis dato valOut sel macchina...
                RedisValue rawData = await _redisDb.StringGetAsync(currKey);
                if (rawData.HasValue)
                {
                    result = JsonConvert.DeserializeObject<List<Macchine2SlaveModel>>($"{rawData}");
                }
                else
                {
                    result = await _repo.Macchine2SlaveAsync();
                    // serializzo e salvo...
                    rawData = JsonConvert.SerializeObject(result);
                    await _redisDb.StringSetAsync(currKey, rawData, getRandTOut(redisLongTimeCache * 10));
                }
                if (result == null)
                {
                    result = new List<Macchine2SlaveModel>();
                }
                return result;
            }, TimeSpan.FromMinutes(30));
        }

        /// <summary>
        /// Restitusice elenco KVP dei campi DatiMacchine + StatoMacchine per l'impianto indicato
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        private async Task<Dictionary<string, string>> mDatiMacchineAsync(string idxMacchina)
        {
            // hard coded dimensione vettore DatiMacchine
            Dictionary<string, string> answ = new Dictionary<string, string>();
            // ORA recupero da memoria redis...
            try
            {
                var currHash = MP.Data.Utils.RedKeyDatiMacc(idxMacchina, MpIoNS);
                answ = await RedisGetHashDictAsync(currHash);
                // se è vuoto... leggo da DB e popolo!
                if (answ.Count == 0)
                {
                    answ = await ResetDatiMacchinaAsync(idxMacchina);
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in compilazione dati Macchine x Redis - idxMacchina {idxMacchina}:{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Restitusice elenco KVP (async) per evitare blocchi quando chiamato da metodi asincroni
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        private async Task<KeyValuePair<string, string>[]> mTabMSMIAsync(string idxMacchina)
        {
            KeyValuePair<string, string>[] answ = new KeyValuePair<string, string>[1];
            answ[0] = new KeyValuePair<string, string>("0", "0");
            try
            {
                var currHash = MP.Data.Utils.RedKeyMsmi(idxMacchina);
                answ = await RedisGetHashAsync(currHash);
                if (answ == null || answ.Length == 0)
                {
                    answ = await resetMSMIAsync(idxMacchina);
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in compilazione Tabella Multi State Machine Ingressi x Redis:{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Calcola dataora evento da info dt ricevute
        /// </summary>
        /// <param name="dtEve"></param>
        /// <param name="dtCurr"></param>
        /// <returns></returns>
        private DateTime ParseEventTime(string dtEve, string dtCurr)
        {
            DateTime dataOraEvento = DateTime.Now;

            // fix formato dataora in ingresso
            string stdEve = dtFormStd(dtEve);
            string stdCurr = dtFormStd(dtCurr);

            // 2. Se le stringhe normalizzate coincidono, skip dei calcoli
            if (stdEve != stdCurr)
            {
                // 3. Parsing sicuro
                if (DateTime.TryParseExact(stdEve, dtFormat, ciProvider, DateTimeStyles.None, out DateTime dtEvento) &&
                    DateTime.TryParseExact(stdCurr, dtFormat, ciProvider, DateTimeStyles.None, out DateTime dtCorrente))
                {
                    TimeSpan diff = dtCorrente - dtEvento;
                    double ms = Math.Abs(diff.TotalMilliseconds);

                    // 4. Classificazione delta con switch expression (più leggibile e performante)
                    string deltaClass = ms switch
                    {
                        <= 10 => "0-10 ms",
                        <= 100 => "10-100 ms",
                        <= 1000 => "100-1000 ms",
                        <= 10000 => "1-10 sec",
                        _ => "> 10 sec"
                    };

                    Log.Debug($"Correzione delta {deltaClass}");

                    // 5. Correzione data/ora server: sottrao lo scarto calcolato
                    dataOraEvento = dataOraEvento.Subtract(diff);
                }
                else
                {
                    Log.Error($"Errore parsing date: {stdEve} | {stdCurr}");
                }
            }
            return dataOraEvento;
        }

        /// <summary>
        /// Calcola l'effettivo valOut da passare alla macchina a stati INGRESSI usando dati macchina in cache
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="valore"></param>
        /// <param name="datiMacc"></param>
        /// <returns></returns>
        private string preProcInput(string idxMacchina, string valore, Dictionary<string, string> datiMacc)
        {
            string newVal = "";
            try
            {
                // variabili
                int valINT = 0;
                int BitFilt = 0;
                int BSR = 0;
                bool ExplodeBit = false;
                int NumBit = 0;
                int newValInt = 0;
                // recupero parametri dalla cache...
                int.TryParse(datiMacc.ContainsKey("BitFilt") ? datiMacc["BitFilt"] : "0", out BitFilt);
                int.TryParse(datiMacc.ContainsKey("BSR") ? datiMacc["BSR"] : "0", out BSR);
                Boolean.TryParse(datiMacc.ContainsKey("ExplodeBit") ? datiMacc["ExplodeBit"] : "false", out ExplodeBit);
                // non usato (x ora)
                int.TryParse(datiMacc.ContainsKey("NumBit") ? datiMacc["NumBit"] : "0", out NumBit);

                // recupero valOut
                valINT = int.Parse(valore, NumberStyles.HexNumber);
                // filtro
                newValInt = MP.Core.Utils.bMaskInt(valINT, BitFilt);
                // effettuo eventuale BitShiftRight
                if (BSR > 0)
                {
                    newValInt = newValInt >> BSR;
                }
                // effettuo eventuale esplosione in BIT esclusivi
                if (ExplodeBit)
                {
                    newValInt = Convert.ToInt32(1 << newValInt);
                }
                // riconverto a STRING HEX!!!
                newVal = newValInt.ToString("X");
            }
            catch
            {
                newVal = valore;
            }

            return newVal;
        }

        private async Task<KeyValuePair<string, string>[]> RedisGetHashAsync(RedisKey redKey)
        {
            HashEntry[] rawData = await _redisDb.HashGetAllAsync(redKey);
            var result = rawData.Where(x => !x.Name.IsNull).Select(x => new KeyValuePair<string, string>($"{x.Name}", $"{x.Value}")).ToArray();
            return result;
        }

        private async Task<Dictionary<string, string>> RedisGetHashDictAsync(RedisKey hashKey)
        {
            HashEntry[] rawData = await _redisDb.HashGetAllAsync(hashKey);
            var result = rawData
                        .Where(x => !x.Name.IsNull)
                        .ToDictionary(x => x.Name.ToString(), x => x.Value.ToString());
            return result;
        }

        private async Task RedisSetHashAsync(RedisKey redKey, KeyValuePair<string, string>[] valori, double expireSeconds = -1.0)
        {
            HashEntry[] redHash = valori.Select(x => new HashEntry(x.Key, x.Value)).ToArray();
            await _redisDb.HashSetAsync(redKey, redHash);
            if (expireSeconds > 0.0)
            {
                await _redisDb.KeyExpireAsync(redKey, DateTime.Now.AddSeconds(expireSeconds));
            }
        }

        /// <summary>
        /// Restitusice elenco KVP dei campi DatiMacchine + StatoMacchine per l'impianto indicato
        /// </summary>
        /// <param name="idxMacc"></param>
        /// <returns></returns>
        private async Task<Dictionary<string, string>> ResetDatiMacchinaAsync(string idxMacc)
        {
            Dictionary<string, string> result = new Dictionary<string, string>();
            VMSFDModel? dbResult = null;
            dbResult = await _repo.VMSFDGetByMaccAsync(idxMacc);
            if (dbResult == null) return new Dictionary<string, string>();

            double numSecCache = redisLongTimeCache;
            // converto in formato dizionario...
            if (dbResult != null)
            {
                // salvo 1:1 i valori... STATO
                result.Add("IdxMicroStato", $"{dbResult.IdxMicroStato}");
                result.Add("IdxStato", $"{dbResult.IdxStato}");
                result.Add("CodArticolo", $"{dbResult.CodArticolo}");
                result.Add("insEnabled", $"{dbResult.InsEnabled}");
                result.Add("sLogEnabled", $"{dbResult.SLogEnabled}");
                result.Add("pallet", $"{dbResult.Pallet}");
                result.Add("CodArticolo_A", $"{dbResult.CodArticoloA}");
                result.Add("CodArticolo_B", $"{dbResult.CodArticoloB}");
                result.Add("TempoCicloBase", $"{dbResult.TempoCicloBase}");
                result.Add("PzPalletProd", $"{dbResult.PzPalletProd}");
                result.Add("MatrOpr", $"{dbResult.MatrOpr}");
                result.Add("lastVal", $"{dbResult.LastVal}");
                result.Add("TCBase", $"{dbResult.TempoCicloBase}");

                //...e SETUP
                result.Add("CodMacc", $"{dbResult.Codmacchina}");
                result.Add("IdxFamIn", $"{dbResult.IdxFamigliaIngresso}");
                result.Add("Multi", $"{dbResult.Multi}");
                result.Add("BitFilt", $"{dbResult.BitFilt}");
                result.Add("MaxVal", $"{dbResult.MaxVal}");
                result.Add("BSR", $"{dbResult.Bsr}");
                result.Add("ExplodeBit", $"{dbResult.ExplodeBit}");
                result.Add("NumBit", $"{dbResult.NumBit}");
                result.Add("IdxFamMacc", $"{dbResult.IdxFamiglia}");
                result.Add("simplePallet", $"{dbResult.SimplePallet}");
                result.Add("palletChange", $"{dbResult.PalletChange}");
                // durata cache in secondi dal valOut insEnabled...
                //double numSecCache = ((result["insEnabled"].ToLower() == "true") ? redisShortTimeCache : redisLongTimeCache);
                numSecCache = dbResult.InsEnabled ? redisShortTimeCache : redisLongTimeCache;
            }

            // dati master/slave
            string isMaster = (await ListMasterAsync()).Contains(idxMacc) ? "1" : "0";
            string isSlave = (await ListSlaveAsync()).Contains(idxMacc) ? "1" : "0";
            result.Add("Master", isMaster);
            result.Add("Slave", isSlave);

            // Processing redis in transazoine...
            var redKey = MP.Data.Utils.RedKeyDatiMacc(idxMacc, MpIoNS);

            // variazione con redis transaction...
            var transaction = _redisDb.CreateTransaction();
            // 1. Eliminiamo la chiave (rimuove i vecchi campi)
            _ = transaction.KeyDeleteAsync(redKey);
            // 2. Prepariamo gli HashEntry per il batch (più efficiente di un Dictionary)
            HashEntry[] entries = result.Select(kvp => new HashEntry(kvp.Key, kvp.Value)).ToArray();
            // 3. Inseriamo i nuovi valori
            _ = transaction.HashSetAsync(redKey, entries);
            // 4. Impostiamo l'expiration in un unico colpo
            _ = transaction.KeyExpireAsync(redKey, TimeSpan.FromSeconds(numSecCache));
            // Eseguiamo tutto in un unico viaggio verso Redis
            bool success = await transaction.ExecuteAsync();

            return result;
        }

        /// <summary>
        /// Resetta (rileggendo) i dati della State Machine multi ingressi nel formato
        /// currKey:    IdxMacchina
        /// value:  IdxFamigliaIngresso
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        private async Task<KeyValuePair<string, string>[]> resetMSMIAsync(string idxMacchina)
        {
            var currHash = MP.Data.Utils.RedKeyMsmi(idxMacchina);
            // recupero records
            var tabMSMI = await _repo.VMSFDGetMultiByMaccAsync(idxMacchina);

            KeyValuePair<string, string>[] answ = new KeyValuePair<string, string>[tabMSMI.Count];
            // salvo tutti i valori StateMachineIngressi...
            int i = 0;
            foreach (var item in tabMSMI)
            {
                answ[i] = new KeyValuePair<string, string>(item.IdxMacchina, item.IdxFamigliaIngresso.ToString());
                i++;
            }
            // verifico il timeout (default 60 sec...)
            var sTOutSmi = await tryGetConfigAsync("TmOut.MSMI");
            int tOut = 60;
            int.TryParse(sTOutSmi, out tOut);
            tOut = tOut <= 60 ? 60 : tOut;
            // salvo in redis!
            await RedisSetHashAsync(currHash, answ, tOut);
            return answ;
        }

        /// <summary>
        /// Resetta (rileggendo) i dati della State Machine ingressi nel formato
        /// currKey:    cState_nVal (current MICRO-STATE + "_" + new Value)
        /// value:  iTipoEv_nState (IdxTipoEv da trasmettere + New MICRO-STATE)
        /// </summary>
        /// <param name="idxFamIn"></param>
        /// <returns></returns>
        private async Task<KeyValuePair<string, string>[]> resetSMIAsync(int idxFamIn)
        {
            var currHash = MP.Data.Utils.GetHashSMI(idxFamIn);
            // leggo da DB...
            var tabSMI = await _repo.StateMachineIngressiAsync(idxFamIn);

            KeyValuePair<string, string>[] answ = new KeyValuePair<string, string>[tabSMI.Count];
            // salvo tutti i valori StateMachineIngressi...
            int i = 0;
            string key = "";
            string val = "";
            foreach (var item in tabSMI)
            {
                key = string.Format("{0}_{1}", item.IdxMicroStato, item.ValoreIngresso);
                val = string.Format("{0}_{1}", item.IdxTipoEvento, item.NextIdxMicroStato);
                answ[i] = new KeyValuePair<string, string>(key, val);
                i++;
            }
            // verifico il timeout (default 60 sec...)
            int tOut = 300;
            var sTOutSmi = await tryGetConfigAsync("TmOut.SMI");
            if (!string.IsNullOrEmpty(sTOutSmi))
            {
                int.TryParse(sTOutSmi, out tOut);
            }
            // salvo in redis!
            await RedisSetHashAsync(currHash, answ, tOut);
            return answ;
        }

        /// <summary>
        /// salva il segnale di "microstato" (segnale) 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></returns>
        private async Task<bool> saveSigLogAsync(string idxMacchina, string valore, DateTime dtEve, int contatore)
        {
            SignalLogModel newRec = new SignalLogModel()
            {
                IdxMacchina = idxMacchina,
                DtCurr = DateTime.Now,
                DtEve = dtEve,
                Contatore = contatore,
                Valore = valore
            };
            return await _repo.SignalLogInsertAsync(newRec);
        }

        /// <summary>
        /// Scrive una riga evento + una riga microstato insieme, ed effettua verifica necessità cambio stato
        /// </summary>
        /// <param name="newRecMsm">Record MicroStatoMacchina</param>
        /// <param name="newRecEv">record EventList</param>
        /// <returns></returns>
        private async Task<inputComandoMapo> scriviRigaEventoAsync(MicroStatoMacchinaModel newRecMsm, EventListModel newRecEv)
        {
            bool inserito = false;

            // inserisco evento
            inserito = await _repo.EvListMicroStatoInsertAsync(newRecMsm, newRecEv);
            // faccio controllo per eventuale cambio stato da tab transizioni...

            await _repo.CheckCambiaStatoBatchAsync(tipoInputEvento.hw, newRecEv.IdxMacchina, newRecEv.InizioStato ?? DateTime.Now, newRecEv.IdxTipo, newRecEv.CodArticolo, newRecEv.Value, newRecEv.MatrOpr, newRecEv.pallet);

            // formatto output
            inputComandoMapo answ = new inputComandoMapo();
            answ.outValue = inserito.ToString();
            answ.needStatusRefresh = true;
            return answ;
        }

        /// <summary>
        /// Restitusice elenco KVP dei campi della State Machine ingressi nel formato
        /// currKey:    cState_nVal (current MICRO-STATE + "_" + new Value)
        /// value:  iTipoEv_nState (IdxTipoEv da trasmettere + New MICRO-STATE
        /// </summary>
        /// <param name="idxFamIn"></param>
        /// <returns></returns>
        private async Task<KeyValuePair<string, string>[]> StateMachInByKeyAsync(int idxFamIn)
        {
            // hard coded dimensione vettore DatiMacchine
            KeyValuePair<string, string>[] answ = new KeyValuePair<string, string>[1];
            // iniziualizzo con un valOut... 0/0
            answ[0] = new KeyValuePair<string, string>("0", "0");
            // ORA recupero da memoria redis...
            try
            {
                var currHash = MP.Data.Utils.GetHashSMI(idxFamIn);
                answ = await RedisGetHashAsync(currHash);
                // se è vuoto... leggo da DB e popolo!
                if (answ.Length == 0)
                {
                    answ = await resetSMIAsync(idxFamIn);
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in compilazione State Machine Ingressi x Redis:{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Stato prod macchina (completo)
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="dtReq"></param>
        /// <returns></returns>
        private async Task<StatoProdModel> StatoProdMacchinaAsync(string idxMacchina, DateTime dtReq, bool forceDb = false)
        {
            string cacheKey = $"IOC_StatoProd_{idxMacchina}";
            return await GetOrFetchAsync(cacheKey, async () =>
            {
                StatoProdModel? result = new StatoProdModel();
                // cerco in _redisConn...
                string currKey = $"{MP.Data.Utils.redisStatoProd}:{idxMacchina}:{dtReq:HHmm}";
                RedisValue rawData = await _redisDb.StringGetAsync(currKey);
                if (rawData.HasValue && !forceDb)
                {
                    result = JsonConvert.DeserializeObject<StatoProdModel>($"{rawData}");
                }
                else
                {
                    result = await _repo.StatoProdMacchinaAsync(idxMacchina, dtReq);
                    // serializzo e salvo...
                    rawData = JsonConvert.SerializeObject(result);
                    await _redisDb.StringSetAsync(currKey, rawData, TimeSpan.FromSeconds(30));
                }
                if (result == null)
                {
                    result = new StatoProdModel();
                }
                return result;
            }, TimeSpan.FromSeconds(3));
        }

        /// <summary>
        /// Restituisce valOut della stringa (SE disponibile)
        /// </summary>
        /// <param name="keyName"></param>
        /// <returns></returns>
        private async Task<string> tryGetConfigAsync(string keyName)
        {
            string answ = "";
            // preselezione valori
            var configData = await ConfigGetAllAsync();
            var currRec = configData.FirstOrDefault(x => x.Chiave == keyName);
            if (currRec != null)
            {
                answ = currRec.Valore;
            }
            return answ;
        }

        /// <summary>
        /// Validazione preliminare valori input
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="valore"></param>
        /// <param name="dtEve"></param>
        /// <param name="dtCurr"></param>
        /// <returns></returns>
        private bool ValidateInputParams(string idxMacchina, string valore, string dtEve, string dtCurr)
        {
            bool isValid = false;
            // preparo stringa valori correnti
            string currVals = $"idxMacchina: {idxMacchina} | valOut: {valore} | dtEve: {dtEve} | dtCurr:{dtCurr}";
            if (dtEve == null || dtCurr == null)
            {
                Log.Warn($"procInput: null found | {currVals}");
            }
            else if (dtEve.Length < 17 || dtCurr.Length < 17)
            {
                Log.Info($"procInput: invalid data | {currVals}");
            }
            else if (string.IsNullOrEmpty(idxMacchina))
            {
                Log.Info($"procInput: missing IdxMacchina | {currVals}");
            }
            else if (string.IsNullOrEmpty(valore))
            {
                Log.Info($"procInput: missing valOut | {currVals}");
            }
            else
            {
                isValid = true;
            }
            return isValid;
        }

        /// <summary>
        /// Restituisce il valore SPECIFICATO per la state machine ingressi
        /// value:  iTipoEv_nState (IdxTipoEv da trasmettere + New MICRO-STATE)
        /// </summary>
        /// <param name="idxFamIn"></param>
        /// <param name="idxMicroStato"></param>
        /// <param name="valoreIn"></param>
        /// <returns></returns>
        private async Task<string> ValoreSmiAsync(int idxFamIn, int idxMicroStato, int valoreIn)
        {
            string valOut = "";
            var currHash = MP.Data.Utils.GetHashSMI(idxFamIn);
            string field = $"{idxMicroStato}_{valoreIn}";
            var searchVal = await _redisDb.HashGetAsync(currHash, field);
            if (!searchVal.HasValue)
            {
                // ricarico tabella (salvando in redis x ricerca successiva)!
                var valori = await StateMachInByKeyAsync(idxFamIn);
                if (valori.Any(x => x.Key == field))
                {
                    searchVal = valori.FirstOrDefault(x => x.Key == field).Value;
                }
            }
            valOut = $"{searchVal}";
            return valOut;
        }

        /// <summary>
        /// cerca codice in anagrafica macchine ed eventualmente inserisce nuova macchina
        /// </summary>
        /// <param name="IdxMacchina"></param>
        private async Task verificaIdxMacchinaAsync(string IdxMacchina)
        {
            // esecuzione in REDIS...cerco status macchina...
            if ((await mDatiMacchineAsync(IdxMacchina)).Count == 0)
            {
                // verifico se esiste su DB
                var dbRec = await _repo.MacchineGetByIdxAsync(IdxMacchina);
                if (dbRec == null)
                {
                    MacchineModel newRec = new MacchineModel()
                    {
                        IdxMacchina = IdxMacchina,
                        CodMacchina = "0000",
                        Nome = IdxMacchina,
                        Descrizione = "Macchina non codificata",
                        Note = "-",
                        locazione = "",
                        RecipeArchivePath = "",
                        RecipePath = ""
                    };
                    await _repo.MacchineUpsertAsync(newRec);

                    // verifico ci sia un microstato macchina...
                    var recMSM = await _repo.MicroStatoMacchinaGetByIdxMaccAsync(IdxMacchina);
                    if (recMSM.Count == 0)
                    {
                        // inserisco nuovo stato...
                        MicroStatoMacchinaModel msRec = new MicroStatoMacchinaModel()
                        {
                            IdxMacchina = IdxMacchina,
                            IdxMicroStato = 0,
                            InizioStato = DateTime.Now,
                            Value = "00"
                        };
                        await _repo.MicroStatoMacchinaUpsertAsync(msRec);
                    }
                }
            }
        }

        #endregion Private Methods
    }
}