using AppData;
using Newtonsoft.Json;
using SteamWare;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text.RegularExpressions;
using System.Web.UI;

namespace C_TRACK
{
  public partial class barcode : System.Web.UI.Page
  {
    /// <summary>
    /// idxRec della fase attiva
    /// </summary>
    public int idxRecCurr
    {
      get
      {
        return memLayer.ML.IntSessionObj("idxRecCurr");
      }
    }
    /// <summary>
    /// Qta della fase attiva
    /// </summary>
    public int QtaFaseCurr
    {
      get
      {
        return memLayer.ML.IntSessionObj("QtaFaseCurr");
      }
    }
    /// <summary>
    /// Codice TASK corrente
    /// </summary>
    public string CurrNumTask
    {
      get
      {
        return memLayer.ML.StringSessionObj("CurrNumTask");
      }
      set
      {
        memLayer.ML.setSessionVal("CurrNumTask", value);
        // cerco articolo e lo salvo...
        string CurrCodArt = "";
        try
        {
          CurrCodArt = dataLayer.man.taTL.getByKey(value)[0].CodArt;
        }
        catch
        { }
        memLayer.ML.setSessionVal("CurrCodArt", CurrCodArt);

      }
    }
    protected void Page_Load(object sender, EventArgs e)
    {
      // Crea stopwatch.
      Stopwatch stopwatch = new Stopwatch();
      // Avvio...
      stopwatch.Start();
      checkVisib();
      if (!Page.IsPostBack)
      {
        traduciObj();
        numDD = memLayer.ML.CRI("numDD");
        cacheValSec = memLayer.ML.CRI("cacheValSec");
        divReload.Visible = devicesAuthProxy.stObj.userHasRight("CT_userStart");
        setTipoTaskSel();
      }
      checkRequisiti();
      // effettuo load valori...
      setupComandiBarcode();
      setupValoriBarcode();
      // a seconda di pagina singola o multi determino come procedere con comani / dati grezzi...
      if (mUtils.postIsMulti)
      {
        // gestiosco segnali "grezzi"
        mod_barcode1.eh_dataRead += Mod_barcode_eh_dataRead;
        mod_postMulti.eh_reqUpdate += Mod_postMulti_eh_reqUpdate;
      }
      else
      {
        // registro eventi
        mod_barcode1.eh_comandoRegistrato += new EventHandler(Mod_barcode_eh_comandoRegistrato);
        mod_btnComandi1.eh_clickComando += new EventHandler(mod_btnComandi1_eh_clickComando);
      }
      mod_selTask.eh_dataSel += Mod_selTask_eh_dataSel;
      // registro
      stopwatch.Stop();
      lastUpdDuration = stopwatch.Elapsed;
    }

    private void Mod_postMulti_eh_reqUpdate(object sender, EventArgs e)
    {
      setTipoTaskSel();
      // aggiorna eleco task...
      mod_taskRec.doUpdate();
    }

    private void setTipoTaskSel()
    {
      // in base al tipo di postazione è per user o per post multi
      if (mUtils.postIsMulti)
      {
        mod_taskRec.tipoSelezione = WebUserControls.selType.byPostMulti;
      }
      else
      {
        mod_taskRec.tipoSelezione = WebUserControls.selType.byUser;
      }
    }

    private void Mod_selTask_eh_dataSel(object sender, EventArgs e)
    {
      // selezione commessa --> chiamo metodo caricamento comandi in modulo barcode...
      mod_barcode1.loadBtnClickComando();
      // refresh master...
      ((WebMasterPages.Bootstrap)this.Master).doUpdate();
    }

    /// <summary>
    /// Verifica visibilità componenti bcode e selettore...
    /// </summary>
    private void checkVisib()
    {
      mod_barcode1.Visible = memLayer.ML.CRB("OptUseBCode");
      mod_selTask.Visible = memLayer.ML.CRB("OptUseSelTask");
    }

    /// <summary>
    /// Verifica i requisiti (operatore e postazione) per operare
    /// </summary>
    private void checkRequisiti()
    {
      mod_btnComandi1.Visible = (mUtils.CodOpr != "" && mUtils.CodPost != "");
      // ora controllo SE SIA una postazione multi e di conseguenza imposto div relativi...
      showMulti = mUtils.postIsMulti;
    }

    protected bool showMulti
    {
      set
      {
        divMulti.Visible = value;
        mod_postMulti.Visible = value;
        divMain.Attributes.Remove("class");
        divMain.Attributes.Add("class", value ? "col-12 col-xl-9" : "col-12");
      }
    }

    /// <summary>
    /// Numero comandi ammessi caricati
    /// </summary>
    public int nComandi
    {
      get
      {
        return comandiAmmessiBCode.Count;
      }
    }
    /// <summary>
    /// Numero record BCode caricati
    /// </summary>
    public int nBCodeRec
    {
      get
      {
        return valoriAmmessiBCode.Count;
      }
    }
    /// <summary>
    /// Memorizzo durata ultimo update (lettura record...) come timespan
    /// </summary>
    public TimeSpan lastUpdDuration
    {
      get
      {
        return (TimeSpan)memLayer.ML.objSessionObj("lastUpdDuration");
      }
      set
      {
        memLayer.ML.setSessionVal("lastUpdDuration", value);
      }
    }
    /// <summary>
    /// inviato un comando dai link buttons
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    void mod_btnComandi1_eh_clickComando(object sender, EventArgs e)
    {
      // chiamo metodo caricamento comandi in modulo barcode...
      mod_barcode1.loadBtnClickComando();
    }

    private void traduciObj()
    {
    }
    /// <summary>
    /// imposta/recupera valore num gg da rileggere...
    /// </summary>
    public int numDD
    {
      get
      {
        int answ = 85;
        try
        {
          answ = Convert.ToInt32(txtNumDD.Text.Trim());
        }
        catch
        { }
        return answ;
      }
      set
      {
        txtNumDD.Text = value.ToString();
      }
    }
    /// <summary>
    /// logLevel impostato...
    /// </summary>
    public int logLevel
    {
      get
      {
        int answ = 1;
        try
        {
          answ = memLayer.ML.CRI("_logLevel");
        }
        catch
        { }
        return answ;
      }
    }
    /// <summary>
    /// imposta/recupera valore num sec validità cache...
    /// </summary>
    public int cacheValSec
    {
      get
      {
        int answ = 55;
        try
        {
          answ = Convert.ToInt32(txtCacheSec.Text.Trim());
        }
        catch
        { }

        return answ;
      }
      set
      {
        txtCacheSec.Text = value.ToString();
      }
    }
    /// <summary>
    /// Variabile x controllo scadenza valori in cache
    /// </summary>
    protected DateTime lastDataRefresh
    {
      get
      {
        DateTime answ = DateTime.Now.AddDays(-1);
        try
        {
          answ = Convert.ToDateTime(memLayer.ML.objCacheObj("lastBCodeDataRead"));
        }
        catch
        { }
        return answ;
      }
      set
      {
        // registro che i valori in cache sono scaduti...
        memLayer.ML.setCacheVal("lastBCodeDataRead", value);
        if (logLevel > 5)
        {
          logger.lg.scriviLog("impostata validita cache");
        }
      }
    }
    protected bool cacheValida
    {
      get
      {
        bool answ = false;
        try
        {
          if (DateTime.Now.Subtract(lastDataRefresh).TotalSeconds < cacheValSec)
          {
            answ = true;
          }
        }
        catch
        { }
        return answ;
      }
    }
    /// <summary>
    /// Elenco (da cache) dei valori ammessi x BCode
    /// </summary>
    protected Dictionary<string, string> valoriAmmessiBCode
    {
      get
      {
        Dictionary<string, string> answ = new Dictionary<string, string>();
        bool valIncache = memLayer.ML.isInCacheObject("valoriAmmessiBCode");
        if (valIncache && cacheValida)
        {
          answ = JsonConvert.DeserializeObject<Dictionary<string, string>>(memLayer.ML.objCacheObj("valoriAmmessiBCode").ToString());
        }
        return answ;
      }
      set
      {
        string serVal = JsonConvert.SerializeObject(value);
        memLayer.ML.setCacheVal("valoriAmmessiBCode", serVal);
        lastDataRefresh = DateTime.Now;
      }
    }
    /// <summary>
    /// Elenco (da cache) dei comandi ammessi x BCode
    /// </summary>
    protected Dictionary<string, string> comandiAmmessiBCode
    {
      get
      {
        Dictionary<string, string> answ = new Dictionary<string, string>();
        if (memLayer.ML.isInCacheObject("comandiAmmessiBCode"))
        {
          try
          {
            answ = JsonConvert.DeserializeObject<Dictionary<string, string>>(memLayer.ML.objCacheObj("comandiAmmessiBCode").ToString());
          }
          catch
          {
            answ = new Dictionary<string, string>();
          }
        }
        return answ;
      }
      set
      {
        string serVal = JsonConvert.SerializeObject(value);
        memLayer.ML.setCacheVal("comandiAmmessiBCode", serVal);
        lastDataRefresh = DateTime.Now;
      }
    }
    /// <summary>
    /// effettuo il setup dei valori ammessi x il barcode...
    /// </summary>
    private void setupValoriBarcode()
    {
      if (valoriAmmessiBCode.Count > 0)
      {
        // assegno valori al barcode...
        mod_barcode1.tabValori = valoriAmmessiBCode;
        if (logLevel > 5)
        {
          logger.lg.scriviLog("Letti da cache VALORI Barcode", tipoLog.INFO);
        }
      }
      else
      {
        // Crea stopwatch.
        Stopwatch stopwatch = new Stopwatch();
        // Avvio...
        stopwatch.Start();
        // carico dati!
        if (logLevel > 5)
        {
          logger.lg.scriviLog("Inizio setup valori Barcode", tipoLog.INFO);
        }

        Dictionary<string, string> valori = new Dictionary<string, string>();

        // aggiungo i COD OPERATORE
        var tabOpr = dataLayer.man.taAO.GetData();
        foreach (var rigaOpr in tabOpr)
        {
          valori.Add(rigaOpr.CodOpr, string.Format("{0} {1}", rigaOpr.Cognome, rigaOpr.Nome));
        }
        if (logLevel > 5)
        {
          logger.lg.scriviLog("Caricato OPERATORI per Barcode", tipoLog.INFO);
        }

        // aggiungo le POSTAZIONI
        var tabPost = dataLayer.man.taAP.GetData();
        foreach (var rigaPost in tabPost)
        {
          valori.Add(rigaPost.CodPost, rigaPost.Descrizione);
        }
        if (logLevel > 5)
        {
          logger.lg.scriviLog("Caricato POSTAZIONI per Barcode", tipoLog.INFO);
        }
        // aggiungo le commesse...
        var tabTask = dataLayer.man.taTL.getLastNumDD(numDD);
        foreach (var rigaTask in tabTask)
        {
          valori.Add(rigaTask.NumTask, string.Format("Comm. {0} | Art. {1} | Qta {2}", rigaTask.NumTask, rigaTask.CodArt, rigaTask.QtaRic));
        }
        if (logLevel > 5)
        {
          logger.lg.scriviLog("Caricato TaskList per Barcode", tipoLog.INFO);
        }
        // assegno valori al barcode...
        mod_barcode1.tabValori = valori;
        valoriAmmessiBCode = valori;
        lastDataRefresh = DateTime.Now;
        logger.lg.scriviLog("Letti da DB VALORI Barcode", tipoLog.INFO);
        stopwatch.Start();
        lastUpdDuration = stopwatch.Elapsed;
      }
    }
    /// <summary>
    /// carico da tab i comandi ammessi per il barcode...
    /// </summary>
    private void setupComandiBarcode()
    {
      if (comandiAmmessiBCode.Count > 0)
      {
        // assegno valori al barcode...
        mod_barcode1.comandiAmmessi = comandiAmmessiBCode;
        if (logLevel > 5)
        {
          logger.lg.scriviLog("Letti da cache COMANDI Barcode", tipoLog.INFO);
        }
      }
      else
      {
        Dictionary<string, string> comandi = new Dictionary<string, string>();

        // !!!FARE!!! togliere...
        var tabCmd = dataLayer.man.taTE2S.getByMappa("E_BC");
        foreach (var rigaCmd in tabCmd)
        {
          comandi.Add(rigaCmd.CodEvento.ToUpper(), devicesAuthProxy.stObj.traduci(rigaCmd.text2show));
        }


        var tabFasi = dataLayer.man.taAF.GetData();
        foreach (var rigaFase in tabFasi)
        {
          comandi.Add(rigaFase.CodFase, rigaFase.DescrFase);
        }

        // impongo i comandi al barcode...
        mod_barcode1.comandiAmmessi = comandi;
        comandiAmmessiBCode = comandi;
        logger.lg.scriviLog("Letti da DB COMANDI Barcode", tipoLog.INFO);
      }
    }
    /// <summary>
    /// il barcode ha registrato un evento...
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    void Mod_barcode_eh_dataRead(object sender, EventArgs e)
    {
      // passo il processing al modulo postMulti...
      mod_postMulti.processInput(mod_barcode1.rawInput);
    }
    /// <summary>
    /// il barcode ha registrato un evento...
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    void Mod_barcode_eh_comandoRegistrato(object sender, EventArgs e)
    {
      switch (stateMachine.st.azioneComando(mod_barcode1.comandoRegistrato))
      {
        case tipoAzione.annulla:
          mod_barcode1.resetMe();
          break;
        case tipoAzione.conferma:
          // se input completo eseguo...
          if (mod_barcode1.comandoRegistrato.currCmdIn != "" && mod_barcode1.comandoRegistrato.valore != "")
          {
            eseguiComando();
          }
          else // altrimenti warning... e rimetto valori precedenti
          {
            mod_barcode1.txtRich2show = user_std.UtSn.Traduci("codObjUnknown");
            mod_barcode1.comandoRegistrato.currCmdIn = mod_barcode1.comandoRegistrato.prevCmdIn;
            mod_barcode1.comandoRegistrato.descrComando = mod_barcode1.comandoRegistrato.descrComandoPrev;
            mod_barcode1.txtInput2show = mod_barcode1.comandoRegistrato.descrComandoPrev;
          }
          break;
        case tipoAzione.esegui:
          // se ho auto conferma eseguo!
          if (memLayer.ML.CRB("autoConfCmd"))
          {
            mod_barcode1.comandoRegistrato.prevCmdIn = mod_barcode1.comandoRegistrato.currCmdIn;
            mod_barcode1.comandoRegistrato.currCmdIn = "ok";
            eseguiComando();
          }
          else
          {
            if (mod_barcode1.comandoRegistrato.valore != "")
            {
              mod_barcode1.txtRich2show = user_std.UtSn.Traduci("pleaseConfirm");
            }
            else
            {
              mod_barcode1.txtRich2show = user_std.UtSn.Traduci("codObjUnknown");
            }
          }
          break;
        case tipoAzione.noAct:
          break;
        default:
          break;
      }
      mod_btnComandi1.updateBtn();
    }
    /// <summary>
    /// eseguo il comando
    /// </summary>
    private void eseguiComando()
    {
      // in primis: sono in esecuzione, x cui il comando è valido...
      string msg2show = "";
      Match testNumTask = Regex.Match(mod_barcode1.comandoRegistrato.valore, mUtils.reNumTask);
      Match testOper = Regex.Match(mod_barcode1.comandoRegistrato.valore, mUtils.reCodOper);
      Match testPost = Regex.Match(mod_barcode1.comandoRegistrato.valore, mUtils.reCodPost);

      // verifico se cmd setup utente...         
      if (mod_barcode1.comandoRegistrato.prevCmdIn == mUtils.reCmdResetOper)
      {
        // rimuovo OPR da POST occupate
        dataLayer.man.taAP.resetOpr(mUtils.CodOpr);
        // rimuovo OPR da sessione
        mUtils.CodOpr = "";
        // rimuovo post corrente...  
        mUtils.CodPost = "";
        // rimuovo MULTI
        mUtils.postIsMulti = false;
        // rimuovo COMMESSA
        CurrNumTask = "";
        // torno a pagina base...
        Response.Redirect("~/barcode");
      }
      else if (mod_barcode1.comandoRegistrato.prevCmdIn == mUtils.reCmdResetNumTask)
      {
        // rimuovo COMMESSA
        CurrNumTask = "";
        // torno a pagina base...
        Response.Redirect("~/barcode");
      }
      //else if (mod_barcode1.comandoRegistrato.valore.Contains("OPR."))
      else if (testOper.Success)
      {
        // imposto operatore
        mUtils.CodOpr = mod_barcode1.comandoRegistrato.valore;
        // SE HO postazione...
        if (mUtils.CodPost != "")
        {
          // ...e SE la postazione è libera associo e registro
          var tabPost = dataLayer.man.taAP.getByKey(mUtils.CodPost);
          if (tabPost.Rows.Count == 1)
          {
            var rigaPost = tabPost[0];
            if (rigaPost.CodOpr == mUtils.CodOpr || rigaPost.CodOpr == "")
            {
              dataLayer.man.taAP.setOpr(mUtils.CodPost, mUtils.CodOpr);
            }
            else
            {
              // tolgo postazione (è occupata...)
              mUtils.CodPost = "";
            }
          }
        }
        Response.Redirect("~/barcode");
      }
      else if (testPost.Success)
      {
        // SE HO operatore ...
        if (mUtils.CodOpr != "")
        {
          // ...e SE la postazione è libera o c'è lui associo e registro
          var tabPost = dataLayer.man.taAP.getByKey(mod_barcode1.comandoRegistrato.valore);
          if (tabPost.Rows.Count == 1)
          {
            var rigaPost = tabPost[0];
            if (rigaPost.CodOpr == mUtils.CodOpr || rigaPost.CodOpr == "")
            {
              mUtils.CodPost = mod_barcode1.comandoRegistrato.valore;
              dataLayer.man.taAP.setOpr(mUtils.CodPost, mUtils.CodOpr);
              // svuoto vallori
            }
          }
        }
        Response.Redirect("~/barcode");
      }
      else if (testNumTask.Success)
      {
        CurrNumTask = mod_barcode1.comandoRegistrato.valore;
        Response.Redirect("~/barcode");
      }
      else if (mod_barcode1.comandoRegistrato.prevCmdIn == mUtils.reCmdPause)
      {
        // registro chiusura con qta 0 (pausa)
        dataLayer.man.taTR.updateQuery(idxRecCurr, DateTime.Now, 0);
        Response.Redirect("~/barcode");
      }
      else if (mod_barcode1.comandoRegistrato.prevCmdIn == mUtils.reCmdClose)
      {
        // registro chiusura con la qta indicata
        dataLayer.man.taTR.updateQuery(idxRecCurr, DateTime.Now, QtaFaseCurr);
        Response.Redirect("~/barcode");
      }
      else if (dataLayer.man.taAF.getByKey(mod_barcode1.comandoRegistrato.prevCmdIn).Rows.Count > 0)
      {
        // se è un comando di fase --> registro INIZIO!
        dataLayer.man.taTR.insertQuery(mUtils.CodOpr, mUtils.CodPost, CurrNumTask, mod_barcode1.comandoRegistrato.prevCmdIn, DateTime.Now);
        // controllo se sia fase di CHIUSURA DEFINITIVA registro con INIZIO e FINE insieme e CHIUDO commessa...
        var rigaFase = dataLayer.man.taAF.getByKey(mod_barcode1.comandoRegistrato.prevCmdIn)[0];
        if (rigaFase.CloseTask)
        {
          // chiudo direttamente SIA fase che il TASK principale...  
          dataLayer.man.taTL.updateClose(CurrNumTask, true);
          // se è abilitato PODL indico chiuso anche li... IdxOdl = -10

          // tolgo comm corrente...
          CurrNumTask = "";
        }
        Response.Redirect("~/barcode");
      }
#if false
      DS_applicazione.IstObjRow rigaIstObj;
      // calcolo lo stato dell'oggetto...
      try
      {
        rigaIstObj = XPS_data.XPS.obj.taObj.getByIdxObj(mod_barcode1.comandoRegistrato.valore)[0];
        currState = rigaIstObj.CodStato;
      }
      catch
      {
      }
      tipoEsito esito = stateMachine.st.doAction("E_Stati", mod_barcode1.comandoRegistrato.valore, currState, mod_barcode1.comandoRegistrato.prevCmdIn);
      if (esito == tipoEsito.ok)
      {
        msg2show = string.Format("{0}: {1}", mod_barcode1.comandoRegistrato.valore, user_std.UtSn.Traduci("chgStateDone"));
      }
      else if (esito == tipoEsito.error)
      {
        msg2show = user_std.UtSn.Traduci("cannotStateChange");
      }
      else
      {
        msg2show = user_std.UtSn.Traduci("unknownCmd");
      } 
#endif
      // reset e mostro output...
      mod_barcode1.resetMe();
      if (msg2show != "")
      {
        mod_barcode1.txtInput2show = msg2show;
      }
    }

    protected void btnReload_Click(object sender, EventArgs e)
    {
      resetCache();
    }

    private void resetCache()
    {
      // resetto tutto!
      comandiAmmessiBCode = new Dictionary<string, string>();
      valoriAmmessiBCode = new Dictionary<string, string>();
      lastDataRefresh = DateTime.Now.AddDays(-1);
    }

    protected void txtCacheSec_TextChanged(object sender, EventArgs e)
    {
      resetCache();
    }

    protected void txtNumDD_TextChanged(object sender, EventArgs e)
    {
      resetCache();
    }
  }
}