using GMW_data;
using SteamWare;
using System;
using System.Collections.Generic;
using System.Web.UI;

namespace GMW.WebUserControls
{
  public partial class mod_sanpos_controlloLiquidi : System.Web.UI.UserControl
  {
    /// <summary>
    /// flusso associato (hard coded) a controllo liquidi
    /// </summary>
    protected string flusso = "LI";
    /// <summary>
    /// stato associato (hard coded) a  controllo liquidi
    /// </summary>
    protected string statoUDC = "FinLiq";
    /// <summary>
    /// stringa UID univoca
    /// </summary>
    public string uid
    {
      get
      {
        return this.UniqueID.Replace("$", "_").Replace("-", "_");
      }
    }
    /// <summary>
    /// caricamento pagina
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void Page_Load(object sender, EventArgs e)
    {
      if (!Page.IsPostBack)
      {
        Postazione.messaggiText = "";
        Postazione.warningText = "";
        traduciObj();
      }
      doChecks();
      if (currParticolare != "")
      {
        lblParticolareAttivo.Text = string.Format("Particolare selezionato <b>{0}</b>", currParticolare);
        // aggiungo descrizione del particolare
        string descr = "";
        string disegno = "";
        try
        {
          DS_magazzino.AnagParticolariRow riga = MagClass.magazzino.taAnagPart.likeSearch(currParticolare, memLayer.ML.StringSessionObj("CodCS"))[0];
          descr = riga.DescParticolare;
          disegno = string.Format("( {0} )", riga.DisegnoGrezzo);
        }
        catch
        { }
        lblDescrAttivo.Text = descr;
        lblDisegno.Text = disegno;
      }
      else
      {
        lblParticolareAttivo.Text = "...";
        lblDescrAttivo.Text = "";
        lblDisegno.Text = "";
      }
    }
    /// <summary>
    /// ristampo cartellino
    /// </summary>
    public void ristampa()
    {
      // registro ri-stampa UDC
      DateTime adesso = DateTime.Now;
      // calcolo particolare...
      DS_magazzino.ElencoCartelliniRow rigaUDC = null;
      string particolare = "";
      // cerco il tipo cartellino dato l'attuale stato e l'imballo del cartellino
      tipoCartellino cart = tipoCartellino.cartMP;
      try
      {
        rigaUDC = MagClass.magazzino.taCartellini.getByUdc(udcReq)[0];
        particolare = rigaUDC.Particolare;
        switch (rigaUDC.CodImballo)
        {
          case "IF10":
            cart = tipoCartellino.cartLiquidiF10;
            break;
          case "IF18":
            cart = tipoCartellino.cartLiquidiF18;
            break;
          default:
            break;
        }
      }
      catch
      {
        logger.lg.scriviLog(string.Format("Errore recupero particolare UDC Controllo Liquidi {0}", udcReq), tipoLog.EXCEPTION);
      }
      // stampo
      MagClass.magazzino.stampaUdc(udcReq, Postazione.printer, cart, Request.UserHostName);
      // registro azione
      MagClass.magazzino.taSAO.insertQuery(adesso, MagClass.magazzino.CodSoggCurrUser, Postazione.name, Postazione.IP, udcReq, particolare, "stampaUDC", "Ri-Stampato UDC F10");
    }
    /// <summary>
    /// udc da stampare
    /// </summary>
    protected string udcReq
    {
      get
      {
        return memLayer.ML.StringSessionObj("udcSelSAO");
      }
    }
    /// <summary>
    /// effettua controlli visibilità
    /// </summary>
    private void doChecks()
    {
      checkBarcode();
      checkStampa();
    }
    /// <summary>
    /// sistemo labels oggetti
    /// </summary>
    private void traduciObj()
    {
      //txtBox
      txtQta.Text = memLayer.ML.cdv("QtaImballoLiquidi");
      txtAnno.Text = DateTime.Now.Year.ToString();
      // buttons
      btnStampa.Text = traduci("btnStampa");
      btnAdd.ToolTip = traduci("btnAdd");
      btnSvuota.ToolTip = traduci("btnSvuota");
      btnEmptyNote.Text = traduci("btnEmptyNote");
    }
    /// <summary>
    /// restituisce il nome della pagina corrente
    /// </summary>
    protected string PagCorrente
    {
      get
      {
        string answ = "";
        Uri MyUrl = Request.Url;
        string delimStr = "/";
        char[] delimiter = delimStr.ToCharArray();
        string[] finalUrl = MyUrl.LocalPath.ToString().Split(delimiter);
        int n = finalUrl.Length;
        answ = finalUrl[n - 1].ToString();
        DataLayer_AnagGen.PermessiRow riga = (DataLayer_AnagGen.PermessiRow)user_std.UtSn.permessi.Select(string.Format("URL = '{0}'", answ))[0];
        answ = riga.NOME;
        return answ;
      }
    }
    /// <summary>
    /// wrapper traduzione
    /// </summary>
    /// <param name="lemma"></param>
    /// <returns></returns>
    public string traduci(object lemma)
    {
      return user_std.UtSn.Traduci(lemma.ToString());
    }
    /// <summary>
    /// indica il codice articolo correntemente selezionato
    /// </summary>
    protected string currParticolare
    {
      get
      {
        return memLayer.ML.StringSessionObj(string.Format("currParticolare_{0}", uid));
      }
      set
      {
        memLayer.ML.setSessionVal(string.Format("currParticolare_{0}", uid), value, memLayer.ML.confReadBool("keepParticolareSel"));
      }
    }
    /// <summary>
    /// indica se i caratteri vadano forzati a maiuscoli
    /// </summary>
    public bool forceUppercase
    {
      get
      {
        return memLayer.ML.confReadBool("forceUppercase");
      }
    }
    /// <summary>
    ///  num pezzi dell'ultimo UDC del particolare generato
    /// </summary>
    public int pezziUdc
    {
      get
      {
        int answ = 0;
        try
        {
          answ = (int)MagClass.magazzino.taCartellini.getLastByParticolareStato(memLayer.ML.StringSessionObj("CodCS"), currParticolare, statoUDC, false)[0].Qta;
        }
        catch
        { }
        return answ;
      }
    }
    /// <summary>
    /// cod imballo dell'ultimo UDC del particolare generato
    /// </summary>
    public string lastCodImb
    {
      get
      {
        string answ = "";
        try
        {
          answ = MagClass.magazzino.taCartellini.getLastByParticolareStato(memLayer.ML.StringSessionObj("CodCS"), currParticolare, statoUDC, false)[0].CodImballo;
        }
        catch
        {
          answ = memLayer.ML.cdv("CodImballoFiniti");
        }
        return answ;
      }
    }
    /// <summary>
    /// decodifica il tipo barcode acquisito
    /// </summary>
    public tipoCodiceBarcode tipoBCode
    {
      get
      {
        tipoCodiceBarcode answ = tipoCodiceBarcode.ND;
        int trovati = 0;
        // controllo non si tratti di un comando...
        string preCmd = memLayer.ML.AppConf["prefComandi"];
        if (barcodeIn.StartsWith(preCmd))
        {
          answ = tipoCodiceBarcode.Comando;
        }
        // controllo se sia un particolare Tipo P
        else if (TermClass.Ter.riconosciBarcode(barcodeIn) == tipoCodiceBarcode.Particolare && TermClass.Ter.isParticolare(barcodeIn)) // è un particolare...
        {
          answ = tipoCodiceBarcode.Particolare;
        }
        // controllo se sia un codice IMBALLO
        else if (utils.obj.taSelImballi.getByImballo(barcodeIn).Rows.Count > 0)
        {
          // è imballo!
          answ = tipoCodiceBarcode.Imballo;
        }
        else
        {
          try
          {
            // cerco tra gitterbox (UDC)...
            trovati = MagClass.magazzino.taCartellini.getByUdc(barcodeIn).Rows.Count;
            if (trovati > 0)
            {
              answ = tipoCodiceBarcode.UDC;
            }
          }
          catch
          {
          }
        }
        return answ;
      }
    }
    /// <summary>
    /// valore barcode
    /// </summary>
    public string barcodeIn
    {
      get
      {
        return txtBarcode.Text.Trim();
      }
      set
      {
        txtBarcode.Text = value;
      }
    }
    /// <summary>
    /// qta pezzi x UDC
    /// </summary>
    public int qta
    {
      get
      {
        int qta = 0;
        try
        {
          qta = Convert.ToInt32(txtQta.Text.Trim());
        }
        catch
        { }
        return qta;
      }
      set
      {
        txtQta.Text = value.ToString();
      }
    }
    /// <summary>
    /// controlla se ci sia un barcode
    /// </summary>
    private void checkBarcode()
    {
      if (barcodeIn != "")
      {
        Postazione.messaggiText = string.Format("Barcode digitato: {0}", barcodeIn);
        switch (tipoBCode)
        {
          case tipoCodiceBarcode.Imballo:
            // cerco di selezionare!
            try
            {
              ddlImballi.SelectedValue = barcodeIn;
            }
            catch
            {
              Postazione.warningText = traduci("ERR-IMB-001");
              Postazione.CssClass = "stileComandoKo";
            }
            break;
          case tipoCodiceBarcode.Particolare:
            // imposto il particolare corrente
            currParticolare = barcodeIn;
            // imposto particolare...
            lblPart.Text = currParticolare;
            // controllo esista il particolare scansionato
            if (DataProxy.obj.taAnagParticolari.getByParticolare(currParticolare).Rows.Count == 0)
            {
              currParticolare = "";
              Postazione.messaggiText += " - codice particolare non valido / non trovato in RILPRO.";
              Postazione.CssClass = "stileComandoKo";
            }
            else
            {
              Postazione.messaggiText += " - impostato particolare!";
              Postazione.CssClass = "stileComandoOk";
            }
            // default: qta a zero
            decimal qtaPart = 0;
            // leggo la qta dell'ultimo UDC del particolare, SE C'E', e la imposto...
            try
            {
              qtaPart = MagClass.magazzino.taCartellini.getLastByParticolare(memLayer.ML.StringSessionObj("CodCS"), currParticolare)[0].Qta;
            }
            catch
            { }
            if (qtaPart > 0)
            {
              txtQta.Text = Convert.ToInt32(qtaPart).ToString();
            }
            else // rimette default
            {
              txtQta.Text = memLayer.ML.cdv("QtaImballoLiquidi");
            }
            // fix imballo
            ddlImballi.DataBind();
            break;
          case tipoCodiceBarcode.UDC:
            // procedo solo se UDC esistente
            if (MagClass.magazzino.checkUDC(barcodeIn))
            {
              // recupero il particolare dai dati del cartellino preesistente
              currParticolare = DataProxy.obj.taCartellini.stp_getByUdc(barcodeIn)[0].Particolare;
              // controllo esista il particolare
              if (DataProxy.obj.taAnagParticolari.getByParticolare(currParticolare).Rows.Count == 0)
              {
                currParticolare = "";
                Postazione.messaggiText += " - codice particolare da UDC non valido / non trovato in RILPRO.";
                Postazione.CssClass = "stileComandoKo";
              }
              else
              {
                Postazione.messaggiText += " - impostato particolare!";
                Postazione.CssClass = "stileComandoOk";
              }
            }

            break;
          default:
            Postazione.messaggiText += " - codice <b>non riconosciuto</b>!";
            Postazione.CssClass = "stileComandoND";
            break;
        }
        barcodeIn = "";
      }
      else
      {
        Postazione.messaggiText = traduci("AttesaBCode");
        Postazione.CssClass = "stileAttesa";
      }
      //grView.DataBind();
      txtBarcode.Focus();
    }
    /// <summary>
    /// controllo l'abilitazione alla stampa UDC:
    /// - particolare ok
    /// - qta > 0
    /// - almeno 1 trattamento
    /// altrimenti disabilito btn stampa
    /// </summary>
    private void checkStampa()
    {
      bool stampaOk = false;
      if (currParticolare != "" && qta > 0)
      {
        if (elencoTrattamenti.Count > 0)
        {
          updateListBoxTrattamenti();
          stampaOk = true;
        }
      }
      btnStampa.Enabled = stampaOk;
    }

    /// <summary>
    /// elenco dictionary dei trattamenti da associare ad UDC
    /// </summary>
    public Dictionary<string, string> elencoTrattamenti
    {
      get
      {
        try
        {
          return (Dictionary<string, string>)memLayer.ML.objSessionObj("elencoTrattamenti");
        }
        catch
        {
          return new Dictionary<string, string>();
        }
      }
      set
      {
        memLayer.ML.setSessionVal("elencoTrattamenti", value, false);
      }
    }
    /// <summary>
    /// aggiungo un oggetto trattamento alla lista..
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnAdd_Click(object sender, EventArgs e)
    {
      if (txtTratt.Text.Trim() != "")
      {
        string valore = txtTratt.Text.Trim();
        Dictionary<string, string> elenco = elencoTrattamenti;
        // controllo il valore non ci sia già...
        if (!elenco.ContainsKey(valore))
        {
          elenco.Add(valore, "n° " + valore);
          elencoTrattamenti = elenco;
        }
        txtTratt.Text = "";
        updateListBoxTrattamenti();
      }
      doChecks();
    }
    /// <summary>
    /// aggiorna la listbox
    /// </summary>
    private void updateListBoxTrattamenti()
    {
      lbTrattamenti.DataSource = elencoTrattamenti;
      lbTrattamenti.DataTextField = "Value";
      lbTrattamenti.DataValueField = "Key";
      lbTrattamenti.DataBind();
    }
    /// <summary>
    /// svuota elenco trattamenti
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnSvuota_Click(object sender, EventArgs e)
    {
      resetTrattamenti();
      doChecks();
    }
    /// <summary>
    /// resetta i trattamenti caricati
    /// </summary>
    private void resetTrattamenti()
    {
      Dictionary<string, string> elenco = new Dictionary<string, string>();
      elencoTrattamenti = elenco;
      txtTratt.Text = "";
      updateListBoxTrattamenti();
    }
    /// <summary>
    /// genera i barcode di
    /// - trattamenti
    /// - nuovo x pezzi liquidi
    /// e lancia la relativa stampa
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnStampa_Click(object sender, EventArgs e)
    {
      // verifico postazione x procedere...
      if (Postazione.printer != "n.d.")
      {
        string newUdcChild = "";
        string newUdcParent = "";
        bool UdcExists = false;
        int anno = Convert.ToInt32(txtAnno.Text.Substring(txtAnno.Text.Trim().Length - 2, 2));
        int qta = memLayer.ML.cdvi("QtaImballoLiquidi");
        string noteTrim = txtNote.Text.Trim();
        try
        {
          qta = Convert.ToInt32(txtQta.Text);
        }
        catch
        { }
        // effettuo controlli che cod_soggetto e cod particolare siano disponibili...
        string codSogg = "";
        string particolare = "";
        try
        {
          codSogg = MagClass.magazzino.CodSoggCurrUser;
          particolare = currParticolare;
        }
        catch
        {
        }
        if (codSogg != "" && particolare != "")
        {
          // calcolo codImballo
          string codImballo = "";
          try
          {
            codImballo = ddlImballi.SelectedValue;
          }
          catch
          {
            codImballo = memLayer.ML.cdv("CodImballoLiquidi");
          }
          // se NON HA selezionato prendo default...
          if (string.IsNullOrEmpty(codImballo) || codImballo == "-")
          {
            codImballo = memLayer.ML.cdv("CodImballoLiquidi");
          }
          // genero cartellino liquidi
          DateTime adesso = DateTime.Now;
          try
          {
            // creo nuovo UDC del trattamento liquidi
            newUdcChild = MagClass.magazzino.creaUdc(flusso, "", particolare, "", "", "", "", "", 0, codImballo, "U", codSogg, qta, 0, 0, adesso, 0, statoUDC, memLayer.ML.cdvi("IdxPosizioneLiquidi"), "IdxPosizioneLiquidi", memLayer.ML.cdv("nuovoUdcLiquidiF10"), noteTrim, "", adesso.Year, Request.UserHostName);
            // registro creazione nuovo UDC
            MagClass.magazzino.taSAO.insertQuery(adesso, codSogg, Postazione.name, Postazione.IP, newUdcChild, particolare, "creaUDC", string.Format("Creato nuovo UDC Liquidi F10 - qta:{0} {1}", qta, noteTrim));
          }
          catch (Exception exc)
          {
            httpLog(string.Format("Errore creazione UDC Liquidi San Possidonio: {0}", exc), tipoLog.EXCEPTION);
          }
          // se ho cart liquidi genero (se non ci sono) cart trattamenti
          if (newUdcChild != "")
          {
            // creo UDC dei trattamenti termici
            foreach (KeyValuePair<string, string> kvp in elencoTrattamenti)
            {
              // calcolo il nuovo codice UDC del trattamento
              newUdcParent = MagClass.magazzino.getComposizioneUDC(memLayer.ML.cdv("CodCS"), "TR", anno.ToString(), Convert.ToInt32(kvp.Key)); // !!! "TR" HARD CODED x indicare flusso trattamenti
                                                                                                                                               // verifico se ci sia già UDC
              UdcExists = MagClass.magazzino.checkUDC(newUdcParent);
              if (!UdcExists)
              {
                try
                {
                  // creo UDC
                  MagClass.magazzino.creaUdc("TR", "", memLayer.ML.confReadString("particTratt"), "", "", "", "", "", 0, "", "U", MagClass.magazzino.CodSoggCurrUser, 0, 0, 0, DateTime.Now, 0, "Trattamenti", memLayer.ML.cdvi("IdxPosizioneTrattamenti"), "IdxPosizioneTrattamenti", memLayer.ML.cdv("nuovoUdcTrattamenti"), flusso, newUdcParent, anno, Request.UserHostName);
                }
                catch (Exception exc)
                {
                  httpLog(string.Format("Errore creazione cartellino trattamenti San Possidonio: {0}", exc), tipoLog.EXCEPTION);
                }
              }
              // associo tratt termici e liquidi
              MagClass.magazzino.associaUdcParent(newUdcChild, newUdcParent);
              if (!UdcExists)
              {
                // consumo UDC tratt termici
                MagClass.magazzino.scaricaUdcMpWip(newUdcParent, Request.UserHostName);
              }
              // reset valori
              newUdcParent = "";
              UdcExists = false;
            }
            // ora stampo il nuovo cartellino!!!
            MagClass.magazzino.stampaUdc(newUdcChild, Postazione.printer, tipoCartellino.cartLiquidiF10, Request.UserHostName);
            // incremento timing...
            adesso = DateTime.Now;
            adesso = adesso.AddSeconds(1);
            // registro stampa nuovo UDC
            MagClass.magazzino.taSAO.insertQuery(adesso, codSogg, Postazione.name, Postazione.IP, newUdcChild, particolare, "stampaUDC", "Stampato UDC Liquidi F10");
          }
        }
        else
        {
          httpLog(string.Format("Errore persi utente/particolare, ricarico!"), tipoLog.ERROR);
          Response.Redirect("~/login.aspx");
        }
      }
      else
      {
        Response.Redirect("~/menu.aspx");
      }
    }
    /// <summary>
    /// wrapper per log con salvataggio dell'IP del chiamante
    /// </summary>
    /// <param name="_testoPre"></param>
    /// <returns></returns>
    public bool httpLog(string _testoPre)
    {
      bool answ = false;
      logger.lg.scriviLog(Postazione.IP + _testoPre);
      return answ;
    }
    /// <summary>
    /// wrapper per log con salvataggio dell'IP del chiamante
    /// </summary>
    /// <param name="_testoPre"></param>
    /// <returns></returns>
    public bool httpLog(string testoLog, tipoLog tipo)
    {
      bool answ = false;
      logger.lg.scriviLog(Postazione.IP + testoLog, tipo);
      return answ;
    }
    /// <summary>
    /// svuoto le note
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnEmptyNote_Click(object sender, EventArgs e)
    {
      txtNote.Text = "";
    }
    /// <summary>
    /// preseleziono (se possibile) imballo...
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void ddlImballi_DataBound(object sender, EventArgs e)
    {
      selezionaImballo();
    }
    /// <summary>
    /// seleziona imballo corretto
    /// </summary>
    private void selezionaImballo()
    {
      string codImb = "";
      // cerco se c'è un imballo x particolare corrente...
      if (currParticolare != "")
      {
        codImb = lastCodImb;
      }
      else
      {
        codImb = memLayer.ML.cdv("CodImballoFiniti");
      }
      try
      {
        // preseleziono
        ddlImballi.SelectedValue = codImb;
      }
      catch
      { }
    }

  }
}