using MapoDb;
using SteamWare;
using System;
using System.Text;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace MoonProTablet.WebUserControls
{
  public partial class mod_ODL : System.Web.UI.UserControl
  {
    /// <summary>
    /// registrato nuovo valore
    /// </summary>
    public event EventHandler eh_reqUpdate;
    /// <summary>
    /// Valore protected idxODL
    /// </summary>
    protected string _idxOdlMacc;
    /// <summary>
    /// Valore protected idxODL
    /// </summary>
    protected string _idxOdlAltraMacc;
    /// <summary>
    /// IdxODL sulla macchina
    /// </summary>
    public string idxOdlMacc
    {
      get
      {
        if (_idxOdlMacc == null)
        {
          _idxOdlMacc = DataLayer.currODL(idxMacchina, true);
        }
        return _idxOdlMacc;
      }
      set
      {
        _idxOdlMacc = value;
      }
    }
    /// <summary>
    /// IdxODL su ALTRA macchina (se multi)
    /// </summary>
    public string idxOdlAltraMacc
    {
      get
      {
        if (_idxOdlAltraMacc == null)
        {
          _idxOdlAltraMacc = DataLayer.currODL(idxMaccAltraTav, true);
        }
        return _idxOdlAltraMacc;
      }
      set
      {
        _idxOdlAltraMacc = value;
      }
    }
    /// <summary>
    /// Verifica se la macchina sia MULTI
    /// </summary>
    public bool isMulti
    {
      get
      {
        return DataLayer.isMulti(idxMacchina);
      }
    }

    public bool maccInAttr
    {
      get
      {
        bool answ = false;
        // controllo se la macchina è in attrezzaggio...
        DS_applicazione.StatoMacchineRow rigaStato = null;
        try
        {
          // se è multi controllo parent...
          if (isMulti)
          {
            rigaStato = selData.mng.rigaStato(idxMaccParent);
          }
          else
          {
            rigaStato = selData.mng.rigaStato(idxMacchina);
          }
          answ = (rigaStato.IdxStato == 2);
        }
        catch (Exception exc)
        {
          logger.lg.scriviLog(string.Format("Eccezione in recupero dati rigaStato! {0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
        }
        return answ;
      }
    }
    /// <summary>
    /// Verifica se la macchina NON abbia ODL (valido, > 0)
    /// </summary>
    public bool emptyOdlMacc
    {
      get
      {
        return (idxOdlMacc == "" || idxOdlMacc == "0");
      }
    }
    /// <summary>
    /// Verifica se la macchina NON abbia ODL (valido, > 0)
    /// </summary>
    public bool emptyOdlAltraMacc
    {
      get
      {
        return (idxOdlAltraMacc == "" || idxOdlAltraMacc == "0");
      }
    }
    /// <summary>
    /// Verifica visibilità btn split ODL su 2° tavola SE:
    /// - sia un impianto MULTI (= con + tavole)
    /// - sia già attrezzata la prima tavola
    /// - in tab Congif: se sia abilitato lo split ODL sulla seconda tavola 
    /// - la macchina SIA ANCORA in attrezzaggio (2019.07.08) = 2
    /// </summary> 
    protected bool showSplitOdlOnTavVal
    {
      get
      {
        bool answ = false;
        // se è multi controllo
        if (isMulti)
        {
          // verifico se NON HA ODL ma ce l'ha altra tavola...
          if (emptyOdlMacc)
          {
            // ora verifico SE ALTRA TAVOLA ha ODL...                                                                
            if (!emptyOdlAltraMacc)
            {
              // ora verifico SE E SOLO SE è ANCORA in attrezzaggio
              if (maccInAttr)
              {
                answ = memLayer.ML.cdvb("showSplitOdlOnTav");
              }
            }
          }
        }
        return answ;
      }
    }
    /// <summary>
    /// Verifica visibilità btn riprendi ODL su 2° tavola SE:
    /// - sia un impianto MULTI (= con + tavole)
    /// - sia disattrezzata la tavola 
    /// - in tab congif: se sia abilitato la ripresa ODL sulla seconda tavola 
    /// - in tab config: sia il grace period
    /// - NON SIANO passati i minuti indicati dalla chiusura
    /// </summary> 
    protected bool showReopOdlTav
    {
      get
      {
        bool answ = false;
        // se è multi controllo             
        if (isMulti)
        {
          // verifico se NON HA ODL...                      
          if (emptyOdlMacc)
          {
            // verifico SE siamo nel gracePeriod
            int gPeriod = memLayer.ML.cdvi("gPeriodReopenOdlTav");
            DateTime adesso = DateTime.Now;
            DateTime dtChiusura = DateTime.Now.AddHours(-1);
            try
            {
              dtChiusura = DataLayer.obj.taODL.getLastByMacc(idxMacchina)[0].DataFine;
            }
            catch
            { }

            // ora verifico SE E SOLO SE è ANCORA in attrezzaggio
            if (maccInAttr)
            {
              // ora verifico SE ALTRA TAVOLA ha ODL...
              if (dtChiusura.AddMinutes(gPeriod) > adesso)
              {
                answ = memLayer.ML.cdvb("showReopenOdlTav");
              }
            }
          }
        }
        return answ;
      }
    }
    /// <summary>
    /// Verifica se la tavola SIA in fase di attrezzaggio, ovvero SE:
    /// - sia un impianto MULTI (= con + tavole)
    /// - sia già attrezzata
    /// </summary> 
    protected bool tavHasOdl
    {
      get
      {
        bool answ = false;
        // se è multi controllo              
        if (isMulti)
        {
          answ = !emptyOdlMacc;
        }
        return answ;
      }
    }
    /// <summary>
    /// Restituisce il codice IdxMacchina dell'altra tavola (se multi) altrimenti la stessa macchina...
    /// </summary>
    protected string idxMaccAltraTav
    {
      get
      {
        string answ = "";
        try
        {
          // verifico se SIA una tavola (ha char "#")
          int iSharp = idxMacchina.IndexOf('#');
          if (iSharp > 0)
          {
            // ora verifico SE ALTRA TAVOLA ha ODL...
            string nomeTav = idxMacchina.Substring(iSharp);
            string altraTav = nomeTav.Substring(0, nomeTav.Length - 1);
            altraTav += nomeTav.EndsWith("1") ? "2" : "1";
            // sistemo nome
            answ = idxMacchina.Replace(nomeTav, altraTav);
          }
        }
        catch
        { }
        return answ;
      }
    }
    /// <summary>
    /// Restituisce il codice IdxMacchina dell'impianto PARENT (se multi) altrimenti la stessa macchina...
    /// </summary>
    protected string idxMaccParent
    {
      get
      {
        string answ = "";
        // se è multi controllo             
        if (isMulti)
        {
          // verifico se SIA una tavola (ha char "#")
          int iSharp = idxMacchina.IndexOf('#');
          if (iSharp > 0)
          {
            // sistemo nome
            answ = idxMacchina.Substring(0, iSharp);
          }
        }
        return answ;
      }
    }

    /// <summary>
    /// Verifica chiave chkCloseOdl in tab Config
    /// </summary>
    protected bool chkCloseOdlVal
    {
      get
      {
        return memLayer.ML.cdvb("chkCloseOdl");
      }
    }
    /// <summary>
    /// Verifica chiave showChkCloseOdl in tab Config
    /// </summary>
    protected bool showChkCloseOdlVal
    {
      get
      {
        return memLayer.ML.cdvb("showChkCloseOdl");
      }
    }
    /// <summary>
    /// Verifica chiave showOdlProvv in tab Config
    /// </summary>
    protected bool showOdlProvvVal
    {
      get
      {
        return memLayer.ML.cdvb("showOdlProvv");
      }
    }

    /// <summary>
    /// stringa UID univoca
    /// </summary>
    public string uid
    {
      get
      {
        return this.UniqueID.Replace("$", "_").Replace("-", "_");
      }
    }
    /// <summary>
    /// idx macchina selezionata
    /// </summary>
    public string idxMacchina
    {
      get
      {
        string answ = "";
        try
        {
          answ = memLayer.ML.StringSessionObj(string.Format("idxMacchina-{0}", uid));
        }
        catch
        { }
        return answ;
      }
      set
      {
        memLayer.ML.setSessionVal(string.Format("idxMacchina-{0}", uid), value);
        hfIdxMacchina.Value = value;
        cmp_newODL.idxMacchina = value;
      }
    }
    /// <summary>
    /// classe MapoDB x uso locale
    /// </summary>
    protected MapoDb.MapoDb controllerMapo = new MapoDb.MapoDb();
    /// <summary>
    /// Determina se sia abilitato il controllo x editing
    /// </summary>
    public bool isEnabled
    {
      get
      {
        bool answ = false;
        try
        {
          answ = memLayer.ML.BoolSessionObj(string.Format("isEnabled-{0}", uid));
        }
        catch
        { }
        return answ;
      }
      set
      {
        memLayer.ML.setSessionVal(string.Format("isEnabled-{0}", uid), value);
      }
    }
    /// <summary>
    /// codice odl selezionato
    /// </summary>
    public int idxODLSel
    {
      get
      {
        int answ = 0;
        try
        {
          answ = Convert.ToInt32(ddlODL.SelectedValue);
        }
        catch
        { }
        return answ;
      }
    }
    /// <summary>
    /// Cod articolo dell'ODL selezionato
    /// </summary>
    public string CodArtSel
    {
      get
      {
        string CodArticolo = "";
        try
        {
          CodArticolo = DataLayer.obj.taODL.getByIdx(idxODLSel, false)[0].CodArticolo;
        }
        catch
        { }
        return CodArticolo;
      }
    }
    /// <summary>
    /// avvio pagina
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void Page_Load(object sender, EventArgs e)
    {
      if (!Page.IsPostBack)
      {
        // fix modo tempo...
        if (memLayer.ML.cdvb("TAB_TC_MinSec"))
        {
          mod_tempoMSMC.modoTempo = timeMode.MS;
        }
        else
        {
          mod_tempoMSMC.modoTempo = timeMode.MC;
        }
      }
      cmp_newODL.eh_newVal += Cmp_newODL_eh_newVal;
    }
    /// <summary>
    /// Verifica (su tab config) se sia abilitata la gestione flusso RPO (Richieste - Promesse - ODL)
    /// </summary>
    protected bool enableRPO
    {
      get
      {
        return memLayer.ML.cdvb("enableRPO");
      }
    }

    private void Cmp_newODL_eh_newVal(object sender, EventArgs e)
    {
      // creato nuovo ODL, faccio refresh ricaricando pagina!
      Response.Redirect("~/ODL");
    }

    public void hideAll()
    {
      divDettOdl.Visible = false;
    }

    public void checkAll()
    {
      lblOut.Text = "";
      checkBtnStatus();
      chkCloseOdl.Checked = chkCloseOdlVal;
      chkCloseOdl.Visible = showChkCloseOdlVal;
      divOdlProvv.Visible = showOdlProvvVal;
      divOpRiattr.Visible = (showSplitOdlOnTavVal || showReopOdlTav);
      lbtSplitOdlSuTav.Visible = showSplitOdlOnTavVal;
      lbtReopOdlSuTav.Visible = showReopOdlTav;
    }
    /// <summary>
    /// Sistema CSS x status enabled/disabled
    /// </summary>
    /// <param name="lbtn"></param>
    protected void fixWCtrStatus(object lbtn)
    {
      // tolgo (eventuale) classe
      try
      {
        ((WebControl)lbtn).CssClass = ((WebControl)lbtn).CssClass.Replace("disabled", "");
        // se richiesto metto disabled...
        if (!((WebControl)lbtn).Enabled)
        {
          ((WebControl)lbtn).CssClass += " disabled";
        }
      }
      catch
      { }
    }

    /// <summary>
    /// controlla stato bottoni abilitato
    /// </summary>
    private void checkBtnStatus()
    {
      // di default rendo abilitato / disabilitato tutto in base al valore "isEnabled"
      lbtShowSplitODL.Enabled = isEnabled;
      lbtSplitODL.Enabled = isEnabled;
      chkCloseOdl.Enabled = isEnabled;
      fixWCtrStatus(lbtShowSplitODL);
      fixWCtrStatus(lbtSplitODL);
      fixWCtrStatus(chkCloseOdl);

      // condizioni booleane
      bool inAttr = false;
      bool currHasOdl = false;
      // controllo se la macchina è in attrezzaggio...
      DS_applicazione.StatoMacchineRow rigaStato = null;
      try
      {
        // se è multi controllo parent...
        if (isMulti)
        {
          rigaStato = selData.mng.rigaStato(idxMaccParent);
          inAttr = (rigaStato.IdxStato == 2 && tavHasOdl);
        }
        else
        {
          rigaStato = selData.mng.rigaStato(idxMacchina);
          inAttr = (rigaStato.IdxStato == 2);
        }
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("Eccezione in recupero dati rigaStato! {0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
      }
      try
      {
        currHasOdl = DataLayer.obj.taODL.getByMacchina(idxMacchina)[0].IdxODL != 0;
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("Eccezione in recupero dati currHasOdl! {0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
      }
      // deve controllare abbia ODL o PROMESSE odl...
      bool hasNewOdl = DataLayer.obj.taSelOdlFree.getUnused(idxMacchina, chkTutti.Checked).Rows.Count > 1;
      // sistemo buttons!
      lbtStartAttr.Enabled = (isEnabled && (!inAttr && hasNewOdl));
      lbtStartProd.Enabled = (isEnabled && inAttr);
      lbtEndProd.Enabled = (isEnabled && (!inAttr && currHasOdl));
      ddlODL.Enabled = (isEnabled && (!inAttr && hasNewOdl));
      odsODL.DataBind();
      // sistemo anche come css..
      fixWCtrStatus(lbtStartAttr);
      fixWCtrStatus(lbtStartProd);
      fixWCtrStatus(lbtEndProd);
      fixWCtrStatus(ddlODL);
      // sistemo show tempo/note attrezzaggio..
      if (inAttr)
      {
        showNoteTC(true);
        int idxOdl = 0;
        try
        {
          idxOdl = DataLayer.obj.taODL.getByMacchina(idxMacchina)[0].IdxODL;
          updateTempoTc(idxOdl, inAttr);
          updateNoteTC(idxOdl);
        }
        catch (Exception exc)
        {
          logger.lg.scriviLog(string.Format("Eccezione in recupero dati ODL! {0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
        }
      }

      // verifico se l'articolo corrente sia in revisione x mostrare conferma modifica revisione...
      if (CodArtSel != "")
      {
        bool showWarn = false;
        try
        {
          showWarn = DataLayer.obj.taAnagArt.getByCod(CodArtSel)[0].FlagIsNew;
        }
        catch (Exception exc)
        {
          logger.lg.scriviLog(string.Format("Eccezione in recupero dati showWarn! {0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
        }
        divWarningArt.Visible = showWarn;
      }
    }
    /// <summary>
    /// processa evento richiesto
    /// </summary>                       
    /// <param name="idxMaccCurr"></param>
    /// <param name="idxEvento"></param>
    /// <param name="userMsg"></param>
    /// <param name="idxODL"></param>
    private void processaEvento(string idxMaccCurr, int idxEvento, string userMsg, int idxODL)
    {
      MapoDb.inputComando inCmd;
      MapoDb.inputComando inCmd2;
      DS_applicazione.StatoMacchineRow rigaStato = selData.mng.rigaStato(idxMaccCurr);
      // ricavo codice articolo...
      string CodArticolo = DataLayer.obj.taODL.getByIdx(idxODL, false)[0].CodArticolo;
      // processo evento...
      inCmd = controllerMapo.scriviRigaEventoBarcode(idxMaccCurr, idxEvento, CodArticolo, "", DataLayer.MatrOpr, rigaStato.pallet);
      // se la macchina è MULTI (cod#tavola) e sonoa INIZIO/FINE attrezzaggio (idxEv <=2) oppure FINE PROD processo ANCHE per la macchina madre...
      if (idxMaccCurr.IndexOf('#') > 0 && (idxEvento <= 2 || idxEvento == 7))
      {
        inCmd2 = controllerMapo.scriviRigaEventoBarcode(idxMaccParent, idxEvento, CodArticolo, "", DataLayer.MatrOpr, rigaStato.pallet);
      }
      // chiamo refresh MSE
      DataLayer.obj.taMSE.forceRecalc(0, idxMaccCurr);
      // invalido la cache di selData
      selData.mng.invalidateCache();
      lblOut.Text = userMsg;
      // loggo USR MSG
      logger.lg.scriviLog(userMsg, tipoLog.INFO);
      checkBtnStatus();
    }
    /// <summary>
    /// valore decimal del TC richiesto...
    /// </summary>
    protected decimal TCRichAttr
    {
      get
      {
        decimal answ = 0;
        try
        {
          answ = mod_tempoMSMC.tempoMC;
        }
        catch
        { }
        return answ;
      }
      set
      {
        mod_tempoMSMC.tempoMC = value;
      }
    }
    /// <summary>
    /// valore INT di num Pz per Pallet...
    /// </summary>
    protected int PzPallet
    {
      get
      {
        int answ = 0;
        try
        {
          answ = cmp_selPzPallet.pzPallet;
        }
        catch
        { }
        return answ;
      }
      set
      {
        cmp_selPzPallet.pzPallet = value;
      }
    }
    /// <summary>
    /// valore decimal del TC ASSEGNATO...
    /// </summary>
    protected decimal TCAssegnato(int idxODL)
    {
      decimal answ = 0;
      try
      {
        if (enableRPO)
        {
          // leggo info da promessa...
          var rigaProm = DataLayer.obj.taPODL.getByKey(idxODL)[0];
          answ = rigaProm.TCAssegnato;
        }
        else
        {
          // leggo idxOdl da ultimo odl attivo x macchina
          DS_ProdTempi.ODLRow rigaOdl = DataLayer.obj.taODL.getByIdx(idxODL, false)[0];
          answ = rigaOdl.TCAssegnato;
        }
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// dichiara inizio attrezzaggio ODL indicato..
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lbtStartAttr_Click(object sender, EventArgs e)
    {
      bool inAttr = false;
      // se è multi mi chiedo se sia DAVVERO in attrezzaggio...
      if (isMulti)
      {
        try
        {
          // controllo se NON SONO già in attrezzaggio...   
          DS_applicazione.StatoMacchineRow rigaStato = selData.mng.rigaStato(idxMaccParent);
          inAttr = (rigaStato.IdxStato == 2);
        }
        catch
        { }
      }
      // proseguo
      int idxODL_curr = 0;
      confermaProdOdl(false);
      if (idxODLSel > 0)
      {
        // se vedesse TCRich a zero lo reimposta a quello assegnato...
        if (TCRichAttr == 0)
        {
          TCRichAttr = TCAssegnato(idxODLSel);
        }
        int idxODL = 0;
        if (memLayer.ML.CRB("enableSplitODL"))
        {
          // splitto VECCHIO ODL (se è rimasto qualcosa da produrre e se ce ne è rimasto uno.......)
          try
          {
            idxODL = DataLayer.obj.taODL.getByMacchina(idxMacchina)[0].IdxODL;
            DataLayer.obj.taODL.splitODL(idxODL, DataLayer.MatrOpr, idxMacchina, TCAssegnato(idxODL), PzPallet, string.Format("inizio attrezzaggio, Sospensione ODL {0}, generato residuo con pari TCiclo: {1}", idxODL, TCAssegnato(idxODL)), false);
            // se è multi processo ANCHE x altra tavola...
            if (isMulti)
            {
              int _idxOdl = DataLayer.obj.taODL.getByMacchina(idxMaccAltraTav)[0].IdxODL;
              DataLayer.obj.taODL.splitODL(_idxOdl, DataLayer.MatrOpr, idxMaccAltraTav, TCAssegnato(_idxOdl), PzPallet, string.Format("inizio attrezzaggio, Sospensione ODL {0}, generato residuo con pari TCiclo: {1}", _idxOdl, TCAssegnato(_idxOdl)), false);
            }
          }
          catch
          { }
        }
        // 2018.07.24 verifico se devo lavorare come ODL classico o come RPO (Richiesta / Promessa / ODL)
        if (enableRPO)
        {
          // creo nuovo ODL da promessa ed associo
          DataLayer.obj.taODL.inizioSetupPromessa(idxODLSel, DataLayer.MatrOpr, idxMacchina, TCRichAttr, PzPallet, txtNote.Text);
          // salvo ODL attrezzato
          idxODL_curr = DataLayer.obj.taODL.getByMacchina(idxMacchina)[0].IdxODL;
        }
        // ODL classico
        else
        {
          // avvio NUOVO ODL
          DataLayer.obj.taODL.inizioSetup(idxODLSel, DataLayer.MatrOpr, idxMacchina, TCRichAttr, PzPallet, txtNote.Text);
          // salvo ODL Current
          idxODL_curr = idxODLSel;
        }
        // process evento
        int idxEvento = 2; // !!!HARD CODED
        string evText = "Registrato inizio attrezzaggio per ODL {0}";
        StringBuilder sb = new StringBuilder();
        sb.AppendLine(String.Format(evText, idxODL_curr));
        processaEvento(idxMacchina, idxEvento, sb.ToString(), idxODL_curr);
        // indico INIZIO SETUP su REDIS coem EXE della macchina...
        string ts = string.Format("{0:yyMMdd}T{0:HHmmss.fff}Z", DateTime.Now);
        DataLayer.addTask4Machine(idxMacchina, "startSetup", $"TS:{ts}|MATR:{DataLayer.MatrOpr}|ODL:{idxODL_curr}");
        // se è multi CHIUDO ODL x altra tavola...
        if (isMulti)
        {
          // se NON sono in attrezzaggio...
          if (!inAttr)
          {
            int idxOdlAltra = 0;
            try
            {
              var tabOdl = DataLayer.obj.taODL.getByMacchina(idxMaccAltraTav);
              if (tabOdl.Rows.Count > 0)
              {
                idxOdlAltra = DataLayer.obj.taODL.getByMacchina(idxMaccAltraTav)[0].IdxODL;
              }
            }
            catch (Exception exc)
            {
              logger.lg.scriviLog("Durante recupero idxOdlAltra " + exc.ToString(), tipoLog.EXCEPTION);
            }
            // procedo se ho ODL
            if (idxOdlAltra > 0)
            {
              sb.AppendLine("---");
              DataLayer.obj.taODL.fineProd(idxOdlAltra, idxMaccAltraTav);
              evText = "Registrato inizio attrezzaggio per ODL {0} (setup seconda tavola)";
              sb.AppendLine(String.Format(evText, idxOdlAltra));
              processaEvento(idxMaccAltraTav, idxEvento, String.Format(evText, idxOdlAltra), idxOdlAltra);
            }
            lblOut.Text = sb.ToString().Replace("---", "<br/>");
          }
          // update buttons...
          checkAll();
        }
        // resetto contapezzi redis...
        DataLayer.saveCounter(idxMacchina, "0");
        // imposto ODL su redis...
        DataLayer.saveCurrODL(idxMacchina, idxODL_curr.ToString());
      }
      else
      {
        lblOut.Text = "Selezionare un ORDINE valido!";
      }
      // sollevo evento!
      if (eh_reqUpdate != null)
      {
        eh_reqUpdate(this, new EventArgs());
      }
    }
    /// <summary>
    /// inizio prod
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lbtStartProd_Click(object sender, EventArgs e)
    {
      confermaProdOdl(true);
      // se vedesse TCRich a zero lo reimposta a quello assegnato...
      if (TCRichAttr == 0)
      {
        TCRichAttr = TCAssegnato(idxODLSel);
      }
      // leggo idxOdl da ultimo odl attivo x macchina
      int idxODL = DataLayer.obj.taODL.getByMacchina(idxMacchina)[0].IdxODL;
      int idxEvento = 1; // !!!HARD CODED
      // aggiorno (se necessario) note e tempo setup
      DataLayer.obj.taODL.updateSetup(idxODL, DataLayer.MatrOpr, TCRichAttr, PzPallet, txtNote.Text);
      // controllo se TC Assegnato != TCRichiesto allora invio email x verifiche...
      DS_ProdTempi.ODLRow rigaOdl = DataLayer.obj.taODL.getByIdx(idxODL, false)[0];
      if (rigaOdl.TCAssegnato != TCRichAttr)
      {
        // invio email!
        DataLayer.obj.sendWarnTcChangeReq(memLayer.ML.CRS("_adminEmail"));
      }
      // processo chiusura setup  
      string evText = "Registrata inizio produzione per ODL {0}";
      StringBuilder sb = new StringBuilder();
      sb.AppendLine(String.Format(evText, idxODL));
      processaEvento(idxMacchina, idxEvento, sb.ToString(), idxODL);
      // indico INIZIO SETUP su REDIS coem EXE della macchina...
      string ts = string.Format("{0:yyMMdd}T{0:HHmmss.fff}Z", DateTime.Now);
      DataLayer.addTask4Machine(idxMacchina, "stopSetup", $"TS:{ts}|MATR:{DataLayer.MatrOpr}|ODL:{idxODL}");
      // se è multi processo chiusura setup x altra tavola...
      if (isMulti)
      {
        sb.AppendLine("---");
        int idxOdlAltra = DataLayer.obj.taODL.getByMacchina(idxMaccAltraTav)[0].IdxODL;
        sb.AppendLine(String.Format(evText, idxOdlAltra));
        processaEvento(idxMaccAltraTav, idxEvento, String.Format(evText, idxOdlAltra), idxOdlAltra);
      }
      // riporto stringa
      lblOut.Text = sb.ToString().Replace("---", "<br/>");
      // nascondo note!
      showNoteTC(false);
      // update buttons...
      checkAll();
      // sollevo evento!
      if (eh_reqUpdate != null)
      {
        eh_reqUpdate(this, new EventArgs());
      }
    }
    /// <summary>
    /// fine prod
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lbtEndProd_Click(object sender, EventArgs e)
    {
      // leggo idxOdl da ultimo odl attivo x macchina
      int idxODL = DataLayer.obj.taODL.getByMacchina(idxMacchina)[0].IdxODL;
      int idxEvento = 7; // !!!HARD CODED

      // confermo prod vecchio ODL
      confermaProdOdl(false);

      // se chk flaggato ovvero richiesta di chiudere ODL procedo come prima (chiudendo ODL senza averne altri...)
      if (chkCloseOdl.Checked)
      {
        // aggiungo try/catch x capire se sia qui che si "impasta" in chiusura ODL
        try
        {
          // processo x macchina selezionata
          DataLayer.obj.taODL.fineProd(idxODL, idxMacchina);
          string evText = "Registrata fine produzione per ODL {0}";
          StringBuilder sb = new StringBuilder();
          sb.AppendLine(String.Format(evText, idxODL));
          processaEvento(idxMacchina, idxEvento, sb.ToString(), idxODL);
          // se è multi processo ANCHE x altra tavola...
          if (isMulti)
          {
            sb.AppendLine("---");
            int idxOdlAltra = 0;
            string _idxOdl = idxOdlAltraMacc;
            int.TryParse(_idxOdl, out idxOdlAltra);
            DataLayer.obj.taODL.fineProd(idxOdlAltra, idxMaccAltraTav);
            sb.AppendLine(String.Format(evText, idxOdlAltra));
            processaEvento(idxMaccAltraTav, idxEvento, String.Format(evText, idxOdlAltra), idxOdlAltra);
          }
          // riporto stringa
          lblOut.Text = sb.ToString().Replace("---", "<br/>");
        }
        catch (Exception exc)
        {
          logger.lg.scriviLog(string.Format("Eccezione in operazione chiusura ODL! {0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
          Response.Redirect("~/DettaglioMacchina.aspx");
        }
      }
      // altrimenti split ODL x completare IN FUTURO la produzione...
      else
      {
        try
        {
          // effettuo split su nuovo ODL
          DataLayer.obj.taODL.splitODL(idxODL, DataLayer.MatrOpr, idxMacchina, TCAssegnato(idxODL), PzPallet, string.Format("Fine Produzione, Sospensione ODL {0}, generato residuo con pari TCiclo: {1}", idxODL, TCAssegnato(idxODL)), false);
          // processo chiusura setup
          processaEvento(idxMacchina, idxEvento, String.Format("Registrata fine produzione per ODL {0}, nuovo ODL per quantità residua", idxODL), idxODL);

          // se è multi processo ANCHE x altra tavola...
          if (isMulti)
          {
            int idxOdlAltra = 0;
            string _idxOdl = idxOdlAltraMacc;
            int.TryParse(_idxOdl, out idxOdlAltra);
            // effettuo split su nuovo ODL
            DataLayer.obj.taODL.splitODL(idxOdlAltra, DataLayer.MatrOpr, idxMaccAltraTav, TCAssegnato(idxOdlAltra), PzPallet, string.Format("Fine Produzione, Sospensione ODL {0}, generato residuo con pari TCiclo: {1}", idxOdlAltra, TCAssegnato(idxOdlAltra)), false);
            // processo chiusura setup
            processaEvento(idxMaccAltraTav, idxEvento, String.Format("Registrata fine produzione per ODL {0}, nuovo ODL per quantità residua", idxOdlAltra), idxOdlAltra);
          }
          // sistemo buttons!
          bool splitOdl = false;
          fixSplitBtn(splitOdl);
        }
        catch (Exception exc)
        {
          logger.lg.scriviLog(string.Format("Eccezione in operazione Chiusura + Split ODL su nuovo! {0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
          Response.Redirect("~/DettaglioMacchina.aspx");
        }
      }
      // resetto ODL su redis...
      DataLayer.emptyCurrODL(idxMacchina);
      // aggiorno visualizzazione
      checkAll();
      // sollevo evento!
      if (eh_reqUpdate != null)
      {
        eh_reqUpdate(this, new EventArgs());
      }
    }
    /// <summary>
    /// verifica se sia necessario confermare la prod dell'ODL precedente prima di chiudere e lo fa in automatico...
    /// </summary>
    /// <param name="confZero">boolean, true = deve confermare 0 pezzi (es. in setup)</param>
    private void confermaProdOdl(bool confZero)
    {
      // 2016.11.17 NOTA: introdotti scarti, li confermiamo SEMPRE a zero se in setup, però da valutare SE a FINE ATTREZZAGGIO chiedere num pezzi e num scarti (saldo zero buoni) da inserire...
      if (confZero)
      {
        // confermo produzione ZERO pezzi (in setup)
        DataLayer.obj.confermaProdMacchina(idxMacchina, memLayer.ML.CRI("modoConfProd"), 0, 0, DateTime.Now);
      }
      else // se NON sono in setup verifico se ho pz da confermare
      {
        // recupero pz da confermare
        DS_ProdTempi.stp_PzProd_getByMacchinaRow rigaProd = DataLayer.obj.taPzProd2conf.GetData(idxMacchina)[0];
        if (rigaProd.pezziNonConfermati > 0)
        {
          DataLayer.obj.confermaProdMacchina(idxMacchina, memLayer.ML.CRI("modoConfProd"), rigaProd.pezziNonConfermati, 0, DateTime.Now);
        }
      }
    }
    /// <summary>
    /// mostra dati ed opzione x split ODL
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lbtShowSplitODL_Click(object sender, EventArgs e)
    {
      bool splitOdl = true;
      fixSplitBtn(splitOdl);
      // recupero current idx
      int currODL = DataLayer.obj.taODL.getByMacchina(idxMacchina)[0].IdxODL;
      updateTempoTc(currODL, true);
      updateNoteTC(currODL);
    }
    /// <summary>
    /// sistema buttons split
    /// </summary>
    /// <param name="splitOdl"></param>
    private void fixSplitBtn(bool splitOdl)
    {
      lbtShowSplitODL.Visible = !splitOdl;
      chkCloseOdl.Visible = !splitOdl;
      lbtSplitODL.Visible = splitOdl;
      showNoteTC(splitOdl);
      ddlODL.Visible = !splitOdl;
      chkTutti.Visible = !splitOdl;
      lbtStartAttr.Visible = !splitOdl;
      lbtStartProd.Visible = !splitOdl;
      lbtEndProd.Visible = !splitOdl;
    }
    /// <summary>
    /// split ODL con creazione nuovo ODL
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lbtSplitODL_Click(object sender, EventArgs e)
    {
      // chiamo stored che genera nuovo ODL, mette note e tempo, chiude vecchi e assegna nuovo...
      int currODL = DataLayer.obj.taODL.getByMacchina(idxMacchina)[0].IdxODL;
      int idxEvento = 1; // !!!HARD CODED
                         // controllo se TC è valorizzato..
      if (TCRichAttr == 0)
      {
        mod_tempoMSMC.checkTC();
      }

      // confermo prod vecchio ODL
      confermaProdOdl(false);

      // effettuo split su nuovo ODL
      DataLayer.obj.taODL.splitODL(currODL, DataLayer.MatrOpr, idxMacchina, TCRichAttr, PzPallet, txtNote.Text, true);

      // resetto ODL su redis...
      DataLayer.emptyCurrODL(idxMacchina);

      // invio email!
      DataLayer.obj.sendWarnTcChangeReq(memLayer.ML.CRS("_adminEmail"));
      // processo chiusura setup
      processaEvento(idxMacchina, idxEvento, String.Format("Registrato Riattrezzaggio ODL (old: {0})", currODL), currODL);
      // sistemo buttons!
      bool splitOdl = false;
      fixSplitBtn(splitOdl);

      // sollevo evento!
      if (eh_reqUpdate != null)
      {
        eh_reqUpdate(this, new EventArgs());
      }
    }
    /// <summary>
    /// selezionato un ODL mostro note/tempo da validare
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void ddlODL_SelectedIndexChanged(object sender, EventArgs e)
    {
      checkDDL();
    }

    private void checkDDL()
    {
      if (ddlODL.SelectedIndex > 0)
      {
        showNoteTC(true);
        updateTempoTc(idxODLSel, false);
        updateNoteTC(idxODLSel);
      }
      else
      {
        showNoteTC(false);
      }
    }


    /// <summary>
    /// mostra/nasconde note
    /// </summary>
    private void showNoteTC(bool show)
    {
      // mostra/nasconde note da compilare
      divTempo.Visible = show;
      divNote.Visible = show;
      divPzPallet.Visible = show;
      lbtStartAttr.Visible = show;
      cmp_dettODL.idxODLSel = idxODLSel;
      divDettOdl.Visible = show && idxODLSel > 0;
      // se abilitato da config su DB mostro selezione del numPzPallet...
      cmp_selPzPallet.enableSet = memLayer.ML.CRB("enableTabSetPzPallet");

    }
    /// <summary>
    /// aggiorna note ODL
    /// </summary>
    /// <param name="idxOdl"></param>
    private void updateNoteTC(int idxOdl)
    {
      string testo = "";
      if (idxOdl > 0)
      {
        try
        {
          testo = DataLayer.obj.taODL.getByIdx(idxOdl, false)[0].Note;
        }
        catch
        { }
      }
      txtNote.Text = testo;
    }

    /// <summary>
    /// update TC mostrato
    /// </summary>                    
    /// <param name="idxOdlPodl">idx dell'ODL / PODL</param>
    /// <param name="inAttr"></param>
    private void updateTempoTc(int idxOdlPodl, bool inAttr)
    {
      // riporta TC
      decimal _TCRichAttr = 0;
      int pzPallet = 1;
      if (enableRPO && !inAttr)
      {
        var rigaProm = DataLayer.obj.taPODL.getByKey(idxOdlPodl)[0];
        _TCRichAttr = rigaProm.TCAssegnato;
        pzPallet = rigaProm.PzPallet;
      }
      else
      {
        DS_ProdTempi.ODLRow rigaOdl = DataLayer.obj.taODL.getByIdx(idxOdlPodl, false)[0];
        if (rigaOdl.TCRichAttr > 0)
        {
          _TCRichAttr = rigaOdl.TCRichAttr;
        }
        else
        {
          _TCRichAttr = rigaOdl.TCAssegnato;
        }
        pzPallet = rigaOdl.PzPallet;
      }
      // aggiorno dati!
      TCRichAttr = _TCRichAttr;
      PzPallet = pzPallet;
    }

    protected void lbtConfNewRevProd_Click(object sender, EventArgs e)
    {
      // chiamo stored x allineare revProd a revUT
      string CodArticolo = DataLayer.obj.taODL.getByIdx(idxODLSel, false)[0].CodArticolo;
      DataLayer.obj.taAnagArt.setNewRev(CodArticolo);
      checkBtnStatus();
    }
    /// <summary>
    /// toggle visualizzazione creazioen ODL provvisorio
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lbtShowCreaOdlProvv_Click(object sender, EventArgs e)
    {
      cmp_newODL.Visible = !cmp_newODL.Visible;
    }
    /// <summary>
    /// Testo x button creazione nuovo ODL
    /// </summary>
    public string lblCreaOdl
    {
      get
      {
        string answ = "CREAZIONE ODL PROVVISORIO";
        if (cmp_newODL.Visible)
        {
          answ = "NASCONDI creazione ODL provvisorio";
        }
        return answ;
      }
    }

    protected void chkTutti_CheckedChanged(object sender, EventArgs e)
    {
      checkBtnStatus();
    }
    /// <summary>
    /// Effettua split ODL da ALTRA tavola su tav corrente
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lbtSplitOdlSuTav_Click(object sender, EventArgs e)
    {
      // chiamo stored x splittare ODL...
      int idxOdlAltra = 0;
      int.TryParse(idxOdlAltraMacc, out idxOdlAltra);
      // se ho trovato...
      if (idxOdlAltra > 0)
      {
        DataLayer.obj.taODL.dividiDaAltraTav(idxOdlAltra, DataLayer.MatrOpr, idxMacchina);
        // messaggio utente
        string evText = "Registrata inizio attrezzaggio da split ODL {0} (come da altra tavola)";
        StringBuilder sb = new StringBuilder();
        sb.AppendLine(String.Format(evText, idxOdlAltra));
        lblOut.Text = sb.ToString();
      }
      // update button x setup da altra tavola...
      checkAll();
      // sollevo evento!
      if (eh_reqUpdate != null)
      {
        eh_reqUpdate(this, new EventArgs());
      }
    }
    /// <summary>
    /// Effettua ripresa ODL su tavola
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lbtReopOdlSuTav_Click(object sender, EventArgs e)
    {
      // chiamo stored x riprendere ODL (toglie data chiusura...)
      DS_ProdTempi.ODLDataTable tabRes = DataLayer.obj.taODL.reopenGetLast(idxMacchina);
      if (tabRes.Rows.Count > 0)
      {
        var riga = tabRes[0];
        // messaggio utente
        string evText = "Registrato riapertura ODL {0} | art {1}";
        StringBuilder sb = new StringBuilder();
        sb.AppendLine(String.Format(evText, riga.IdxODL, riga.CodArticolo));
        lblOut.Text = sb.ToString();
      }
      // update buttons...
      checkAll();
      // sollevo evento!
      if (eh_reqUpdate != null)
      {
        eh_reqUpdate(this, new EventArgs());
      }
    }

    protected void txtSearchODL_TextChanged(object sender, EventArgs e)
    {
      odsODL.DataBind();
    }
  }
}