using SteamWare;
using System;
using System.Collections.Generic;
using System.Data;

namespace MapoDb
{

  public struct inputComando
  {
    /// <summary>
    /// input comando valido si/no
    /// </summary>
    public bool isValid;
    /// <summary>
    /// testo da mostrare all'utente
    /// </summary>
    public string text2show;
    /// <summary>
    /// idx evento associato al comando
    /// </summary>
    public int idxTipoEvento;
    /// <summary>
    /// input precedente
    /// </summary>
    public string precInput;
    /// <summary>
    /// descrizione comando
    /// </summary>
    public string descrComando;
    /// <summary>
    /// refresh stato macchina encessario si/no
    /// </summary>
    public bool needStatusRefresh;
    /// <summary>
    /// lista del nome dei WebBrowserBox e delle relative url, nel formato {0}##{1} {0}=nome WebBrowserBox (es. box01), {1}=url relativo (es. http://server/MoonPro/Produzione.aspx?idxMacchina=99)
    /// </summary>
    public string[] wBrowsBoxUrls;
    /// <summary>
    /// valore di output dal comando
    /// </summary>
    public string outValue;
  }

  /// <summary>
  /// tipologia evento inviato
  /// </summary>
  public enum tipoInputEvento
  {
    barcode,
    hw
  }
  /// <summary>
  /// nuovo stato ingressi e eventuale evento da inviare
  /// </summary>
  public struct hwMachineState
  {
    public int next_IdxMicroStato;
    public int IdxTipoEvento;
  }

  public class MapoDb
  {
    #region area protected

    protected string _separatore = ",";
    protected string _connectionString = "";



    /// <summary>
    /// avvio i table adapter della classe
    /// </summary>
    private void AvviaTabAdapt()
    {
      taEvList = new DS_applicazioneTableAdapters.EventListTableAdapter();
      taDiario = new DS_applicazioneTableAdapters.DiarioDiBordoTableAdapter();
      taAnagSt = new DS_applicazioneTableAdapters.AnagraficaStatiTableAdapter();
      taAnagEv = new DS_applicazioneTableAdapters.AnagraficaEventiTableAdapter();
      taMacchine = new DS_applicazioneTableAdapters.MacchineTableAdapter();
      taTranEv = new DS_applicazioneTableAdapters.TransizioneEventiTableAdapter();
      taTranSt = new DS_applicazioneTableAdapters.TransizioneStatiTableAdapter();
      taStatoMacchine = new DS_applicazioneTableAdapters.StatoMacchineTableAdapter();
      taKeepAlive = new DS_applicazioneTableAdapters.KeepAliveTableAdapter();
      taRRL = new DS_applicazioneTableAdapters.RemoteRebootLogTableAdapter();
      taTransIngr = new DS_applicazioneTableAdapters.TransizioneIngressiTableAdapter();
      taAnOpr = new DS_applicazioneTableAdapters.AnagraficaOperatoriTableAdapter();
      taDatiMacch = new DS_applicazioneTableAdapters.DatiMacchineTableAdapter();
      taMSM = new DS_applicazioneTableAdapters.MicroStatoMacchinaTableAdapter();
      taMSFD = new DS_applicazioneTableAdapters.MSFDTableAdapter();
      taDatiMacchine = new DS_ProdTempiTableAdapters.DatiMacchineTableAdapter();
      taODL = new DS_ProdTempiTableAdapters.ODLTableAdapter();
      taTCRilevati = new DS_ProdTempiTableAdapters.TempiCicloRilevatiTableAdapter();
    }
    /// <summary>
    /// forza la connString x i vari table adapters
    /// </summary>
    private void setConnString()
    {
      _connectionString = SteamWare.memLayer.ML.confReadString("MoonProConnectionString");
      taEvList.Connection.ConnectionString = _connectionString;
      taDiario.Connection.ConnectionString = _connectionString;
      taAnagEv.Connection.ConnectionString = _connectionString;
      taAnagSt.Connection.ConnectionString = _connectionString;
      taMacchine.Connection.ConnectionString = _connectionString;
      taTranEv.Connection.ConnectionString = _connectionString;
      taTranSt.Connection.ConnectionString = _connectionString;
      taStatoMacchine.Connection.ConnectionString = _connectionString;
      taKeepAlive.Connection.ConnectionString = _connectionString;
      taRRL.Connection.ConnectionString = _connectionString;
      taTransIngr.Connection.ConnectionString = _connectionString;
      taAnOpr.Connection.ConnectionString = _connectionString;
      taDatiMacch.Connection.ConnectionString = _connectionString;
      taMSM.Connection.ConnectionString = _connectionString;
      taMSFD.Connection.ConnectionString = _connectionString;
      taDatiMacchine.Connection.ConnectionString = _connectionString;
      taODL.Connection.ConnectionString = _connectionString;
      taTCRilevati.Connection.ConnectionString = _connectionString;
    }
    /// <summary>
    /// cerca codice in anagrafica macchine ed eventualmente inserisce nuova macchina
    /// </summary>
    /// <param name="IdxMacchina"></param>
    private void verificaIdxMacchina(string IdxMacchina)
    {
      bool needDB = false;
      if (!memLayer.ML.CRB("disable_verificaIdxMacchina"))
      {
        if (memLayer.ML.CRB("IOB_RedEnab"))
        {
          try
          {
            // esecuzione in REDIS...cerco status macchina...
            if (DataLayer.mDatiMacchine(IdxMacchina).Count == 0)
            {
              needDB = true;
            }
          }
          catch
          { }
        }
        // ...oppure segno richiesta DB...
        else
        {
          needDB = true;
        }
        if (needDB)
        {
          // 2017.07.11 se richiesto di NON usare singleton... riporto FUORI la gestione NUOVO oggetto
          if (memLayer.ML.CRB("disable_singleton"))
          {
            taMacchine = new DS_applicazioneTableAdapters.MacchineTableAdapter();
            taMSM = new DS_applicazioneTableAdapters.MicroStatoMacchinaTableAdapter();
          }
          // verifico esistenza macchina
          if (taMacchine.GetByIdx(IdxMacchina).Rows.Count == 0)
          {
            // inserisco nuova macchina...
            taMacchine.Insert(IdxMacchina, "9999", IdxMacchina, "Macchina non codificata", "-", "http://", "nd", "col", 0, 0);
          }
          // verifico ci sia un microstato macchina...
          if (taMSM.getByIdxMacchina(IdxMacchina).Rows.Count == 0)
          {
            // inserisco nuovo stato...
            taMSM.Insert(IdxMacchina, 0, DateTime.Now, "00");
          }
        }
      }
    }
    /// <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)
    {
      DS_applicazione.TransizioneStatiRow rigaTransStati;
      switch (tipoInput)
      {
        case tipoInputEvento.barcode:
          // effettuo cambio stato INDIPENDENTEMENTE da stato precedente
          try
          {
            rigaTransStati = taTranSt.GetUserForcedTransitions(IdxMacchina, IdxTipo)[0];
            // solo se cambia stato...
            if (rigaTransStati.IdxStato != rigaTransStati.next_IdxStato)
            {
              taDiario.InsStatoBatch(IdxMacchina, InizioStato, rigaTransStati.next_IdxStato, CodArt, Value, MatrOpr, pallet);
              // aggiorno MSE
              DataLayer.obj.taMSE.forceRecalc(0, IdxMacchina);
            }
          }
          catch (Exception exc)
          {
            // non dovrebbe succedere... input utente da barcode dovrebbero TUTTI essere inseriti in tab transizione con famiglia 1...
            logger.lg.scriviLog(string.Format("Errore controllo transizione stato x evento barcode:{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
          }
          break;
        case tipoInputEvento.hw:
          // verifico se ci sia  necessità di cambio stato
          try
          {
            rigaTransStati = taTranSt.GetHwTransitions(IdxMacchina, IdxTipo)[0];
            if (rigaTransStati != null)
            {
              // solo se cambia stato...
              if (rigaTransStati.IdxStato != rigaTransStati.next_IdxStato)
              {
                taDiario.InsStatoBatch(IdxMacchina, InizioStato, rigaTransStati.next_IdxStato, CodArt, Value, MatrOpr, pallet);
              }
            }
          }
          catch
          {
            // non trovo riga [0]... NON scrivo!
          }
          break;
      }
    }

    /// <summary>
    /// metodo privato x fornire matricola che è correntemente sulla macchina
    /// </summary>
    /// <param name="idxMacchina"></param>
    /// <returns></returns>
    private int getMatrOpMacc(string idxMacchina)
    {
      int matr = -1;
      try
      {
        matr = (taStatoMacchine.GetDataByIdxMacchina(idxMacchina)[0]).MatrOpr;
      }
      catch
      {
      }
      return matr;
    }
    /// <summary>
    /// metodo privato x fornire cognome-nome dalla matricola
    /// </summary>
    /// <param name="matrOpr"></param>
    /// <returns></returns>
    private string getGeneralitDaMatr(int matrOpr)
    {
      string cognNome = "";
      // cerco operatore...
      DS_applicazione.AnagraficaOperatoriRow rigaOpr;
      try
      {
        rigaOpr = taAnOpr.getByMatrOpr(matrOpr)[0];
        cognNome = string.Format("{0} {1}", rigaOpr.Cognome, rigaOpr.Nome);
      }
      catch
      {
      }
      return cognNome;
    }

    #endregion

    #region area public

    #region area table adapters

    // area applicazione
    public DS_applicazioneTableAdapters.EventListTableAdapter taEvList;
    public DS_applicazioneTableAdapters.DiarioDiBordoTableAdapter taDiario;
    public DS_applicazioneTableAdapters.AnagraficaEventiTableAdapter taAnagEv;
    public DS_applicazioneTableAdapters.AnagraficaStatiTableAdapter taAnagSt;
    public DS_applicazioneTableAdapters.MacchineTableAdapter taMacchine;
    public DS_applicazioneTableAdapters.TransizioneEventiTableAdapter taTranEv;
    public DS_applicazioneTableAdapters.TransizioneStatiTableAdapter taTranSt;
    public DS_applicazioneTableAdapters.StatoMacchineTableAdapter taStatoMacchine;
    public DS_applicazioneTableAdapters.KeepAliveTableAdapter taKeepAlive;
    public DS_applicazioneTableAdapters.RemoteRebootLogTableAdapter taRRL;
    public DS_applicazioneTableAdapters.TransizioneIngressiTableAdapter taTransIngr;
    public DS_applicazioneTableAdapters.AnagraficaOperatoriTableAdapter taAnOpr;
    public DS_applicazioneTableAdapters.DatiMacchineTableAdapter taDatiMacch;
    public DS_applicazioneTableAdapters.MicroStatoMacchinaTableAdapter taMSM;
    public DS_applicazioneTableAdapters.MSFDTableAdapter taMSFD;
    // area tempi ciclo
    public DS_ProdTempiTableAdapters.DatiMacchineTableAdapter taDatiMacchine;
    public DS_ProdTempiTableAdapters.ODLTableAdapter taODL;
    public DS_ProdTempiTableAdapters.TempiCicloRilevatiTableAdapter taTCRilevati;

    #endregion


    /// <summary>
    /// avvio della classe
    /// </summary>
    public MapoDb()
    {
      AvviaTabAdapt();
    }

    /// <summary>
    /// Oggetto singleton x MapoDb
    /// </summary>
    /// <returns></returns>
    public static MapoDb obj = new MapoDb();
    /// <summary>
    /// restituisce la stringa di connessione al db
    /// </summary>
    public string getStringaConnessione()
    {
      return _connectionString;
    }
    /// <summary>
    /// imposta la stringa di connessione al db
    /// </summary>
    public bool setStringaConnessione(string valore)
    {
      _connectionString = valore;
      setConnString();
      return true;
    }
    /// <summary>
    /// scrive una riga di evento 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>
    /// <param name="eventTime">data-ora dell'evento</param>
    /// <param name="currentTime">data-ora corrente dell'invio</param>
    /// <returns></returns>
    public inputComando scriviRigaEvento(string IdxMacchina, int IdxTipo, string CodArticolo, string Value, int MatrOpr, string pallet, DateTime eventTime, DateTime currentTime)
    {
      int inserito = 0;
      // 2017.07.11 se richiesto di NON usare singleton... riporto FUORI la gestione NUOVO oggetto
      if (memLayer.ML.CRB("disable_singleton"))
      {
        // 2017.06.09 forzo init x errori "sovrapposizioni"
        taEvList = new DS_applicazioneTableAdapters.EventListTableAdapter();
      }
      try
      {
        // verifico se esista la macchina altrimenti la creo...
        verificaIdxMacchina(IdxMacchina);
        // calcolo dataOra reale (evento + delta(ora server - ora remota)
        DateTime dataOra = eventTime.Add(DateTime.Now - currentTime);
        // inserisco evento
        inserito = taEvList.Insert(IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, MatrOpr, pallet);
        // faccio controllo per eventuale cambio stato da tab transizioni...
        checkCambiaStatoBatch(tipoInputEvento.hw, IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, MatrOpr, pallet);
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("Errore in fase di scrittura evento con i seguenti dati:{0} macchina {1}{0} IdxTipo {2}{0} CodArticolo {3}{0} Value {4}{0} MatrOpr {5}{0} Pallet {6}{0} eventTime {7}{0} currentTime {8}{0} eccezione: {0}{9}", Environment.NewLine, IdxMacchina, IdxTipo, CodArticolo, Value, MatrOpr, pallet, eventTime, currentTime, exc), tipoLog.EXCEPTION);
      }
      // formatto output
      inputComando answ = new inputComando();
      answ.outValue = inserito.ToString();
      answ.needStatusRefresh = true;
      return answ;
    }
    /// <summary>
    /// scrive una riga di evento 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 inputComando scriviRigaEvento(string IdxMacchina, int IdxTipo, string CodArticolo, string Value, int MatrOpr, string pallet)
    {
      int inserito = 0;
      // 2017.06.09 forzo init x errori "sovrapposizioni"
      taEvList = new DS_applicazioneTableAdapters.EventListTableAdapter();
      try
      {
        // verifico se esista la macchina altrimenti la creo...
        verificaIdxMacchina(IdxMacchina);
        DateTime dataOra = DateTime.Now;
        // inserisco evento
        inserito = taEvList.Insert(IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, MatrOpr, pallet);
        // faccio controllo per eventuale cambio stato da tab transizioni...
        checkCambiaStatoBatch(tipoInputEvento.hw, IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, MatrOpr, pallet);
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("Errore in fase di scrittura evento con i seguenti dati:{0} macchina {1}{0} IdxTipo {2}{0} CodArticolo {3}{0} Value {4}{0} MatrOpr {5}{0} Pallet {6}{0} eccezione:{0}{7}", Environment.NewLine, IdxMacchina, IdxTipo, CodArticolo, Value, MatrOpr, pallet, exc), tipoLog.EXCEPTION);
      }
      // formatto output
      inputComando answ = new inputComando();
      answ.outValue = inserito.ToString();
      answ.needStatusRefresh = true;
      return answ;
    }
    /// <summary>
    /// restituisce boolean se la macchina sia abilitata x inserimento dati (tab DatiMacchine)
    /// </summary>
    /// <param name="idxMacchina"></param>
    /// <returns></returns>
    public bool insEnabled(string idxMacchina)
    {
      bool answ = false;
      try
      {
        answ = taDatiMacch.GetByIdx(idxMacchina)[0].insEnabled;
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// restituisce valore dell'ODL attivo (iniziato e NON concluso)
    /// </summary>
    /// <param name="idxMacchina"></param>
    /// <returns></returns>
    public string currODL(string idxMacchina)
    {
      string answ = "";
      // recupero con stored NUOVA...
      DS_ProdTempi.ODLDataTable tabOdl = DataLayer.obj.taODL.getByMacchina(idxMacchina);
      if (tabOdl.Rows.Count > 0)
      {
        // solo SE ho idxODL (altrimenti loggo errore)
        if (tabOdl[0].IdxODL > 0)
        {
          answ = tabOdl[0].IdxODL.ToString();
          answ = answ == "" ? "0" : answ;
        }
        else
        {
          answ = "0";
          logger.lg.scriviLog("[currODL] Errore in currODL x idxMacchina " + idxMacchina + ": IdxODL = 0");
        }
      }
      else
      {
        // se è empty --> 0!!!
        answ = "0";
      }
      // ultimo controllo su idxOdl...
      answ = answ == "" ? "0" : answ;
      // restituisco!
      return answ;
    }
    /// <summary>
    /// Testituisce tabella con riga dell'ODL attivo (iniziato e NON concluso)
    /// </summary>
    /// <param name="idxMacchina"></param>
    /// <returns></returns>
    public DS_ProdTempi.ODLDataTable currODLTab(string idxMacchina)
    {
      DS_ProdTempi.ODLDataTable answ = null;
      logger.lg.scriviLog("Recupero currODLTab da DB!", tipoLog.INFO);
      try
      {
        answ = DataLayer.obj.taODL.getByMacchina(idxMacchina);
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog($"Eccezione in recupero currODLTab{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
      }
      // restituisco!
      return answ;
    }
    /// <summary>
    /// Testituisce tabella con riga dell'ODL attivo (iniziato e NON concluso)
    /// </summary>
    /// <param name="idxMacchina"></param>
    /// <returns></returns>
    public DS_applicazione.StatoMacchineDataTable currStatoMaccTab(string idxMacchina)
    {
      DS_applicazione.StatoMacchineDataTable answ = null;
      logger.lg.scriviLog("Recupero currStatoMaccTab da DB!", tipoLog.INFO);
      try
      {
        answ = DataLayer.obj.taStatoMacchine.GetDataByIdxMacchina(idxMacchina);
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog($"Eccezione in recupero currStatoMaccTab{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
      }
      // restituisco!
      return answ;
    }
    /// <summary>
    /// restituisce boolean se la macchina sia abilitata x registrazione segnali in input (tab DatiMacchine)
    /// </summary>
    /// <param name="idxMacchina"></param>
    /// <returns></returns>
    public bool sLogEnabled(string idxMacchina)
    {
      bool answ = false;
      try
      {
        // 2017.07.11 se richiesto di NON usare singleton... riporto FUORI la gestione NUOVO oggetto
        if (memLayer.ML.CRB("disable_singleton"))
        {
          //2017.06.09 forzo inizializzazione oggetto..
          taDatiMacch = new DS_applicazioneTableAdapters.DatiMacchineTableAdapter();
        }
        answ = taDatiMacch.GetByIdx(idxMacchina)[0].sLogEnabled;
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// Restituisce il valore booleano se la macchina sia di tipo MULTI (con più state machine x INGRESSI)
    /// </summary>
    /// <param name="idxMacchina"></param>
    /// <returns></returns>
    public bool isMulti(string idxMacchina)
    {
      bool answ = false;
      try
      {
        // 2017.07.11 se richiesto di NON usare singleton... riporto FUORI la gestione NUOVO oggetto
        if (memLayer.ML.CRB("disable_singleton"))
        {
          //2017.06.09 forzo inizializzazione oggetto..
          taMSFD = new DS_applicazioneTableAdapters.MSFDTableAdapter();
        }
        answ = taMSFD.getByIdxMacc(idxMacchina)[0].Multi == 1;
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// salva il segnale di "microstato"
    /// </summary>
    /// <param name="idxMacchina">idx macchina</param>
    /// <param name="valore">valore ingresso</param>
    /// <param name="dtEve">data-ora evento (server)</param>
    /// <param name="contatore">sequenza dati inviati</param>
    /// <returns></returns>
    public void saveSigLog(string idxMacchina, string valore, DateTime dtEve, string contatore)
    {
      int cont = 0;
      try
      {
        cont = Convert.ToInt32(contatore);
      }
      catch
      { }
      // 2017.07.11 se richiesto di NON usare singleton... riporto FUORI la gestione NUOVO oggetto
      if (memLayer.ML.CRB("disable_singleton"))
      {
        // 2017.06.09 forzo init x errori "sovrapposizioni"
        DataLayer.obj.taSigLog = new DS_applicazioneTableAdapters.SignalLogTableAdapter();
      }
      DataLayer.obj.taSigLog.Insert(DateTime.Now, idxMacchina, valore, dtEve, cont);
    }
    /// <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">valore ingresso</param>
    /// <param name="dtEve">data-ora evento (server)</param>
    /// <param name="contatore">sequenza dati inviati</param>
    /// <returns></returns>
    public inputComando checkMicroStato(string idxMacchina, string valore, DateTime dtEve, string contatore)
    {
      int _logLevel = memLayer.ML.CRI("_logLevel");
      // recupero SE IMPIEGATO REDIS i valori del Dictionary della macchina...
      Dictionary<string, string> datiMacc = DataLayer.mDatiMacchine(idxMacchina);

      if (_logLevel > 6)
      {
        logger.lg.scriviLog(string.Format("[ChkMiSt]{2}---------------------------{2}Richiesta verifica INPUT per Macchina {0}, seriale {1}", idxMacchina, valore, Environment.NewLine), tipoLog.INFO);
      }
      // formatto output
      inputComando answ = new inputComando();
      DS_applicazione.TransizioneIngressiDataTable TabTransIn;
      DS_applicazione.TransizioneIngressiRow rigaTransIn = null;
      // verifico se esista la macchina altrimenti la creo... REDIS compliant
      verificaIdxMacchina(idxMacchina);
      string CodArticolo = "";
      if (memLayer.ML.CRB("IOB_RedEnab"))
      {
        try
        {
          // esecuzione in REDIS
          CodArticolo = datiMacc["CodArticolo"];
        }
        catch
        { }
      }
      // ...oppure dritto su DB
      else
      {
        // esecuzione in DB...
        // recupero CodArticolo corretto
        try
        {
          // 2017.07.11 se richiesto di NON usare singleton... riporto FUORI la gestione NUOVO oggetto
          if (memLayer.ML.CRB("disable_singleton"))
          {
            // 2017.07.10 forzo init x errori "sovrapposizioni"
            taDatiMacchine = new DS_ProdTempiTableAdapters.DatiMacchineTableAdapter();
          }
          CodArticolo = taDatiMacchine.getByIdx(idxMacchina)[0].CodArticolo_A;
        }
        catch (Exception exc)
        {
          logger.lg.scriviLog(string.Format("[ChkMiSt_4a] - Eccezione in recupero CodArticolo:{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
        }
      }
      // recupero next microstato
      int? valINT = 0;
      try
      {
        valINT = int.Parse(valore, System.Globalization.NumberStyles.HexNumber);
        // esecuzione in REDIS...
        if (memLayer.ML.CRB("IOB_RedEnab"))
        {
          try
          {
            int idxFamIn = Convert.ToInt32(datiMacc["IdxFamIn"]);
            int idxMicroStato = Convert.ToInt32(datiMacc["IdxMicroStato"]);
            int valIOB = Convert.ToInt32(valINT);
            int idxTipoEv = 0;
            int next_idxMS = idxMicroStato;
            // verifico esistenza tab SMI...
            string fiHASH = DataLayer.hSMI(idxFamIn);
            string todoSMI = "";
            bool trovato = memLayer.ML.redHashPresentSz(fiHASH);
            if (!trovato)
            {
              // ricarico tabella!
              KeyValuePair<string, string>[] valori = DataLayer.mTabSMI(idxFamIn);
            }
            // recupero singolo valore (stringa) x chiave
            todoSMI = DataLayer.valoreSMI(idxFamIn, idxMicroStato, valIOB);
            // solo se ho trovato un risultato nella tab SMI della famiglia macchina...
            if (todoSMI != "")
            {
              // splitto e salvo valori OUT...
              string[] valori = todoSMI.Split('_');
              idxTipoEv = Convert.ToInt32(valori[0]);
              next_idxMS = Convert.ToInt32(valori[1]);
              // creo la riga tipizzatya dai dati di redis x procedere...
              DS_applicazione.TransizioneIngressiDataTable tab = new DS_applicazione.TransizioneIngressiDataTable();
              rigaTransIn = tab.NewTransizioneIngressiRow();
              rigaTransIn.IdxFamigliaIngresso = idxFamIn;
              rigaTransIn.IdxMicroStato = idxMicroStato;
              rigaTransIn.ValoreIngresso = valIOB;
              rigaTransIn.IdxTipoEvento = idxTipoEv;
              rigaTransIn.next_IdxMicroStato = next_idxMS;
            }
          }
          catch
          { }
        }
        // ...oppure dritto su DB
        else
        {
          // 2017.07.11 se richiesto di NON usare singleton... riporto FUORI la gestione NUOVO oggetto
          if (memLayer.ML.CRB("disable_singleton"))
          {
            // 2017.06.09 forzo init x errori "sovrapposizioni"
            taTransIngr = new DS_applicazioneTableAdapters.TransizioneIngressiTableAdapter();
          }
          TabTransIn = taTransIngr.getByIdxMacchinaValore(idxMacchina, valINT);
          if (TabTransIn.Rows.Count > 0)
          {
            rigaTransIn = TabTransIn[0];
          }
        }
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("[ChkMiSt_5a] - - Eccezione in recupero riga Trans ingressi per idxMacchina {3} e valore {2}:{0}{1}", Environment.NewLine, exc, valINT, idxMacchina), tipoLog.EXCEPTION);
      }
      // effettuo update vari SU DB!!!
      if (rigaTransIn != null)
      {
        try
        {
          if (_logLevel > 5)
          {
            logger.lg.scriviLog(string.Format("[ChkMiSt_6a] - Salvo Update Microstato:{0}macchina: {1} | valore seriale: {2} | next micro stato: {3}", Environment.NewLine, idxMacchina, valINT, rigaTransIn.next_IdxMicroStato), tipoLog.INFO);
          }
          // 2017.07.11 se richiesto di NON usare singleton... riporto FUORI la gestione NUOVO oggetto
          if (memLayer.ML.CRB("disable_singleton"))
          {
            // 2017.06.09 forzo init x errori "sovrapposizioni"
            taMSM = new DS_applicazioneTableAdapters.MicroStatoMacchinaTableAdapter();
          }
          // salvo nuovo microstato...
          taMSM.updateQuery(rigaTransIn.next_IdxMicroStato, dtEve, valore, idxMacchina);
          // controllo se c'è evento
          if (rigaTransIn.IdxTipoEvento > 0)
          {
            if (_logLevel > 5)
            {
              logger.lg.scriviLog(string.Format("[ChkMiSt_7a] - Salvo evento:{0}macchina: {1} | tipoEvento: {2} | CodArticolo: {3} | contatore: {4} | valore: {5}", Environment.NewLine, idxMacchina, rigaTransIn.IdxTipoEvento, CodArticolo, contatore, valore), tipoLog.INFO);
            }
            string valEsteso = string.Format("[{0}] {1}", contatore.PadLeft(3, '0'), valore);
            // aggiunto contatore!
            answ = scriviRigaEvento(idxMacchina, rigaTransIn.IdxTipoEvento, CodArticolo, valEsteso, 0, "-", dtEve, DateTime.Now);
            // 2017.09.12 SE era in modalità redis RICARICA dati macchina...
            if (memLayer.ML.CRB("IOB_RedEnab"))
            {
              DataLayer.resetDatiMacchina(idxMacchina);
            }
            if (_logLevel > 5)
            {
              logger.lg.scriviLog(string.Format("[ChkMiSt_a] - Macchina {0} | seriale(INT) {1} | valEsteso {3} | answ {4}{2}---------------------------{2}", idxMacchina, valINT, Environment.NewLine, valEsteso, answ), tipoLog.INFO);
            }
          }
        }
        catch (Exception exc)
        {
          logger.lg.scriviLog(string.Format("[ChkMiSt_8a] - Eccezione:{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
        }
      }
      return answ;
    }
    /// <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">valore ingresso</param>
    /// <param name="dtEve">data-ora evento (server)</param>
    /// <returns></returns>
    public inputComando checkMicroStato(string idxMacchina, string valore, DateTime dtEve)
    {
      if (memLayer.ML.CRI("_logLevel") > 6)
      {
        logger.lg.scriviLog(string.Format("{2}---------------------------{2}Richiesta verifica INPUT per Macchina {0}, seriale {1}", idxMacchina, valore, Environment.NewLine), tipoLog.INFO);
      }
      // formatto output
      inputComando answ = new inputComando();
      DS_applicazione.TransizioneIngressiDataTable TabTransIn;
      DS_applicazione.TransizioneIngressiRow rigaTransIn = null;
      // verifico se esista la macchina altrimenti la creo...
      verificaIdxMacchina(idxMacchina);
      string CodArticolo = "";
      // recupero CodArticolo corretto
      try
      {
        // 2017.07.10 forzo init x errori "sovrapposizioni"
        taDatiMacchine = new DS_ProdTempiTableAdapters.DatiMacchineTableAdapter();
        CodArticolo = taDatiMacchine.getByIdx(idxMacchina)[0].CodArticolo_A;
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("[ChkMiSt_4b] - Eccezione in recupero CodArticolo:{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
      }
      // recupero next microstato
      //int? valINT = Convert.ToInt32(valore);
      int? valINT = 0;
      try
      {
        // 2017.06.09 forzo init x errori "sovrapposizioni"
        taTransIngr = new DS_applicazioneTableAdapters.TransizioneIngressiTableAdapter();
        valINT = int.Parse(valore, System.Globalization.NumberStyles.HexNumber);
        TabTransIn = taTransIngr.getByIdxMacchinaValore(idxMacchina, valINT);
        if (TabTransIn.Rows.Count > 0)
        {
          rigaTransIn = TabTransIn[0];
        }
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("[ChkMiSt_5b] - Eccezione in recupero riga Trans ingressi per idxMacchina {3} e valore {2}:{0}{1}", Environment.NewLine, exc, valINT, idxMacchina), tipoLog.EXCEPTION);
      }
      int _logLevel = memLayer.ML.CRI("_logLevel");
      // effettuo update vari
      if (rigaTransIn != null)
      {
        try
        {
          if (_logLevel > 5)
          {
            logger.lg.scriviLog(string.Format("[ChkMiSt_6b] - Salvo Update Microstato:{0}macchina: {1} | valore seriale: {2} | next micro stato: {3}", Environment.NewLine, idxMacchina, valINT, rigaTransIn.next_IdxMicroStato), tipoLog.INFO);
          }
          // salvo nuovo microstato...
          taMSM.updateQuery(rigaTransIn.next_IdxMicroStato, dtEve, valore, idxMacchina);
          // controllo se c'è evento
          if (rigaTransIn.IdxTipoEvento > 0)
          {
            if (_logLevel > 5)
            {
              logger.lg.scriviLog(string.Format("[ChkMiSt_7b] - Salvo evento:{0}macchina: {1} | tipoEvento: {2} | CodArticolo: {3}", Environment.NewLine, idxMacchina, rigaTransIn.IdxTipoEvento, CodArticolo), tipoLog.INFO);
            }
            answ = scriviRigaEvento(idxMacchina, rigaTransIn.IdxTipoEvento, CodArticolo, valore, 0, "-", dtEve, DateTime.Now);
            if (_logLevel > 5)
            {
              logger.lg.scriviLog(string.Format("[ChkMiSt_b] -Macchina {0}, seriale(INT) {1}{2}---------------------------{2}", idxMacchina, valINT, Environment.NewLine), tipoLog.INFO);
            }
          }
        }
        catch (Exception exc)
        {
          logger.lg.scriviLog(string.Format("[ChkMiSt_8b] - Eccezione:{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
        }
      }
      return answ;
    }
    /// <summary>
    /// controlla se da il segnale di "microstato" deriva un evento da generare
    /// </summary>
    /// <param name="idxMacchina"></param>
    /// <param name="valore"></param>
    /// <returns></returns>
    public inputComando checkMicroStato(string idxMacchina, string valore)
    {
      // wrapper ad ora corrente...
      return checkMicroStato(idxMacchina, valore, DateTime.Now);
    }
    /// <summary>
    /// 
    /// </summary>
    /// <param name="idxMacchina"></param>
    /// <param name="IPv4"></param>
    /// <param name="agent"></param>
    /// <param name="macAddr">mac address (inviato dalla macchina)</param>
    /// <returns></returns>
    public inputComando registraStartup(string idxMacchina, string IPv4, string agent, string macAddr)
    {
      if (memLayer.ML.CRI("_logLevel") > 6)
      {
        logger.lg.scriviLog(string.Format("{0}---------------------------{0}Richiesta registrazione (ri)avvio Macchina {1} - mac: {2}", Environment.NewLine, idxMacchina, macAddr), tipoLog.INFO);
      }
      // formatto output
      inputComando answ = new inputComando();
      // scrivo remote reboot alive!
      scriviRemoteReboot(idxMacchina, IPv4, agent, macAddr);
      // scrivo PRIMO keep alive
      scriviPrimoKeepAlive(idxMacchina, DateTime.Now);


      return answ;
    }

    /// <summary>
    /// scrive una riga di evento nel db SENZA passare operatore e pallet (mette a 0 e "-")
    /// </summary>
    /// <param name="IdxMacchina">codice macchina</param>
    /// <param name="IdxTipo">idx evento</param>
    /// <param name="CodArticolo">Codice Articolo</param>
    /// <param name="Value">valore</param>
    /// <returns></returns>
    public inputComando scriviRigaEvento(string IdxMacchina, int IdxTipo, string CodArticolo, string Value)
    {
      int inserito = 0;
      try
      {
        // verifico se esista la macchina altrimenti la creo...
        verificaIdxMacchina(IdxMacchina);
        DateTime dataOra = DateTime.Now;
        // inserisco evento
        inserito = taEvList.Insert(IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, 0, "-");
        // faccio controllo per eventuale cambio stato da tab transizioni...
        checkCambiaStatoBatch(tipoInputEvento.hw, IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, 0, "-");
      }
      catch
      {
        logger.lg.scriviLog(string.Format("Errore in fase di scrittura evento con i seguenti dati:{0} macchina {1}{0} IdxTipo {2}{0} CodArticolo {3}{0} Value {4}{0} eccezione: {0}{5}", Environment.NewLine, IdxMacchina, IdxTipo, CodArticolo, Value), tipoLog.EXCEPTION);
      }
      // formatto output
      inputComando answ = new inputComando();
      answ.outValue = inserito.ToString();
      answ.needStatusRefresh = true;
      return answ;
    }
    /// <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>
    /// <param name="eventTime">data-ora dell'evento</param>
    /// <param name="currentTime">data-ora corrente dell'invio</param>
    /// <returns></returns>
    public inputComando scriviRigaEventoBarcode(string IdxMacchina, int IdxTipo, string CodArticolo, string Value, int MatrOpr, string pallet, DateTime eventTime, DateTime currentTime)
    {
      int inserito = 0;
      try
      {
        // verifico se esista la macchina altrimenti la creo...
        verificaIdxMacchina(IdxMacchina);
        // calcolo dataOra reale (evento + delta(ora server - ora remota)
        DateTime dataOra = eventTime.Add(DateTime.Now - currentTime);
        // inserisco evento
        inserito = taEvList.Insert(IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, MatrOpr, pallet);
        // faccio controllo per eventuale cambio stato da tab transizioni...
        checkCambiaStatoBatch(tipoInputEvento.barcode, IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, MatrOpr, pallet);
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("Errore in fase di scrittura evento con i seguenti dati:{0} macchina {1}{0} IdxTipo {2}{0} CodArticolo {3}{0} Value {4}{0} MatrOpr {5}{0} Pallet {6}{0} eventTime {7}{0} currentTime {8}{0} eccezione: {0}{9}", Environment.NewLine, IdxMacchina, IdxTipo, CodArticolo, Value, MatrOpr, pallet, eventTime, currentTime, exc), tipoLog.EXCEPTION);
      }
      // formatto output
      inputComando answ = new inputComando();
      answ.outValue = inserito.ToString();
      answ.needStatusRefresh = true;
      return answ;
    }
    /// <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 inputComando scriviRigaEventoBarcode(string IdxMacchina, int IdxTipo, string CodArticolo, string Value, int MatrOpr, string pallet)
    {
      int inserito = 0;
      try
      {
        // verifico se esista la macchina altrimenti la creo...
        verificaIdxMacchina(IdxMacchina);
        DateTime dataOra = DateTime.Now;
        // inserisco evento
        inserito = taEvList.Insert(IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, MatrOpr, pallet);
        // faccio controllo per eventuale cambio stato da tab transizioni...
        checkCambiaStatoBatch(tipoInputEvento.barcode, IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, MatrOpr, pallet);
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("Errore in fase di scrittura evento con i seguenti dati:{0} macchina {1}{0} IdxTipo {2}{0} CodArticolo {3}{0} Value {4}{0} MatrOpr {5}{0} Pallet {6}{0} eccezione: {0}{7}", Environment.NewLine, IdxMacchina, IdxTipo, CodArticolo, Value, MatrOpr, pallet, exc), tipoLog.EXCEPTION);
      }
      // formatto output
      inputComando answ = new inputComando();
      answ.outValue = inserito.ToString();
      answ.needStatusRefresh = true;
      return answ;
    }
    /// <summary>
    /// scrive una riga di evento inviato da Barcode nel db SENZA operatore e pallet (mette a 0 e "-")
    /// </summary>
    /// <param name="IdxMacchina">codice macchina</param>
    /// <param name="IdxTipo">idx evento</param>
    /// <param name="CodArticolo">Codice Articolo</param>
    /// <param name="Value">valore</param>
    /// <returns></returns>
    public inputComando scriviRigaEventoBarcode(string IdxMacchina, int IdxTipo, string CodArticolo, string Value)
    {
      int inserito = 0;
      try
      {
        // verifico se esista la macchina altrimenti la creo...
        verificaIdxMacchina(IdxMacchina);
        DateTime dataOra = DateTime.Now;
        // inserisco evento
        inserito = taEvList.Insert(IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, 0, "-");
        // faccio controllo per eventuale cambio stato da tab transizioni...
        checkCambiaStatoBatch(tipoInputEvento.barcode, IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, 0, "-");
      }
      catch
      {
        logger.lg.scriviLog(string.Format("Errore in fase di scrittura evento con i seguenti dati:{0} macchina {1}{0} IdxTipo {2}{0} CodArticolo {3}{0} Value {4}{0} eccezione: {0}{5}", Environment.NewLine, IdxMacchina, IdxTipo, CodArticolo, Value), tipoLog.EXCEPTION);
      }
      // formatto output
      inputComando answ = new inputComando();
      answ.outValue = inserito.ToString();
      answ.needStatusRefresh = true;
      return answ;
    }
    /// <summary>
    /// scrive una riga di stato nel diario di bordo
    /// </summary>
    /// <param name="IdxMacchina">codice macchina</param>
    /// <param name="IdxStato">idx stato</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>
    /// <param name="eventTime">data-ora dell'evento</param>
    /// <param name="currentTime">data-ora corrente dell'invio</param>
    /// <returns></returns>
    public inputComando scriviRigaStato(string IdxMacchina, int IdxStato, string CodArticolo, string Value, int MatrOpr, string pallet, DateTime eventTime, DateTime currentTime)
    {
      int inserito = 0;
      try
      {
        // verifico se esista la macchina altrimenti la creo...
        verificaIdxMacchina(IdxMacchina);
        // calcolo dataOra reale (evento + delta(ora server - ora remota)
        DateTime dataOra = eventTime.Add(DateTime.Now - currentTime);
        // inserisco la nuova riga di stato mentre il trigger aggiorna le tab...
        inserito = taDiario.Insert(IdxMacchina, dataOra, null, IdxStato, null, Value, CodArticolo, null, null, MatrOpr, pallet);
      }
      catch
      {
        logger.lg.scriviLog(string.Format("Errore in fase di scrittura stato con i seguenti dati:{0} macchina {1}{0} IdxStato {2}{0} CodArticolo {3}{0} Value {4}{0} MatrOpr {5}{0} Pallet {6}{0} eventTime {7}{0} currentTime {8}{0} eccezione: {0}{9}", Environment.NewLine, IdxMacchina, IdxStato, CodArticolo, Value, MatrOpr, pallet, eventTime, currentTime), tipoLog.EXCEPTION);
      }
      // formatto output
      inputComando answ = new inputComando();
      answ.outValue = inserito.ToString();
      answ.needStatusRefresh = true;
      return answ;
    }
    /// <summary>
    /// Restituisce una stringa su 2 righe con intestazione colonne e valore dell'oggetto cercato tutti delimitati da separatore
    /// </summary>
    /// <param name="chiave"></param>
    /// <returns></returns>
    public string getAnagEventi(string chiave)
    {
      int IdxTipo = Convert.ToInt32(chiave);
      string _nomi = "";
      string _valori = "";
      DS_applicazione.AnagraficaEventiDataTable tabella = taAnagEv.GetByIdx(IdxTipo);
      foreach (System.Data.DataColumn colonna in tabella.Columns)
      {
        _nomi += string.Format("{0}{1}", colonna.ColumnName, _separatore);
        _valori += string.Format("{0}{1}", tabella[0][colonna.ColumnName], _separatore);
      }
      return string.Format("{0}\n\r{1}\n\r", _nomi, _valori);
    }
    /// <summary>
    /// Restituisce una stringa su 2 righe con intestazione colonne e valore dell'oggetto cercato tutti delimitati da separatore
    /// </summary>
    /// <param name="chiave"></param>
    /// <returns></returns>
    public string getAnagStati(string chiave)
    {
      int IdxStato = Convert.ToInt32(chiave);
      string _nomi = "";
      string _valori = "";
      DS_applicazione.AnagraficaStatiDataTable tabella = taAnagSt.GetByIdx(IdxStato);
      foreach (System.Data.DataColumn colonna in tabella.Columns)
      {
        _nomi += string.Format("{0}{1}", colonna.ColumnName, _separatore);
        _valori += string.Format("{0}{1}", tabella[0][colonna.ColumnName], _separatore);
      }
      return string.Format("{0}\n\r{1}\n\r", _nomi, _valori);
    }
    /// <summary>
    /// Restituisce una stringa su 2 righe con intestazione colonne e valore dell'oggetto cercato tutti delimitati da separatore
    /// </summary>
    /// <param name="chiave"></param>
    /// <returns></returns>
    public string getAnagMacchine(string chiave)
    {
      string _nomi = "";
      string _valori = "";
      DS_applicazione.MacchineDataTable tabella = taMacchine.GetByIdx(chiave);
      foreach (System.Data.DataColumn colonna in tabella.Columns)
      {
        _nomi += string.Format("{0}{1}", colonna.ColumnName, _separatore);
        _valori += string.Format("{0}{1}", tabella[0][colonna.ColumnName], _separatore);
      }
      return string.Format("{0}\n\r{1}\n\r", _nomi, _valori);
    }
    /// <summary>
    /// fornisce tabella elenco eventi
    /// </summary>
    /// <returns></returns>
    public DS_applicazione.EventListDataTable elencoEventi()
    {
      return taEvList.GetData();
    }
    /// <summary>
    /// fornisce tabella elenco stati (DiarioDiBordo)
    /// </summary>
    /// <returns></returns>
    public DS_applicazione.DiarioDiBordoDataTable elencoStati()
    {
      return taDiario.GetData();
    }
    /// <summary>
    /// restituisce l'oggetto tipizzato che rappresenta i dati del setup di una macchina
    /// </summary>
    /// <param name="idxMacchina"></param>
    /// <returns></returns>
    public DS_applicazione.DatiMacchineRow getDatiMacchina(string idxMacchina)
    {
      DS_applicazione.DatiMacchineRow answ = null;
      try
      {
        answ = taDatiMacch.GetByIdx(idxMacchina)[0];
      }
      catch
      {
        SteamWare.logger.lg.scriviLog(string.Format("Non sono riuscito a leggere la conf della macchina {0}", idxMacchina), SteamWare.tipoLog.ERROR);
      }
      return answ;
    }
    /// <summary>
    /// restituisce una tabella con tutte le transizioni degli ingressi per una data macchina
    /// </summary>
    /// <param name="idxMacchina"></param>
    /// <returns></returns>
    public DS_applicazione.TransizioneIngressiDataTable getMatriceIngressi(string idxMacchina)
    {
      DS_applicazione.TransizioneIngressiDataTable answ;
      try
      {
        answ = DataLayer.obj.taTranIngr.getMatriceByIdxMacchina(idxMacchina);
      }
      catch
      {
        answ = null;
      }
      return answ;
    }

    #region scritture eventi simulati

    public int scriviRigaEventoSimulata(DateTime dataOra, string IdxMacchina, int IdxTipo, string CodArticolo, string Value, int MatrOpr, string pallet)
    {
      // verifico se esista la macchina altrimenti la creo...
      verificaIdxMacchina(IdxMacchina);
      // inserisco evento
      int inserito = taEvList.Insert(IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, MatrOpr, pallet);
      return inserito;
    }
    public int scriviRigaStatoSimulata(DateTime dataOra, string IdxMacchina, int IdxStato, string CodArticolo, string Value, int MatrOpr, string pallet)
    {
      // verifico se esista la macchina altrimenti la creo...
      verificaIdxMacchina(IdxMacchina);
      // inserisco la nuova riga di stato mentre il trigger aggiorna le tab...
      int inserito = taDiario.Insert(IdxMacchina, dataOra, null, IdxStato, null, Value, CodArticolo, null, null, MatrOpr, pallet);
      return inserito;
    }

    public int scriviRigaEventoSimulata(DateTime dataOra, string IdxMacchina, int IdxTipo, string CodArticolo, string Value)
    {
      // verifico se esista la macchina altrimenti la creo...
      verificaIdxMacchina(IdxMacchina);
      // inserisco evento
      int inserito = taEvList.Insert(IdxMacchina, dataOra, IdxTipo, CodArticolo, Value, 0, "-");
      return inserito;
    }
    public int scriviRigaStatoSimulata(DateTime dataOra, string IdxMacchina, int IdxStato, string CodArticolo, string Value)
    {
      // verifico se esista la macchina altrimenti la creo...
      verificaIdxMacchina(IdxMacchina);
      // inserisco la nuova riga di stato mentre il trigger aggiorna le tab...
      int inserito = taDiario.Insert(IdxMacchina, dataOra, null, IdxStato, null, Value, CodArticolo, null, null, 0, "-");
      return inserito;
    }

    #endregion

    /// <summary>
    /// cancella tutti gli eventi
    /// </summary>
    public void deleteAllEventi()
    {
      taEvList.DeleteAll();
    }
    /// <summary>
    /// cancella tutti gli stati
    /// </summary>
    public void deleteAllStati()
    {
      taDiario.DeleteAll();
    }

    /// <summary>
    /// restituisce una riga di dati relativa ad una macchina
    /// </summary>
    /// <param name="idxMacchina"></param>
    /// <returns></returns>
    public DS_applicazione.MacchineRow getRigaMacchina(string idxMacchina)
    {
      return taMacchine.GetByIdx(idxMacchina)[0];
    }

    public DS_applicazione.EventListDataTable elencoEventiImpianto(string idxMacchina)
    {
      return taEvList.GetDataByIdxMacchina(idxMacchina);
    }
    public DS_applicazione.DiarioDiBordoDataTable elencoStatiImpianto(string idxMacchina)
    {
      return taDiario.GetDataByIdxMacchina(idxMacchina);
    }
    public DS_applicazione.EventListDataTable elencoEventiImpiantoPeriodo(string idxMacchina, DateTime dal, DateTime al)
    {
      return taEvList.GetByMacchinaPeriodo(idxMacchina, dal, al);
    }
    public DS_applicazione.DiarioDiBordoDataTable nextEventoImpiantoFrom(string idxMacchina, DateTime prevData)
    {
      return taDiario.getNextByMacchInizioStato(idxMacchina, prevData);
    }
    public DS_applicazione.DiarioDiBordoDataTable elencoStatiImpiantoPeriodo(string idxMacchina, DateTime dal, DateTime al)
    {
      DS_applicazione.DiarioDiBordoDataTable answ = new DS_applicazione.DiarioDiBordoDataTable();
      try
      {
        answ = taDiario.GetByMacchinaPeriodo(idxMacchina, dal, al);
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("Eccezione recupero elencoStatiImpiantoPeriodo:{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
      }
      return answ;
    }

    /// <summary> verifica che il bar code sia un barcode Operatore 
    /// </summary>
    /// <param name="codice"> Bar code da verificare</param>
    /// <returns> true se bar code per operatore </returns>
    public bool isOperatore(string codice)
    {
      // controlli validità bar code operatore : deve cominciare con O maiuscola
      bool check = codice.StartsWith("O");
      return check;
    }

    /// <summary> verifica che il bar code sia un barcode nomeMacchina 
    /// </summary>
    /// <param name="codice"> Bar code da verificare</param>
    /// <returns> true se bar code per operatore </returns>
    public bool isNomeMacchina(string codice)
    {
      // FARE!!! controllare quale codice ci vuole
      // controlli validità bar code nomeMacchina : deve cominciare con O maiuscola
      bool check = codice.StartsWith("C#");
      return check;
    }
    /// <summary>
    /// verifica un codice se sia di tipo "comando"
    /// </summary>
    /// <param name="comando"></param>
    /// <returns></returns>
    public inputComando isComando(string comando)
    {
      inputComando answ = new inputComando();
      answ.isValid = false;
      DS_applicazione.TransizioneEventiDataTable tabTransEv = new DS_applicazione.TransizioneEventiDataTable();
      try
      {
        tabTransEv = taTranEv.GetDataByCodInviato(comando);
      }
      catch
      {
      }
      if (tabTransEv.Rows.Count != 0)
      {
        answ.isValid = true;
        answ.idxTipoEvento = tabTransEv[0].IdxTipoEvento;
        answ.precInput = tabTransEv[0].prec_codInviato;
        answ.text2show = tabTransEv[0].text2show;
        try
        {
          answ.descrComando = tabTransEv[0].descrComando;
        }
        catch
        {
          answ.descrComando = "-";
        }
      }
      return answ;
    }

    /// <summary>
    /// restituisce una riga di dati relativa ad una macchina
    /// </summary>
    /// <param name="idxMacchina"></param>
    /// <returns></returns>
    public DS_applicazione.StatoMacchineRow getRigaStatoMacchina(string idxMacchina)
    {
      return taStatoMacchine.GetDataByIdxMacchina(idxMacchina)[0];
    }
    /// <summary>
    /// converte la definizioen di stato nel suo valore
    /// </summary>
    /// <param name="idx"></param>
    /// <returns></returns>
    public string statoDaIdxStato(int idx)
    {
      return taAnagSt.GetByIdx(idx)[0].Descrizione;
    }

    /// <summary>
    /// scrive un evento di keepalive sulla tabella
    /// </summary>
    /// <param name="IdxMacchina"></param>
    /// <param name="oraMacchina"></param>
    /// <returns></returns>
    public void scriviKeepAlive(string IdxMacchina, DateTime oraMacchina)
    {
      string nomeVar = string.Format("KeepAlive:{0}", IdxMacchina);
      // cerco se ho keep alive in redis, 
      bool keyPresent = false;
      DateTime adesso = DateTime.Now;
      try
      {
        keyPresent = memLayer.ML.redKeyPresentSz(memLayer.ML.redHash(nomeVar));
      }
      catch
      { }
      // se NON presente salvo in REDIS con TTL 10 sec e sul DB...
      if (!keyPresent)
      {
        memLayer.ML.setRSV(memLayer.ML.redHash(nomeVar), adesso.ToString("s"), 10);
        try
        {
          if (memLayer.ML.CRB("resetConnKA"))
          {
            if (memLayer.ML.CRB("forceResetKeepAlive"))
            {
              taKeepAlive.Connection.Close();
              taKeepAlive.Connection.Open();
            }
            else
            {
              if (taKeepAlive.Connection.State == ConnectionState.Closed)
              {
                taKeepAlive.Connection.Open();
              }
            }
          }
          if (memLayer.ML.CRI("_logLevel") > 6)
          {
            logger.lg.scriviLog(string.Format("Scrittura keep alive! IdxMacchina:{0} | oraMacchina:{1}", IdxMacchina, oraMacchina));
          }
          // 2017.07.11 se richiesto di NON usare singleton... riporto FUORI la gestione NUOVO oggetto
          if (memLayer.ML.CRB("disable_singleton"))
          {
            // 2017.06.09 forzo init x errori "sovrapposizioni"
            taKeepAlive = new DS_applicazioneTableAdapters.KeepAliveTableAdapter();
          }
          taKeepAlive.UpdateQueryNoStartTime(DateTime.Now, oraMacchina, IdxMacchina);
        }
        catch (Exception exc)
        {
          logger.lg.scriviLog(string.Format("Errore in scrittura keep alive!{0}oraMacchina:{1} - IdxMacchina:{2}{0}{3}", Environment.NewLine, oraMacchina, IdxMacchina, exc), tipoLog.EXCEPTION);
        }
      }
    }
    /// <summary>
    /// Registra un evento di RemoteReboot sulla tabella
    /// </summary>
    /// <param name="IdxMacchina"></param>
    /// <param name="IPv4"></param>
    /// <param name="macAddr"></param>
    /// <returns></returns>
    public void scriviRemoteReboot(string IdxMacchina, string IPv4, string agent, string macAddr)
    {
      taRRL.Insert(IdxMacchina, IPv4, agent, DateTime.Now, macAddr);
    }

    /// <summary>
    /// scrive un evento di start di keepalive sulla tabella
    /// </summary>
    /// <param name="IdxMacchina"></param>
    /// <param name="oraMacchina"></param>
    /// <returns></returns>
    public void scriviPrimoKeepAlive(string IdxMacchina, DateTime oraMacchina)
    {
      // se non c'è riga macchina insert...
      if (taKeepAlive.GetData().FindByIdxMacchina(IdxMacchina) == null)
      {
        taKeepAlive.Insert(IdxMacchina, DateTime.Now, oraMacchina, DateTime.Now);
      }
      else // altrimenti update!
      {
        taKeepAlive.UpdateQuery(DateTime.Now, oraMacchina, DateTime.Now, IdxMacchina);
      }
    }

    /// <summary>
    /// fornisce il prossimo IdxMicroStato della macchina a stati della gestione segnali in input
    /// </summary>
    /// <param name="IdxMacchina"></param>
    /// <param name="IdxMicroStato"></param>
    /// <param name="ValoreIngresso"></param>
    /// <returns></returns>
    public hwMachineState getNextMicroStato(string IdxMacchina, int IdxMicroStato, int ValoreIngresso)
    {
      hwMachineState valori = new hwMachineState();
      valori.IdxTipoEvento = -1;
      valori.next_IdxMicroStato = IdxMicroStato; // se non trovo un nuovo stato, resto in questo
                                                 // provo a recuperare i dati...
      DS_applicazione.TransizioneIngressiRow rigaIngr;
      try
      {
        rigaIngr = taTransIngr.GetNextStatus(IdxMacchina, IdxMicroStato, ValoreIngresso)[0];
        valori.IdxTipoEvento = rigaIngr.IdxTipoEvento;
        valori.next_IdxMicroStato = rigaIngr.next_IdxMicroStato;
      }
      catch
      {
      }
      return valori;
    }

    /// <summary>
    /// restituisce la stringa del colore della macchina (1 char, V/G/R)
    /// </summary>
    /// <param name="idxMacchina"></param>
    /// <returns></returns>
    public string getColoreMacchina(string idxMacchina)
    {
      string colore = "";
      // cerco stato macchina...
      DS_applicazione.StatoMacchineRow rigaStato;
      try
      {
        rigaStato = taStatoMacchine.GetDataByIdxMacchina(idxMacchina)[0];
        // cerco il colore...
        try
        {
          colore = taAnagSt.GetByIdx(rigaStato.IdxStato)[0].Semaforo;
        }
        catch
        {
        }
      }
      catch
      {
      }
      return colore;
    }
    /// <summary>
    /// restituisce la stringa del pallet correntemente in lavorazione sulla macchina
    /// </summary>
    /// <param name="idxMacchina"></param>
    /// <returns></returns>
    public string getPalletMacchina(string idxMacchina)
    {
      string pallet = "";
      try
      {
        pallet = (taStatoMacchine.GetDataByIdxMacchina(idxMacchina)[0]).pallet;
      }
      catch
      {
      }
      return pallet;
    }
    /// <summary>
    /// restituisce la matricola dell'operatore sulla macchina
    /// </summary>
    /// <param name="idxMacchina"></param>
    /// <returns></returns>
    public int getMatrOprMacchina(string idxMacchina)
    {
      return getMatrOpMacc(idxMacchina);
    }

    /// <summary>
    /// restituisce cognome nome dell'operatore data la sua matricola
    /// </summary>
    /// <param name="idxMacchina"></param>
    /// <returns></returns>
    public string getCognomeNomeDaMatr(int matrOpr)
    {
      return getGeneralitDaMatr(matrOpr);
    }
    /// <summary>
    /// restituisce cognome nome dell'operatore data la sua matricola
    /// </summary>
    /// <param name="idxMacchina"></param>
    /// <returns></returns>
    public string getCognomeNomeOprMacchina(string idxMacchina)
    {
      string cognNome = "";
      try
      {
        cognNome = getGeneralitDaMatr(getMatrOpMacc(idxMacchina));
      }
      catch
      {
      }
      return cognNome;
    }

    /// <summary>
    /// restituisce il TempoCiclo effettivo (tecnico) della macchina
    /// </summary>
    /// <param name="idxMacchina"></param>
    /// <returns></returns>
    public decimal getTcEffMacchina(string idxMacchina)
    {
      decimal tc = 0;
      try
      {
        DS_ProdTempi.stp_repDonati_getDatiProdMacchinaPeriodoRow riga = DataLayer.obj.taDatiProdMacchPer.GetData(idxMacchina, DateTime.Now.AddMinutes(-30), DateTime.Now)[0];
        if (riga.TCEffRT > 0)
        {
          tc = riga.TCEffRT;
        }
        else
        {
          tc = riga.TCAssegnato;
        }
      }
      catch
      { }
      // imposto a 99'TC
      if (tc == 0)
      {
        tc = 99.9M;
        // scrivo log per indicare mancato caricamento dati tc dichiarato e conseguente errore sul timer - 2/11/2012 EN&CV
        logger.lg.scriviLog(string.Format("Impostato TC Tempo Ciclo a 99' (99.9M) causa mancato inserimento tempo ciclo dichiarato"));
      }
      return tc;
    }

    /// <summary>
    /// rigenera la tab diario di bordo x la macchian richiesta nell'intervallo definito
    /// </summary>
    /// <param name="IdxMacchina"></param>
    /// <param name="dataInizio"></param>
    /// <param name="dataFine"></param>
    public void rigeneraDiarioDiBordo(string IdxMacchina, DateTime dataInizio, DateTime dataFine)
    {
      // elimino da diario di bordo i valori nell'intervallo...
      taDiario.DeleteByMacchinaPeriodo(IdxMacchina, dataInizio, dataFine);
      // seleziono le righe eventi interessate e le processo 1 ad 1...
      DS_applicazione.EventListDataTable tabEventi = taEvList.GetByMacchinaPeriodo(IdxMacchina, dataInizio, dataFine);
      foreach (DS_applicazione.EventListRow rigaEv in tabEventi)
      {
        if (rigaEv.IdxTipo <= 12) // è barcode
        {
          checkCambiaStatoBatch(tipoInputEvento.barcode, IdxMacchina, rigaEv.InizioStato, rigaEv.IdxTipo, rigaEv.CodArticolo, rigaEv.Value, rigaEv.MatrOpr, rigaEv.pallet);
        }
        else // è hw
        {
          checkCambiaStatoBatch(tipoInputEvento.hw, IdxMacchina, rigaEv.InizioStato, rigaEv.IdxTipo, rigaEv.CodArticolo, rigaEv.Value, rigaEv.MatrOpr, rigaEv.pallet);
        }
      }
    }
    /// <summary>
    /// restituisce la riga di transizione del comando...
    /// </summary>
    /// <param name="descrComando"></param>
    /// <returns></returns>
    public DS_applicazione.TransizioneEventiRow getRigaTransizioneDaDescrComando(string descrComando)
    {
      return taTranEv.getByDescrComando(descrComando)[0];
    }

    /// <summary>
    /// Dichiara esplicitamente produzione e tempo ciclo rilevato per il numero di pezzi indicati (real time, NON confermati)
    /// </summary>
    /// <param name="IdxMacchina"></param>
    /// <param name="CodArticolo"></param>
    /// <param name="tempoRilevato"></param>
    /// <param name="numPz"></param>
    /// <param name="eventTime"></param>
    /// <param name="currentTime"></param>
    public void dichiaraProduzTempoCiclo(string IdxMacchina, string CodArticolo, decimal tempoRilevato, int numPz, DateTime eventTime, DateTime currentTime)
    {
      // calcolo dataOra reale (evento + delta(ora server - ora remota)
      DateTime dataOra = eventTime.Add(DateTime.Now - currentTime);
      // scrivo il dato del TC rilevato
      taTCRilevati.Insert(IdxMacchina, CodArticolo, dataOra, tempoRilevato, numPz);
    }

    /// <summary>
    /// effettua verifica del codice barcode e restituisce un oggetto inputComando che indica come proseguire
    /// </summary>
    /// <param name="barcodeValue"></param>
    /// <returns></returns>
    public inputComando tryBarcode(string barcodeValue)
    {
      inputComando answ = new inputComando();
      // controllo...

      return answ;
    }

    #endregion
  }
}