using SteamWare;
using System;


namespace GMW_data
{
  /// <summary>
  /// fa da proxy singleton x gli oggetti legati ai cartellini ODETTE
  /// </summary>
  public class Odette
  {
    /// <summary>
    /// Oggetto locale gestione classe datamatrix...
    /// </summary>
    protected DataMatrix DataMatrix_mgr = new DataMatrix();
    #region area table adapters

    public DS_OdetteTableAdapters.OdetteTableAdapter taOdette;
    public DS_OdetteTableAdapters.BORI202JTableAdapter taBORI;
    public DS_OdetteTableAdapters.stp_OdetteStatoCreateTableAdapter taOdCreate;

    /// <summary>
    /// init dei table adapters
    /// </summary>
    protected void initTA()
    {
      taOdette = new GMW_data.DS_OdetteTableAdapters.OdetteTableAdapter();
      taBORI = new GMW_data.DS_OdetteTableAdapters.BORI202JTableAdapter();
      taOdCreate = new GMW_data.DS_OdetteTableAdapters.stp_OdetteStatoCreateTableAdapter();
    }
    /// <summary>
    /// effettua setup dei connection strings da web.config delal singola applicazione
    /// </summary>
    protected virtual void setupConnectionStringBase()
    {
      string connString = memLayer.ML.confReadString("GMWConnectionString");
      // connections strings del db
      taOdette.Connection.ConnectionString = connString;
      taBORI.Connection.ConnectionString = connString;
      taOdCreate.Connection.ConnectionString = connString;
    }
    #endregion

    protected Odette()
    {
      initTA();
      setupConnectionStringBase();
    }

    #region area protected

    /// <summary>
    /// carica le label di lingua su un etichetta odette (che deve già esistere)
    /// </summary>
    /// <param name="UDC"></param>
    /// <param name="lingua"></param>
    /// <returns></returns>
    protected bool caricaEtichetteLinguaPerOdette(string UDC, string lingua)
    {
      bool answ = false;
      // controllo se etichetta odette esiste...
      if (taOdette.getByUdc(UDC).Rows.Count > 0)
      {
        // carico le mie labels tradotte...
        string Campo1_1 = traduci("Campo1_1", lingua);
        string Campo2_1 = traduci("Campo2_1", lingua);
        string Campo3_1 = traduci("Campo3_1", lingua);
        string Campo4_1 = traduci("Campo4_1", lingua);
        string Campo5_1 = traduci("Campo5_1", lingua);
        string Campo6_1 = traduci("Campo6_1", lingua);
        string Campo7_1 = traduci("Campo7_1", lingua);
        string Campo8_1 = traduci("Campo8_1", lingua);
        string Campo9_1 = traduci("Campo9_1", lingua);
        string Campo10_1 = traduci("Campo10_1", lingua);
        string Campo11_1_1 = traduci("Campo11_1_1", lingua);
        string Campo11_2_1 = traduci("Campo11_2_1", lingua);
        string Campo12_1 = traduci("Campo12_1", lingua);
        string Campo13_1 = traduci("Campo13_1", lingua);
        string Campo14_1 = traduci("Campo14_1", lingua);
        string Campo15_1 = traduci("Campo15_1", lingua);
        string Campo16_1 = traduci("Campo16_1", lingua);
        // effettuo update!
        taOdette.updateLingua(UDC, Campo1_1, Campo2_1, Campo3_1, Campo4_1, Campo5_1, Campo6_1, Campo7_1, Campo8_1, Campo9_1, Campo10_1, Campo11_1_1, Campo11_2_1, Campo12_1, Campo13_1, Campo14_1, Campo15_1, Campo16_1);
      }
      else
      {
        logger.lg.scriviLog(string.Format("Attenzione! etichetta odette non trovata per l'UDC {0}", UDC), tipoLog.ERROR);
      }
      return answ;
    }
    /// <summary>
    /// verifica una etichetta odette e salva in db il valore di check x consistenza dei dati
    /// </summary>
    /// <param name="UDC"></param>
    /// <returns></returns>
    protected bool updateStatoOdette(string UDC)
    {
      bool answ = false;
      try
      {
        // effettuo verifiche sulla riga odette...
        // !!!FARE!!!
        answ = true;
        taOdette.setStato(UDC, answ);
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// carica i dati per l'etichetta Odette provenienti dalla bolla indicata
    /// </summary>
    /// <param name="UDC"></param>
    /// <param name="RaggMag"></param>
    /// <param name="GrpBolla"></param>
    /// <param name="numBolla">codice bolla</param>
    /// <param name="dataBolla">data bolla formato YYYYMMDD</param>
    /// <param name="particolare"></param>
    /// <returns></returns>
    protected bool caricaDatiBollaEtichettaOdette(string UDC, string RaggMag, string GrpBolla, decimal numBolla, decimal dataBolla, string particolare)
    {
      bool answ = false;
      try
      {
        taOdette.caricaDatiBollaEtichettaOdette(memLayer.ML.cdv("CodCS"), UDC, numBolla.ToString(), dataBolla.ToString(), RaggMag, GrpBolla, particolare);
        answ = true;
      }
      catch
      {
        answ = false;
      }
      return answ;
    }

    #endregion

    #region area public

    /// <summary>
    /// singleton
    /// </summary>
    public static Odette mgr = new Odette();
    /// <summary>
    /// wrapper traduzione
    /// </summary>
    /// <param name="lemma"></param>
    /// <param name="lingua"></param>
    /// <returns></returns>
    public string traduci(string lemma, string lingua)
    {
      return user_std.UtSn.Traduci(lemma, lingua);
    }

    /// <summary>
    /// verifica l'esistenza di una bolla dato il suo codice + data
    /// </summary>
    /// <param name="RaggMag">cod raggr magazzino</param>
    /// <param name="GrpBolla">gruppo bolla</param>
    /// <param name="numBolla">codice bolla NUMERICO</param>
    /// <param name="dataBolla">data bolla formato numerico YYYYMMDD</param>
    /// <param name="particolare">codice particolare</param>
    /// <returns></returns>
    public bool checkCodBolla(string RaggMag, string GrpBolla, decimal numBolla, decimal dataBolla, string particolare)
    {
      bool answ = false;
      int righeBolla = 0;
      // controllo che la bolla esista...
      try
      {
        // provo a caricarle con stored...
        taBORI.caricaDatiBolla(RaggMag, GrpBolla, numBolla.ToString(), dataBolla.ToString(), particolare);
        // rileggo se presenti...
        righeBolla = taBORI.getByKeyFull(RaggMag, GrpBolla, Convert.ToDecimal(numBolla), Convert.ToDecimal(dataBolla), particolare).Rows.Count;
        answ = (righeBolla >= 1);
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("Errore in checkCodBolla:{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
      }
      // controllo che la bolla non sia già associata... ovvero SENZA NESSUNA etichetta odette associata x quel particolare...
      if (answ)
      {
        // controllo se trovo odette associate a tale bolla...
        answ = (taOdette.getByBolla(RaggMag, GrpBolla, numBolla, dataBolla, particolare).Rows.Count == 0);
      }
      return answ;
    }
    /// <summary>
    /// conteggia il num di colli x una data bolla
    /// </summary>
    /// <param name="RaggMag">cod raggr magazzino</param>
    /// <param name="GrpBolla">gruppo bolla</param>
    /// <param name="numBolla">codice bolla NUMERICO</param>
    /// <param name="dataBolla">data bolla formato numerico YYYYMMDD</param>
    /// <param name="particolare">codice particolare</param>
    /// <returns></returns>
    public int totColliBolla(string RaggMag, string GrpBolla, decimal numBolla, decimal dataBolla, string particolare)
    {
      int answ = 0;
      try
      {
        // calcolo il totale dei pezzi: ogni riga contiene il totale colli della bolla...
        //answ = (int)taBORI.getByKeyFull(RaggMag, GrpBolla, Convert.ToDecimal(numBolla), Convert.ToDecimal(dataBolla), particolare)[0].NRC1B;
        answ = Convert.ToInt32(taBORI.getByKeyFull(RaggMag, GrpBolla, Convert.ToDecimal(numBolla), Convert.ToDecimal(dataBolla), particolare).Compute("SUM(NRC1B)", ""));
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// conteggia il num di pezzi x una data bolla
    /// </summary>
    /// <param name="RaggMag">cod raggr magazzino</param>
    /// <param name="GrpBolla">gruppo bolla</param>
    /// <param name="numBolla">codice bolla NUMERICO</param>
    /// <param name="dataBolla">data bolla formato numerico YYYYMMDD</param>
    /// <param name="particolare">codice particolare</param>
    /// <returns></returns>
    public int totPezziBolla(string RaggMag, string GrpBolla, decimal numBolla, decimal dataBolla, string particolare)
    {
      int answ = 0;
      try
      {
        // rileggo se presenti...
        answ = Convert.ToInt32(taBORI.getByKeyFull(RaggMag, GrpBolla, Convert.ToDecimal(numBolla), Convert.ToDecimal(dataBolla), particolare).Compute("SUM(QTCNS)", ""));
        //answ = (int)taBORI.getByKeyFull(RaggMag, GrpBolla, Convert.ToDecimal(numBolla), Convert.ToDecimal(dataBolla), particolare)[0].QTCNS;
      }
      catch
      { }
      return answ;
    }

    /// <summary>
    /// crea tutte le righe encessarie alal stampa dei cartellini Odette dati lista di prelievo, bolla da associare
    /// </summary>
    /// <param name="CodLista">codice lista di prelievo</param>
    /// <param name="RaggMag">cod raggr magazzino</param>
    /// <param name="GrpBolla">gruppo bolla</param>
    /// <param name="numBolla">codice bolla NUMERICO</param>
    /// <param name="dataBolla">data bolla formato numerico YYYYMMDD</param>
    /// <param name="particolare">codice particolare</param>
    /// <param name="Lingua">IT/EN/...</param>
    /// <returns>in caso di errore e ritorno false, salva in sessione il messaggio di errore relativo in errCreazOdette</returns>
    public bool creaOdetteByBollaPackList(string CodLista, string RaggMag, string GrpBolla, decimal numBolla, decimal dataBolla, string particolare, string lingua)
    {
      bool answ = false;
      string errCreazOdette = "";
      int totUdc = 0;
      int totPz = 0;
      int udcOk = 0;
      DS_magazzino.RigheListePrelievoDataTable ElencoUdc = new DS_magazzino.RigheListePrelievoDataTable();
      // conto totale etichette da creare
      try
      {
        ElencoUdc = MagClass.magazzino.taRigheListePrelievo.getByCodLista(CodLista);
        totUdc = ElencoUdc.Rows.Count;
        totPz = (int)MagClass.magazzino.taElencoListePrelievo.getByCodLista(CodLista)[0].Prelevato;
      }
      catch
      {
        errCreazOdette = string.Format("Errore: non ci sono UDC da creare per la PackList {0}", CodLista);
        logger.lg.scriviLog(errCreazOdette, tipoLog.ERROR);
      }
      // in primis comunque verifico che la bolla ci sia altrimenti non procedo (anche se avrebbe già dovuto controllare...)
      if (checkCodBolla(RaggMag, GrpBolla, numBolla, dataBolla, particolare) && totUdc > 0)
      {
        // controllo se il totale colli corrisponde al totale UDC..
        if (totColliBolla(RaggMag, GrpBolla, numBolla, dataBolla, particolare) == totUdc || true) // controllo disattivato 2013.03.22 perché i colli riga sono i colli totali bolla
        {
          // controllo se il totale pezzi corrisponde al totale qta...
          if (totPezziBolla(RaggMag, GrpBolla, numBolla, dataBolla, particolare) == totPz)
          {
            // leggo elenco UDC da packing list
            foreach (DS_magazzino.RigheListePrelievoRow rigaUdc in ElencoUdc)
            {
              // per ogni UDC creo una riga 
              taOdette.upsertUdc(rigaUdc.UDC, memLayer.ML.cdv("CodCS"), numBolla.ToString(), dataBolla.ToString(), RaggMag, GrpBolla, particolare, CodLista, memLayer.ML.confReadString("indStabFrom"), rigaUdc.Qta.ToString());
              udcOk++;
              // per ogni riga inserisco traduzione nella lingua richiesta
              caricaEtichetteLinguaPerOdette(rigaUdc.UDC, lingua);
              // vado a caricare i dati dalla tab dei dati bolle
              caricaDatiBollaEtichettaOdette(rigaUdc.UDC, RaggMag, GrpBolla, numBolla, dataBolla, particolare);
              // effettuo check della riga odette e determino se sia conforme
              updateStatoOdette(rigaUdc.UDC);
            }
          }
          else
          {
            errCreazOdette = string.Format("Errore assegnazione bolle/odette, il num di pezzi non corrisponde: num bolla {0} del {1}, lista prelievo {2}", numBolla, dataBolla, CodLista);
            logger.lg.scriviLog(errCreazOdette, tipoLog.ERROR);
          }
        }
        else
        {
          errCreazOdette = string.Format("Errore assegnazione bolle/odette, il num di colli non corrisponde: num bolla {0} del {1}, lista prelievo {2}", numBolla, dataBolla, CodLista);
          logger.lg.scriviLog(errCreazOdette, tipoLog.ERROR);
        }
      }
      else
      {
        errCreazOdette = string.Format("Tentativo di generazione etichette odette da bolla inesistente/già impiegata: codice {0} del {1}", numBolla, dataBolla);
        logger.lg.scriviLog(errCreazOdette, tipoLog.ERROR);
      }
      // controllo se tutte le etichette sono sstate create
      if (totUdc == udcOk)
      {
        answ = true;
      }
      memLayer.ML.setSessionVal("errCreazOdette", errCreazOdette);
      return answ;
    }
    /// <summary>
    /// Stampa tutte le etichette odette di una lista di prelievo
    /// </summary>
    /// <param name="CodLista"></param>
    /// <param name="printerName"></param>
    /// <returns></returns>
    public bool stampaOdettePackingList(string CodLista, string printerName)
    {
      bool answ = false;
      int totOdette = 0;
      DS_Odette.OdetteDataTable ElencoOdette = new DS_Odette.OdetteDataTable();
      // conto totale etichette Odette con StatusOK=1 corrispondenti a lista prelievo
      try
      {
        ElencoOdette = taOdette.getByCodLista(CodLista);
        totOdette = ElencoOdette.Rows.Count;
      }
      catch
      {
        logger.lg.scriviLog(string.Format("Errore: non ci sono UDC da creare per la PackList {0}", CodLista), tipoLog.ERROR);
      }
      // in primis comunque verifico che la bolla ci sia altrimenti non procedo (anche se avrebbe già dovuto controllare...)
      if (totOdette > 0)
      {
        // processo elenco Odette
        foreach (DS_Odette.OdetteRow rigaOdette in ElencoOdette)
        {
          stampaEtichettaOdette(rigaOdette.CampoUDC, printerName);
        }
      }
      else
      {
        logger.lg.scriviLog(string.Format("Attenzione: non ho trovaot etichette odette valide per la lista di prelievo {0}", CodLista), tipoLog.ERROR);
      }
      return answ;
    }
    /// <summary>
    /// stampa una singola etichetta odette
    /// </summary>
    /// <param name="UDC"></param>
    /// <param name="printerName"></param>
    /// <returns></returns>
    public bool stampaEtichettaOdette(string UDC, string printerName)
    {
      bool answ = false;
      // chiamo il report...
      try
      {
        answ = reportPrinter.obj.stampaCartellino(tipoCartellino.cartOdette, UDC, printerName);
      }
      catch
      {
        logger.lg.scriviLog(String.Format("Errore nella stmapa del cartellino per l'UDC {0}", UDC), tipoLog.ERROR);
      }
      return answ;
    }
    /// <summary>
    /// determina se ci siano odette x la lista di prelievo
    /// </summary>
    /// <param name="codLista"></param>
    /// <returns></returns>
    public bool listaHasOdette(string codLista)
    {
      bool answ = false;
      try
      {
        DS_Odette.stp_OdetteStatoCreateRow rigaCreate = taOdCreate.GetData(codLista)[0];
        answ = rigaCreate.OdetteCreate > 0;
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// restituisce info se un gitterbox abbia una etichetta odette associata
    /// <param name="codGitterbox"></param>
    /// </summary>
    public bool gitterboxInOdette(string codGitterbox)
    {
      bool answ = false;
      try
      {
        answ = taOdette.getByUdc(codGitterbox).Rows.Count > 0;
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// restituisce info se un datamatrix faccia parte di un gitterbox con una etichetta odette associata
    /// </summary>
    public bool datamatrixInOdette(decimal codDataMatrix)
    {
      bool answ = false;
      string codGitterbox = DataMatrix_mgr.gitterboxFromDataMatrix(codDataMatrix);
      answ = gitterboxInOdette(codGitterbox);
      return answ;
    }
    /// <summary>
    /// Restituisce info se un datamatrix possa essere spostato tra 2 gitterbox (il suo d'origine e quello indicato),
    /// mantenendo l'omogeneità dei prodotti nel gitterbox.
    /// Verifiche:
    /// - se il datamatrix ha un gitterbox associato --> le prime 2 cifre dei gitterbox devono coincidere
    /// - se il datamatrix non ha un gitterbox associato --> rileggo gitterbox originale pre importazione e faccio verifica dei primi 2 char
    /// <param name="codDataMatrix"></param>
    /// <param name="codGitterbox"></param>
    /// </summary>
    public bool dtMtxGtboxCompatibili(decimal codDataMatrix, string codGitterboxTo)
    {
      bool answ = false;
      string codGitterboxFrom = "";
      try
      {
        codGitterboxFrom = DataMatrix_mgr.gitterboxFromDataMatrix(codDataMatrix);
        if (codGitterboxFrom != "EmptyGBox")
        {
          answ = (codGitterboxFrom.Substring(0, 2) == codGitterboxTo.Substring(0, 2));
        }
        else
        {
          // cerco gitterbox originale...
          codGitterboxFrom = DataMatrix_mgr.gitterboxOrigFromDataMatrix(codDataMatrix);
          answ = (codGitterboxFrom.Substring(0, 2) == codGitterboxTo.Substring(0, 2));
        }
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// restituisce info se un datamatrix esista
    /// <param name="codDataMatrix"></param>
    /// </summary>
    public bool datamatrixEsiste(decimal codDataMatrix)
    {
      bool answ = false;
      try
      {
        answ = DataMatrix_mgr.taElencoDM.getByCode(codDataMatrix).Rows.Count > 0;
      }
      catch
      { }
      return answ;
    }


    #endregion

  }
}