using Microsoft.Extensions.Configuration;
using MP.Data.DatabaseModels;
using MP.Data.DTO;
using MP.Data.Objects;
using Newtonsoft.Json;
using NLog;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;
using System.Threading.Tasks;
using static MP.Data.Objects.Enums;

namespace MP.Data.Services
{
    public class TabDataService : BaseServ, IDisposable
    {
        #region Public Constructors

        public TabDataService(IConfiguration configuration)
        {
            _configuration = configuration;

            // setup compoenti REDIS
            redisConn = ConnectionMultiplexer.Connect(_configuration.GetConnectionString("Redis"));
            redisDb = redisConn.GetDatabase();

            // conf DB
            ConnStr = _configuration.GetConnectionString("Mp.All");
            if (string.IsNullOrEmpty(ConnStr))
            {
                Log.Error("ConnString empty!");
            }
            else
            {
                StringBuilder sb = new StringBuilder();
                dbTabController = new Controllers.MpTabController(configuration);
                sb.AppendLine($"TabDataService | MpTabController OK");
                dbIocController = new Controllers.MpIocController(configuration);
                sb.AppendLine($"TabDataService | MpIocController OK");
                Log.Info(sb.ToString());
                // sistemo i parametri x redHas...
                CodModulo = _configuration.GetValue<string>("OptConf:CodModulo");
                var cstringArray = ConnStr.Split(";");
                foreach (var item in cstringArray)
                {
                    var cData = item.Trim().Split("=");
                    if (cData.Length == 2)
                    {
                        if (!connStrParams.ContainsKey(cData[0]))
                        {
                            connStrParams.Add(cData[0], cData[1]);
                        }
                    }
                }
                // sistemo 
                DataSource = connStrParams["Server"];
                DataBase = connStrParams["Database"];
            }
        }

        private Dictionary<string, string> connStrParams = new Dictionary<string, string>();
        private string ConnStr = "";
        private string CodModulo = "";
        private string DataSource = "";
        private string DataBase = "";

        private string redHash(string keyName)
        {
            string result = keyName;
            try
            {
                result = $"{CodModulo}:{DataSource}:{DataBase}:{keyName}".Replace("\\", "_");
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in redHash{Environment.NewLine}{exc}");
            }

            return result;
        }

        #endregion Public Constructors

        #region Public Properties

        private static Controllers.MpIocController dbIocController { get; set; } = null!;
        private static Controllers.MpTabController dbTabController { get; set; } = null!;

        #endregion Public Properties

        #region Public Methods

        /// <summary>
        /// Elenco completo EVENTI
        /// </summary>
        /// <returns></returns>
        public async Task<List<AnagEventiModel>> AnagEventiGetAll()
        {
            // setup parametri costanti
            DateTime startDate = new DateTime(2000, 1, 1);
            DateTime endDate = DateTime.Today.AddDays(1);
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<AnagEventiModel>? result = new List<AnagEventiModel>();
            // cerco in redis...
            string currKey = $"{redisBaseKey}:AnagEventi:ALL";
            RedisValue rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                result = JsonConvert.DeserializeObject<List<AnagEventiModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.AnagEventiGetAll();
                // serializzp e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (result == null)
            {
                result = new List<AnagEventiModel>();
            }
            sw.Stop();
            Log.Debug($"AnagEventiGetAll | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }
        /// <summary>
        /// Elenco EVENTI validi x macchina
        /// </summary>
        /// <returns></returns>
        public async Task<List<AnagEventiModel>> AnagEventiGetByMacch(string IdxMacch)
        {
            // setup parametri costanti
            DateTime startDate = new DateTime(2000, 1, 1);
            DateTime endDate = DateTime.Today.AddDays(1);
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<AnagEventiModel>? result = new List<AnagEventiModel>();
            // cerco in redis...
            string currKey = $"{redisBaseKey}:AnagEventi:{IdxMacch}";
            RedisValue rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                result = JsonConvert.DeserializeObject<List<AnagEventiModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.AnagEventiGetByMacc(IdxMacch);
                // serializzp e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (result == null)
            {
                result = new List<AnagEventiModel>();
            }
            sw.Stop();
            Log.Debug($"AnagEventiGetByMacch | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Elenco completo STATI
        /// </summary>
        /// <returns></returns>
        public async Task<List<AnagStatiModel>> AnaStatiGetAll()
        {
            // setup parametri costanti
            DateTime startDate = new DateTime(2000, 1, 1);
            DateTime endDate = DateTime.Today.AddDays(1);
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<AnagStatiModel>? result = new List<AnagStatiModel>();
            // cerco in redis...
            string currKey = $"{redisBaseKey}:AnagStati";
            RedisValue rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                result = JsonConvert.DeserializeObject<List<AnagStatiModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.AnagStatiGetAll();
                // serializzp e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (result == null)
            {
                result = new List<AnagStatiModel>();
            }
            sw.Stop();
            Log.Debug($"AnaStatiGetAll | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Effettua conferma prod macchina dell'intero periodo da confermare (ultima conferma
        /// --&gt; dtEvent)
        /// </summary>
        /// <param name="idxMacchina">idx macchina da confermare</param>
        /// <param name="modoConfProd">0=periodo, 1 = giorno, 2 = turno</param>
        /// <param name="numPzConfermati">qta pezzi BUONI da confermare</param>
        /// <param name="numPzScarto">qta pezzi SCARTO da confermare</param>
        /// <param name="DataOraApp">DataOra in cui registrare approvazione</param>
        /// <param name="MatrOpr">Matricola operatore</param>
        /// <returns></returns>
        public bool ConfermaProdMacchina(string idxMacchina, int modoConfProd, int numPzConfermati, int numPzScarto, DateTime DataOraApp, int MatrOpr)
        {
            bool answ = false;
            answ = dbTabController.ConfermaProdMacchina(idxMacchina, modoConfProd, numPzConfermati, numPzScarto, DataOraApp, MatrOpr);
            return answ;
        }

        /// <summary>
        /// Effettua conferma prod macchina dell'intero periodo da confermare (ultima conferma
        /// --&gt; dtEvent)
        /// </summary>
        /// <param name="idxMacchina">idx macchina da confermare</param>
        /// <param name="modoConfProd">0=periodo, 1 = giorno, 2 = turno</param>
        /// <param name="numPzConfermati">qta pezzi BUONI da confermare</param>
        /// <param name="numPzLasciati">
        /// qta pezzi LASCIATI alla macchina da confermare (2 eventi 121 rettifica neg/pos)
        /// </param>
        /// <param name="numPzScarto">qta pezzi SCARTO da confermare</param>
        /// <param name="DataOraApp">DataOra in cui registrare approvazione</param>
        /// <param name="MatrOpr">Matricola operatore</param>
        /// <returns></returns>
        public bool ConfermaProdMacchinaFull(string idxMacchina, int modoConfProd, int numPzConfermati, int numPzLasciati, int numPzScarto, DateTime DataOraApp, int MatrOpr)
        {
            bool answ = false;
            answ = dbTabController.ConfermaProdMacchinaFull(idxMacchina, modoConfProd, numPzConfermati, numPzLasciati, numPzScarto, DataOraApp, MatrOpr);
            return answ;
        }

        /// <summary>
        /// Config values attivi
        /// </summary>
        /// <returns></returns>
        public async Task<List<ConfigModel>> ConfigGetAll()
        {
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<ConfigModel>? result = new List<ConfigModel>();
            // cerco in redis...
            string currKey = $"{redisBaseKey}:Conf";
            RedisValue rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                result = JsonConvert.DeserializeObject<List<ConfigModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = await Task.FromResult(dbTabController.ConfigGetAll());
                // serializzp e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (result == null)
            {
                result = new List<ConfigModel>();
            }
            sw.Stop();
            Log.Debug($"ConfigGetAll | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }



        public async Task<IOB_data> IobInfo(string IdxMacchina)
        {
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            IOB_data? result = new IOB_data();
            // cerco in redis...
            string currKey = redHash($"hM2IOB:{IdxMacchina}");
            RedisValue rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                result = JsonConvert.DeserializeObject<IOB_data>($"{rawData}");
                source = "REDIS";
            }
            if (result == null)
            {
                result = new IOB_data();
            }
            sw.Stop();
            Log.Debug($"IobInfo | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        public void Dispose()
        {
            // Clear database controller
            dbTabController.Dispose();
        }

        /// <summary>
        /// Effettua ricalcolo MSE x macchina indicata
        /// </summary>
        /// <param name="idxMacchina">idx macchina da confermare</param>
        /// <param name="maxAgeSec">Num massimo secondi di "vecchiaia" del dato</param>
        /// <returns></returns>
        public bool RicalcMse(string idxMacchina, int maxAgeSec)
        {
            bool answ = false;
            answ = dbTabController.RicalcMse(idxMacchina, maxAgeSec);
            return answ;
        }

        /// <summary>
        /// Recupero Righe (Actual) della scheda tecnica da GRUPPO + ODL
        /// </summary>
        /// <param name="codGruppo"></param>
        /// <param name="idxODL"></param>
        /// <returns></returns>
        public async Task<List<ST_ActRow>> STAR_byGrpOdl(string codGruppo, int idxODL)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<ST_ActRow>? result = new List<ST_ActRow>();
            // cerco in redis...
            string currKey = $"{redisBaseKey}:START:{codGruppo}:{idxODL}";
            RedisValue rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                result = JsonConvert.DeserializeObject<List<ST_ActRow>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.STAR_byGrpOdl(codGruppo, idxODL);
                // serializzp e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (result == null)
            {
                result = new List<ST_ActRow>();
            }
            sw.Stop();
            Log.Debug($"STAR_byGrpOdl | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Recupero Righe (Actual) della scheda tecnica da GRUPPO + ODL
        /// </summary>
        /// <param name="codGruppo"></param>
        /// <param name="label"></param>
        /// <param name="idxODL"></param>
        /// <returns></returns>
        public async Task<List<ST_ActRow>> STAR_byGrpOdlLbl(string codGruppo, string label, int idxODL)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<ST_ActRow>? result = new List<ST_ActRow>();
            // cerco in redis...
            string currKey = $"{redisBaseKey}:START:{codGruppo}:{label}:{idxODL}";
            RedisValue rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                result = JsonConvert.DeserializeObject<List<ST_ActRow>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.STAR_byGrpOdlLbl(codGruppo, label, idxODL);
                // serializzp e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (result == null)
            {
                result = new List<ST_ActRow>();
            }
            sw.Stop();
            Log.Debug($"STAR_byGrpOdlLbl | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Stato prod macchina (completo)
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="dtReq"></param>
        /// <returns></returns>
        public async Task<StatoProdModel> StatoProdMacchina(string idxMacchina, DateTime dtReq)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            StatoProdModel? result = new StatoProdModel();
            // cerco in redis...
            string currKey = $"{redisBaseKey}:StatoProd:{idxMacchina}:{dtReq:HHmmss}";
            RedisValue rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                result = JsonConvert.DeserializeObject<StatoProdModel>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.StatoProdMacchina(idxMacchina, dtReq);
                // serializzp e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await redisDb.StringSetAsync(currKey, rawData, UltraFastCache);
            }
            if (result == null)
            {
                result = new StatoProdModel();
            }
            sw.Stop();
            Log.Debug($"StatoProdMacchina | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }
        /// <summary>
        /// Stato macchina
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        public async Task<StatoMacchineModel> StatoMacchina(string idxMacchina)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            StatoMacchineModel? result = new StatoMacchineModel();
            // cerco in redis...
            string currKey = $"{redisBaseKey}:StatoMacc:{idxMacchina}";
            RedisValue rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                result = JsonConvert.DeserializeObject<StatoMacchineModel>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.StatoMacchina(idxMacchina);
                // serializzp e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await redisDb.StringSetAsync(currKey, rawData, TimeSpan.FromSeconds(2));
            }
            if (result == null)
            {
                result = new StatoMacchineModel();
            }
            sw.Stop();
            Log.Debug($"StatoMacchina | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Intera vista v_MSFD
        /// </summary>
        /// <returns></returns>
        public async Task<List<VMSFDModel>> VMSFDGetAll()
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<VMSFDModel> result = new List<VMSFDModel>();
            // cerco in redis...
            string currKey = $"{redisBaseKey}:MSFD:ALL";
            RedisValue rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                result = JsonConvert.DeserializeObject<List<VMSFDModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbIocController.VMSFDGetAll();
                // serializzp e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (result == null)
            {
                result = new List<VMSFDModel>();
            }
            sw.Stop();
            Log.Debug($"VMSFDGetAll | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Vista v_MSFD x singola macchina (da stored) - singolo record
        /// </summary>
        /// <param name="idxMacc"></param>
        /// <returns></returns>
        public async Task<List<VMSFDModel>> VMSFDGetByMacc(string idxMacc)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<VMSFDModel>? result = new List<VMSFDModel>();
            // cerco in redis...
            string currKey = $"{redisBaseKey}:MSFD:MACCH:{idxMacc}";
            RedisValue rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                result = JsonConvert.DeserializeObject<List<VMSFDModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbIocController.VMSFDGetByMacc(idxMacc);
                // serializzp e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await redisDb.StringSetAsync(currKey, rawData, UltraFastCache);
            }
            if (result == null)
            {
                result = new List<VMSFDModel>();
            }
            sw.Stop();
            Log.Debug($"VMSFDGetByMacc | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }
        /// <summary>
        /// Vista v_MSFD delle machine MULTI filtrato x macchina (da stored)
        /// </summary>
        /// <param name="idxMacc"></param>
        /// <returns></returns>
        public async Task<List<VMSFDModel>> VMSFDGetMultiByMacc(string idxMacc)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<VMSFDModel>? result = new List<VMSFDModel>();
            // cerco in redis...
            string currKey = $"{redisBaseKey}:MSFD:MULTI:{idxMacc}";
            RedisValue rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                result = JsonConvert.DeserializeObject<List<VMSFDModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbIocController.VMSFDGetByMacc(idxMacc);
                // serializzp e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (result == null)
            {
                result = new List<VMSFDModel>();
            }
            sw.Stop();
            Log.Debug($"VMSFDGetMultiByMacc | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        #endregion Public Methods

        #region Protected Fields

        /// <summary>
        /// Oggetto per connessione a REDIS
        /// </summary>
        protected ConnectionMultiplexer redisConn = null!;

        /// <summary>
        /// Oggetto DB redis da impiegare x chiamate R/W
        /// </summary>
        protected IDatabase redisDb = null!;

        #endregion Protected Fields

        #region Private Fields

        private static Logger Log = LogManager.GetCurrentClassLogger();
        private string redisBaseKey = "MP:TAB:Cache";
        private string moonProRedisBaseKey = "MoonPro:SQL2016DEV:MoonPro:hM2IOB";

        #endregion Private Fields
        /// <summary>
        /// Aggiunta record EventList
        /// </summary>
        /// <param name="newRec"></param>
        /// <returns></returns>
        public async Task<bool> EvListInsert(EventListModel newRec)
        {
            bool fatto = false;
            using (var dbCtx = new MoonProContext(_configuration))
            {
                try
                {
                    var currRec = dbCtx
                                    .DbSetEvList
                                    .Add(newRec);
                    await dbCtx.SaveChangesAsync();
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione durante EvListInsert{Environment.NewLine}{exc}");
                }
            }
            await Task.Delay(1);
            return fatto;
        }

        /// <summary>
        /// scrive una riga di evento inviato da Barcode nel db
        /// </summary>
        /// <param name="idxMacchina">codice macchina</param>
        /// <param name="idxTipo">idx evento</param>
        /// <param name="codArticolo">Codice Articolo</param>
        /// <param name="value">valore</param>
        /// <param name="matrOpr">matricola operatore</param>
        /// <param name="pallet">pallet (vuoto se nd)</param>
        /// <returns></returns>
        public async Task<inputComandoMapo> scriviRigaEventoBarcode(string idxMacchina, int idxTipo, string codArticolo, string value, int matrOpr, string pallet)
        {
            bool inserito = false;
            DateTime adesso = DateTime.Now;
            EventListModel newRec = new EventListModel()
            {
                IdxMacchina = idxMacchina,
                InizioStato = adesso,
                IdxTipo = idxTipo,
                CodArticolo = codArticolo,
                Value = value,
                MatrOpr = matrOpr,
                pallet = pallet
            };
            try
            {
                // inserisco evento
                inserito = await EvListInsert(newRec);
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in fase di scrittura evento con i seguenti dati | macchina: {idxMacchina} | IdxTipo: {idxTipo} | CodArticolo: {codArticolo} | Value {value} | MatrOpr {matrOpr} | Pallet {pallet}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            try
            {
                // faccio controllo per eventuale cambio stato da tab transizioni...
                checkCambiaStatoBatch(tipoInputEvento.barcode, idxMacchina, adesso, idxTipo, codArticolo, value, matrOpr, pallet);
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in checkCambiaStatoBatch(6) | tipoInputEvento: {tipoInputEvento.barcode} | macchina: {idxMacchina} | dataOra: {adesso} | IdxTipo: {idxTipo} | CodArticolo: {codArticolo} | Value {value} | MatrOpr {matrOpr} | Pallet {pallet}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            // formatto output
            inputComandoMapo answ = new inputComandoMapo();
            answ.outValue = inserito.ToString();
            answ.needStatusRefresh = true;
            return answ;
        }
        /// <summary>
        /// Verifica se sia necessario inserire un cambio di stato impianto in modalità batch
        /// </summary>
        /// <param name="tipoInput"></param>
        /// <param name="IdxMacchina"></param>
        /// <param name="InizioStato"></param>
        /// <param name="IdxTipo"></param>
        /// <param name="CodArt"></param>
        /// <param name="Value"></param>
        /// <param name="MatrOpr"></param>
        /// <param name="pallet"></param>
        private void checkCambiaStatoBatch(tipoInputEvento tipoInput, string IdxMacchina, DateTime InizioStato, int IdxTipo, string CodArt, string Value, int MatrOpr, string pallet)
        {
#if false
            DS_applicazione.TransizioneStatiDataTable tabTransStati;
            DS_applicazione.TransizioneStatiRow rigaTransStati;
            switch (tipoInput)
            {
                case tipoInputEvento.barcode:
                    // effettuo cambio stato INDIPENDENTEMENTE da stato precedente
                    try
                    {
                        tabTransStati = MapoDbObj.taTranSt.GetUserForcedTransitions(IdxMacchina, IdxTipo);
                        if (tabTransStati != null)
                        {
                            if (tabTransStati.Count > 0)
                            {
                                rigaTransStati = tabTransStati[0];
                                // solo se cambia stato...
                                if (rigaTransStati.IdxStato != rigaTransStati.next_IdxStato)
                                {
                                    MapoDbObj.taDiario.InsStatoBatch(IdxMacchina, InizioStato, rigaTransStati.next_IdxStato, CodArt, Value, MatrOpr, pallet);
                                    // aggiorno MSE
                                    taMSE.forceRecalc(0, IdxMacchina);
                                }
                            }
                            else
                            {
                                if (_logLevel > 6)
                                {
                                    Log.Info($"Non trovata riga per: BARCODE | IdxMacchina: {IdxMacchina} | IdxTipo: {IdxTipo} | CodArt: {CodArt} | Value: {Value} | MatrOpr: {MatrOpr} | pallet: {pallet}", tipoLog.INFO);
                                }
                            }
                        }
                    }
                    catch (Exception exc)
                    {
                        // non dovrebbe succedere... input utente da barcode dovrebbero TUTTI essere
                        // inseriti in tab transizione con famiglia 1...
                        Log.Info($"Errore controllo transizione stato x evento barcode: BARCODE | IdxMacchina: {IdxMacchina} | IdxTipo: {IdxTipo} | CodArt: {CodArt} | Value: {Value} | MatrOpr: {MatrOpr} | pallet: {pallet}{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
                    }
                    break;

                case tipoInputEvento.hw:
                    // verifico se ci sia necessità di cambio stato
                    try
                    {
                        tabTransStati = MapoDbObj.taTranSt.GetHwTransitions(IdxMacchina, IdxTipo);
                        if (tabTransStati != null)
                        {
                            if (tabTransStati.Count > 0)
                            {
                                rigaTransStati = tabTransStati[0];
                                if (rigaTransStati != null)
                                {
                                    // solo se cambia stato...
                                    if (rigaTransStati.IdxStato != rigaTransStati.next_IdxStato)
                                    {
                                        MapoDbObj.taDiario.InsStatoBatch(IdxMacchina, InizioStato, rigaTransStati.next_IdxStato, CodArt, Value, MatrOpr, pallet);
                                    }
                                }
                            }
                            else
                            {
                                if (_logLevel > 6)
                                {
                                    Log.Info($"Non trovata riga per: HW | IdxMacchina: {IdxMacchina} | IdxTipo: {IdxTipo} | CodArt: {CodArt} | Value: {Value} | MatrOpr: {MatrOpr} | pallet: {pallet}", tipoLog.INFO);
                                }
                            }
                        }
                    }
                    catch (Exception exc)
                    {
                        // non trovo riga [0]... NON scrivo!
                        Log.Info($"Errore controllo transizione stato x evento barcode: HW | IdxMacchina: {IdxMacchina} | IdxTipo: {IdxTipo} | CodArt: {CodArt} | Value: {Value} | MatrOpr: {MatrOpr} | pallet: {pallet}{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
                    }
                    break;
            } 
#endif
        }

        /// <summary>
        /// Effettua reset microstato macchina
        /// </summary>
        /// <param name="idxMacchina"></param>
        public void resetMicrostatoMacchina(string idxMacchina)
        {
            // salvo microstato 0...
            MicroStatoMacchinaModel newRecMS = new MicroStatoMacchinaModel()
            {
                IdxMacchina = idxMacchina,
                InizioStato = DateTime.Now,
                IdxMicroStato = 0,
                Value = "FER"
            };
            var result = dbTabController.MicroStatoMacchinaUpsert(newRecMS);
            // reset in redis
            resetDatiMacchina(idxMacchina);
        }

        /// <summary>
        /// Resetta (rileggendo) i dati della macchina
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        public Dictionary<string, string> resetDatiMacchina(string idxMacchina)
        {
            Dictionary<string, string> answ = new Dictionary<string, string>();
#if false
            string currHash = dtMaccHash(idxMacchina);
            // inizio con un bel reset...
            memLayer.ML.redFlushKey(currHash);
            DS_applicazione.MSFDDataTable tabMSFD = new DS_applicazione.MSFDDataTable();
            // 2018.01.08 SEMPRE senza singleton: instanzio un nuovo oggetto MapoDb
            MapoDb connDb = new MapoDb();
            tabMSFD = connDb.taMSFD.getByIdxMacc(idxMacchina);
            bool trovato = false;
            // se ho righe...
            DS_applicazione.MSFDDataTable tab = new DS_applicazione.MSFDDataTable();
            DS_applicazione.MSFDRow rigaMSFD;
            if (tabMSFD.Rows.Count > 0)
            {
                try
                {
                    rigaMSFD = tabMSFD[0];
                    trovato = true;
                }
                catch
                {
                    rigaMSFD = tab.NewMSFDRow();
                }
            }
            else
            {
                rigaMSFD = tab.NewMSFDRow();
            }
            if (trovato)
            {
                // ora provo a compilare...
                try
                {
                    // salvo 1:1 i valori... STATO
                    answ.Add("IdxMicroStato", rigaMSFD.IdxMicroStato.ToString());
                    answ.Add("IdxStato", rigaMSFD.IdxStato.ToString());
                    answ.Add("CodArticolo", rigaMSFD.CodArticolo);
                    answ.Add("insEnabled", rigaMSFD.insEnabled.ToString());
                    answ.Add("sLogEnabled", rigaMSFD.sLogEnabled.ToString());
                    answ.Add("pallet", rigaMSFD.pallet);
                    answ.Add("CodArticolo_A", rigaMSFD.CodArticolo_A);
                    answ.Add("CodArticolo_B", rigaMSFD.CodArticolo_B);
                    answ.Add("TempoCicloBase", rigaMSFD.TempoCicloBase.ToString());
                    answ.Add("PzPalletProd", rigaMSFD.PzPalletProd.ToString());
                    answ.Add("MatrOpr", rigaMSFD.MatrOpr.ToString());
                    answ.Add("lastVal", rigaMSFD.lastVal);
                    answ.Add("TCBase", rigaMSFD.TempoCicloBase.ToString());

                    //...e SETUP
                    answ.Add("CodMacc", rigaMSFD.codmacchina);
                    answ.Add("IdxFamIn", rigaMSFD.IdxFamigliaIngresso.ToString());
                    answ.Add("Multi", rigaMSFD.Multi.ToString());
                    answ.Add("BitFilt", rigaMSFD.BitFilt.ToString());
                    answ.Add("MaxVal", rigaMSFD.MaxVal.ToString());
                    answ.Add("BSR", rigaMSFD.BSR.ToString());
                    answ.Add("ExplodeBit", rigaMSFD.ExplodeBit.ToString());
                    answ.Add("NumBit", rigaMSFD.NumBit.ToString());
                    answ.Add("IdxFamMacc", rigaMSFD.IdxFamiglia.ToString());
                    answ.Add("simplePallet", rigaMSFD.simplePallet.ToString());
                    answ.Add("palletChange", rigaMSFD.palletChange.ToString());
                }
                catch (Exception exc)
                {
                    Log.Info(string.Format("Errore in compilazione dati MSFD:{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
                }
                // cerco dati master/slave...
                string isMaster = connDb.taM2S.getByMaster(idxMacchina).Count > 0 ? "1" : "0";
                string isSlave = connDb.taM2S.getBySlave(idxMacchina).Count > 0 ? "1" : "0";
                answ.Add("Master", isMaster);
                answ.Add("Slave", isSlave);

                // verifico il timeout che cambia a seconda che sia vero o falso insEnabled...
                int tOutShort = memLayer.ML.cdvi("TmOut.MS.S");
                int tOutLong = memLayer.ML.cdvi("TmOut.MS.L");
                int redDtMacTOut = tOutLong;
                try
                {
                    redDtMacTOut = (answ["insEnabled"].ToLower() == "true") ? tOutShort : tOutLong;
                }
                catch (Exception exc)
                {
                    Log.Info($"Eccezione in calcolo timeout dati macchina: idxMacchina{idxMacchina} | TShort: {tOutShort} | TLong {tOutLong}{Environment.NewLine}{exc}");
                }
                // salvo in redis!
                memLayer.ML.redSaveHashDict(currHash, answ, redDtMacTOut);
            }
            else
            {
                Log.Info("Errore in chiamata stp_MSFD_getMacc (connDb.taMSFD.getByIdxMacc(idxMacchina))");
            } 
#endif
            return answ;
        }
    }
}