#include <applicat.h>
#include <automask.h>
#include <defmask.h>
#include <execp.h>
#include <reputils.h>
#include <reprint.h>
#include <toolfld.h>
#include <utility.h>

#include "lvlib.h"
#include "../mg/clifogiac.h"
#include "../ve/velib.h"

#include "clifo.h"
#include "lvcondv.h"
#include "lvrcondv.h"
#include "lvrconsplan.h"

#include  "lv3400a.h"

                                          //////////////////////////////
                                          ////    TQUANTITA_RIGA    ////
                                          //////////////////////////////

//Classe TQuantita_riga
class TQuantita_riga: public TObject
{
  int   _nriga;
  bool  _evaso;
  long  _qtarit;
  long  _qtadacon;
  long  _qtacon;
  int   _pacchi;

public:
  int  get_nriga()      const;
  bool get_evaso()      const;
  long get_qta_rit()    const;
  long get_qta_da_con() const;
  long get_qta_con()    const;
  int  get_pacchi()     const;

  void set_nriga(const int nriga);
  void set_evaso(const bool evaso);
  void set_qta_rit(const long qta);
  void set_qta_da_con(const long qta);
  void set_qta_con(const long qta);
  void set_pacchi(const int pacchi);

  void add_qta_con(const long qta);
  void add_pacchi(const int pacchi = 1);
  
  TQuantita_riga(bool evaso = false, long qtadc = 0, long qtac = 0, int pacchi = 0);
};

//GET_NRIGA: metodo che restituisce il numero di riga
int TQuantita_riga::get_nriga() const
{
  return _nriga;
}

//GET_EVASO: metodo che restituisce il booleano evaso
bool TQuantita_riga::get_evaso() const
{
  return _evaso;
}

//GET_QTA_RIT: metodo che restituisce la qunatita ritirata
long TQuantita_riga::get_qta_rit() const
{
  return _qtarit;
}

//GET_QTA_DA_CON: metodo che restituisce la quantità da consegnare
long TQuantita_riga::get_qta_da_con() const
{
  return _qtadacon;
}

//GET_QTA_CON: metodo che restituisce la quantità consegnata
long TQuantita_riga::get_qta_con() const
{
  return _qtacon;
}

//GET_PACCHI: metodo che restituisce il humero dei pacchi consegnati
int TQuantita_riga::get_pacchi() const
{
  return _pacchi;
}

//SET_NRIGA: metodo che setta il numero di riga
void TQuantita_riga::set_nriga(const int nriga)
{
  _nriga = nriga;
}

//SET_EVASO: metodo che setta il booleano evaso
void TQuantita_riga::set_evaso(const bool evaso)
{
  _evaso = evaso;
}

//SET_QTA_RIT: metodo che setta la quantità ritirata
void TQuantita_riga::set_qta_rit(const long qta)
{
  _qtarit = qta;
}

//SET_QTA_DA_CON: metodo che setta la quantità da consegnare
void TQuantita_riga::set_qta_da_con(const long qta)
{
  _qtadacon = qta;
}

//SET_QTA_CON: metodo che setta la quantità consegnata
void TQuantita_riga::set_qta_con(const long qta)
{
  _qtacon = qta;
}

//SET_PACCHI: metodo che setta il hnumero di pacchi consegnato
void TQuantita_riga::set_pacchi(const int pacchi)
{
  _pacchi = pacchi;
}

//ADD_QTA_CON: metodo che aggiunge un quantitativo di roba alla quantità consegnata
void TQuantita_riga::add_qta_con(const long qta)
{
  _qtacon += qta;
}

//ADD_PACCHI: metodo che aggiunge un certo numero di pacchi a quelli consegnati (default = 1)
void TQuantita_riga::add_pacchi(const int pacchi)
{
  _pacchi += pacchi;
}

//metodo costruttore
TQuantita_riga::TQuantita_riga(bool evaso, long qtadc, long qtac, int pacchi)
{
  set_evaso(evaso);
  set_qta_da_con(qtadc);
  set_qta_con(qtac);
  set_pacchi(pacchi);
}

                                          ////////////////////////////
                                          ////    TRIGHE_ARRAY    ////
                                          ////////////////////////////

//Classe TRighe_array
class TRighe_array: public TAssoc_array
{
public:
  TQuantita_riga* quantita(TString& codart, TDate& data, bool create);
};

//QUANTITA: metodo che cerca nel TAssoc_array le quantità della riga interessata in base ai parametri passati
//e lo crea in automatico se il parametro create vale "true"
TQuantita_riga* TRighe_array::quantita(TString& codart, TDate& data, bool create)
{
  TToken_string key;
  key.add(codart);
  key.add(data);

  TQuantita_riga* qr = (TQuantita_riga*)objptr(key);

  if(qr == NULL && create)
  {
    qr = new TQuantita_riga();
    add(key, qr);
  }
  return qr;
}

                                          /////////////////////////////////
                                          ////    TEVASIONE_TER_MSK    ////
                                          /////////////////////////////////


//Classe TEvasione_ter_msk
class TEvasione_ter_msk: public TAutomask
{
  int           _ndoc;
  int           _autoselect;
  TString4      _tpev;
  TAssoc_array  _pacchi;
  TRighe_array  _ra;

protected:
  void campi_cliente();
  
  bool precarica_righe();
  void genera_buono();
  void evadi();
  void registra();

  void riempi_sheet();
  void spezza_riga();
  
  bool controlla();

  void evadi_da_terminale();

  virtual void on_idle();
  virtual bool on_key(KEY key);
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

public:
  TEvasione_ter_msk();  
};

//ON_KEY: metodo che gestisce i tatsi funzione
bool TEvasione_ter_msk::on_key(KEY key)
{
  /*TString str;
  str << key;

  message_box(str);*/

  if (key >= K_F3 && key <= K_F7)
  {
    FOR_EACH_MASK_FIELD(*this, i, f)
    {
      if (f->is_kind_of(CLASS_BUTTON_TOOL) && f->active())
      {
        TButton_tool& tf = (TButton_tool&)*f;

        if (tf.exit_key() == key)
        {
          send_key(K_SPACE, f->dlg());
          return true;
        }
      }
    }
  }
  return TAutomask::on_key(key);
}

//PRECARICA_RIGHE: metodo che carica in un TAssoc_array le righe fisiche del documento
bool TEvasione_ter_msk::precarica_righe()
{
  TDoc_key kdoc(get_int(F_TANNO), ini_get_string(CONFIG_DITTA, "lv", "NUM_PRE", NULL, 0), get_long(F_TNDOC));
  TBuono_prelievo doc(kdoc);

  if (doc.empty())
  {
    warning_box(TR("Il documento cercato è inesistente"));
    return false;
  }

  const TString4 stato = cache().get("%TIP", ini_get_string(CONFIG_DITTA, "lv", "TIPODOC_PRE", NULL, 0), "S2").mid(2,1);

  if (doc.get(DOC_STATO) == stato)
  {
    TString str;
    str << "Il documento " << get_long(F_TNDOC) << " è già stato evaso";
    warning_box(str);

    reset(F_TCHIAVE);

    return false;
  }

  TDate oggi(TODAY);

  FOR_EACH_PHYSICAL_RDOC(doc, i, row)  
  {
    TBuono_prelievo_row rdoc(*row);

    TString80 codart = rdoc.codart();

    if (codart.blank())
      continue;

    TQuantita_riga* qr = _ra.quantita(codart, oggi, true);
    qr->set_nriga(i);
    qr->set_evaso(rdoc.evaso());
    qr->set_qta_rit(rdoc.qta_ritirata());
    qr->set_qta_da_con(rdoc.qta_dacons());
    qr->set_qta_con(rdoc.qta_consegnata());
    qr->set_pacchi(rdoc.num_pacchi());
  }
  return true;
}

//GENERA_BUONO: metodo che genera il buono di consegna partendo dal buono di ritiro
void TEvasione_ter_msk::genera_buono()
{
  //per prima cosa salva il buono di prelievo
  registra();
  
  TDoc_key kdoc(get_date(F_TDATADOC).year(), ini_get_string(CONFIG_DITTA, "lv", "NUM_PRE", NULL, 0), get_long(F_TNDOC));
  TBuono_prelievo bpre(kdoc);
  const long codcf = bpre.codcf();
  const int codcont = bpre.codcont();

  TLaundry_contract cont(codcf, codcont);
  //leggo se devo scrivere il prezzo sulla bolla
  //const bool prinbo = cont.get_bool(LVCONDV_STPRZBOL);
  const bool prinbo = true; //sempre a true; verrà gestita a video in futuro (27/10/2009)

  //dati documento da generare
  TString4 codnum  = ini_get_string(CONFIG_DITTA, "lv", "NUM_GEN");
  TString4 tipodoc = ini_get_string(CONFIG_DITTA, "lv", "TIPODOC_GEN");
  char stato = cache().get("%TIP", tipodoc, "S2").left(1)[0];

  const TDate databpre = bpre.datadoc();
  const TDate databolla = get_date(F_TDATADOC);
  const TDate datagen(TODAY);
  TDate dadata = databpre;
  TDate adata = datagen;
  adata.addmonth();

  //se _ndoc non è inizializzato, lo inizializzo all'ultimo ndoc utilizzato
  if(_ndoc == 0)
  {
    TString query2;
    query2 << "USE DOC\n"
           << "FROM PROVV=\"D\" ANNO=" << datagen.year() << " CODNUM=\"" << codnum << "\"\n"
           << "TO PROVV=\"D\" ANNO="   << datagen.year() << " CODNUM=\"" << codnum << "\"";
    TISAM_recordset bolle(query2);
    bolle.move_last();
    _ndoc = bolle.get(DOC_NDOC).as_int();
  }

  //recupero i dati di interesse dal planning
  TString query1 = "USE LVRCONSPLAN KEY 3\n";
  query1 << "FROM CODCF=" << codcf << " CODCONT=" << codcont << " DTCONS=#DADATA\n";
  query1 << "TO CODCF="   << codcf << " CODCONT=" << codcont << " DTCONS=#ADATA\n";
  TISAM_recordset consegne(query1);
  consegne.set_var("#DADATA", ++dadata);
  consegne.set_var("#ADATA", adata);
  consegne.move_first();
  const TDate dataprco = consegne.get(LVRCONSPLAN_DTCONS).as_date();
  const int coditi = consegne.get(LVRCONSPLAN_CODITI).as_int();
  const int codaut = consegne.get(LVRCONSPLAN_CODAUT).as_int();

  //recupero il codpag e i codici banca
  TToken_string key;
  key.add('C');
  key.add(codcf);
  const TRectype& clifo = cache().get(LF_CLIFO, key);
  const TString4 codpag = clifo.get(CLI_CODPAG);
  const long codabi = clifo.get_long(CLI_CODABI);
  const long codcab = clifo.get_long(CLI_CODCAB);
   
  //reupero la causale di magazzino di testata
  const TString8 causmag = cache().get("%TIP", tipodoc, "S9");
  
  //preparo la testata del documento  
  TDocumento doc('D', kdoc.anno(), codnum, ++_ndoc);
  doc.put(DOC_TIPODOC, tipodoc);
  doc.put(DOC_STATO, stato);
  doc.put(DOC_DATADOC, databolla);
  doc.put(DOC_TIPOCF, 'C');
  doc.put(DOC_CODCF, codcf);
  doc.put(DOC_CODCONT, codcont);
  doc.put(DOC_CODPAG, codpag);
  doc.put(DOC_CODABIA, codabi);
  doc.put(DOC_CODCABA, codcab);
  doc.put(DOC_CODAG, codaut);
  doc.put(DOC_CAUSMAG, causmag);
  doc.put("DATAGEN", datagen);   //data generazione del documento 
  doc.put("DATAPRCO", dataprco); //data prevista consegna    
  doc.put("CODITI", coditi);     //codice itinerario

  for (int i = 1; i <= bpre.rows(); i++)
  {
    TRiga_documento& row = bpre[i];
    TBuono_prelievo_row rbpre(row);    

    //nella bolla ci vanno solo le righe evase e non associate
    if (!rbpre.evaso())
      continue;

    TDoc_key kbuono = rbpre.rifbcon();
    if (kbuono.full())
      continue;

    const TString80 codart = rbpre.codart();
    TString descr = rbpre.desart();

    const TRectype& rcont = cont.row(codart);    
    
    //recupero i valori delle dotazione temporanea dal magazzino del cliente
    TLocalisamfile magcli(LF_CLIFOGIAC);
    magcli.put(CLIFOGIAC_ANNOES,  datagen.year());
    magcli.put(CLIFOGIAC_TIPOCF,  'C');
    magcli.put(CLIFOGIAC_CODCF,   codcf);
    magcli.put(CLIFOGIAC_INDSPED, 0); //in realtà è da leggere dal contratto
    magcli.put(CLIFOGIAC_CODART,  codart);
    magcli.put(CLIFOGIAC_NRIGA,   1);
    //leggo il record corrispondente
    magcli.read();
    long dottmp = magcli.get_long(CLIFOGIAC_DOTTM);
    long dotod  = magcli.get_long(CLIFOGIAC_DOTOD);

    //recupero l'unità di misura principale di quest'articolo
    TToken_string key;
    key.add(codart);
    key.add(1);
    const TString4 um = cache().get(LF_UMART, key, UMART_UM);    

    //creo la nuova riga documento
    TRiga_documento& rdoc = doc.new_row("21");
    rdoc.put(RDOC_CODART, codart);
    rdoc.put(RDOC_CODARTMAG,codart);
    rdoc.put(RDOC_CHECKED,'X');
    rdoc.put(RDOC_GENERATA, true);

    if(descr.len() <= 50)
      rdoc.put(RDOC_DESCR, descr);
    else
    {
      rdoc.put(RDOC_DESCR, descr.left(50));
      rdoc.put(RDOC_DESCEST, descr.sub(50));
      rdoc.put(RDOC_DESCLUNGA, true);
    }

    rdoc.put(RDOC_QTA, rbpre.qta_consegnata());   //consegnato
    rdoc.put(RDOC_QTAGG1, rbpre.qta_ritirata());  //ritirato

    dotod += (rbpre.qta_consegnata() - rbpre.qta_ritirata());
    rdoc.put("DOTOD", dotod);    

    bool dtmp = false;
    if (datagen >= rcont.get_date(LVRCONDV_INDTTMP) && datagen <= rcont.get_date(LVRCONDV_FIDTTMP))
      dtmp = true;

    if(dtmp)
    {
      rdoc.put("DOTMP", dottmp);
      rdoc.add("DOTMP", rbpre.qta_consegnata() - rbpre.qta_ritirata());
    }
    
    rdoc.put(RDOC_CODAGG1, rbpre.causale());

    const TRectype& anamag = cache().get(LF_ANAMAG, codart);
    //gestione prezzo
    if (prinbo) 
    {
      real prezzo;
      if (cont.get_int(LVCONDV_TIPOLIS) == 0)
        prezzo = rcont.get_real(LVRCONDV_PREZZO);
      else
        prezzo = anamag.get_real(ANAMAG_COSTSTD);

      rdoc.put(RDOC_PREZZO, prezzo);
      rdoc.put(RDOC_SCONTO, rcont.get(LVRCONDV_SCONTPERC)); //sconto
    }

    rdoc.put(RDOC_UMQTA, um);
  
    //scrivo il magazzino
    TString8 magazzino;
    TString8 magazzinoc;
    
    magazzino  << ini_get_string(CONFIG_DITTA, "lv", "CODMAG") << ini_get_string(CONFIG_DITTA, "lv", "CODMAGN");
    magazzinoc << ini_get_string(CONFIG_DITTA, "lv", "CODMAG") << ini_get_string(CONFIG_DITTA, "lv", "CODMAGC");

    rdoc.put(RDOC_CODMAG,  magazzino);
    rdoc.put(RDOC_CODMAGC, magazzinoc);

    //salvo i riferimenti
    TDoc_key rifbcon(datagen.year(), codnum, _ndoc);
    rbpre.set_rifbcon(rifbcon);
  }

  //salva la bolla solo se ha almeno una riga
  int err = 1;
  if (doc.rows() > 0)
  {
    err = doc.write();
    
    if(controlla())
    {
      const TString4 stato = cache().get("%TIP", ini_get_string(CONFIG_DITTA, "lv", "TIPODOC_PRE", NULL, 0), "S2").mid(2,1);
      bpre.put(DOC_STATO, stato);
      bpre.rewrite();
    }
  }

  if (err == NOERR)
  {
    //stampa automatica
    TString80 str;
    str << "ve1 -2 " << codnum << ' ' << datagen.year() << " D " << _ndoc << " S D"; 
    TExternal_app stampa(str);
    stampa.run();
  }
  else
    warning_box(TR("Non è stato possibile generare nessun documento"));  

  //riazzero ndoc
  set(F_TNDOC, 0L, 1);

  //nascondo i campi che non mi servono
  hide(F_TCODCF);
  hide(F_TRAGSOC);
  hide(F_TBARCODE);
  hide(F_TPACCHI);
  hide(F_TQTAPACCO);
  hide(F_TQTACON);
  hide(F_TQTADACON);

  //mostro i campi che servono per la selezione del documento
  show(F_TCODNUM);
  show(F_TTPDOC);
  show(F_TDESCR);
  show(F_TCHIAVE);
  show(F_TANNO);
  show(F_TDATAPRCO);

  //disabilito i bottoni
  disable(DLG_SELECT);
  disable(DLG_PREVIEW);
  disable(DLG_ELABORA);
  disable(DLG_SAVEREC);
  disable(DLG_CANCEL);

  enable(F_TNDOC);
}

//EVADI: metodo che setta a evaso tutte le righe del documento
void TEvasione_ter_msk::evadi()
{
  FOR_EACH_ASSOC_OBJECT(_ra, obj, key, itm)
  {
    TQuantita_riga* qr = (TQuantita_riga*)itm;
    qr->set_evaso(true);
  }
}

//REGISTRA: metodo che salva il buono di prelievo così com'è
void TEvasione_ter_msk::registra()
{
  TDoc_key kdoc(get_date(F_TDATADOC).year(), ini_get_string(CONFIG_DITTA, "lv", "NUM_PRE", NULL, 0), get_long(F_TNDOC));

  TBuono_prelievo doc(kdoc);

  TDate oggi(TODAY);

  FOR_EACH_ASSOC_OBJECT(_ra, obj, key, itm)
  {
    TQuantita_riga* qr = (TQuantita_riga*)itm;
    int nriga = qr->get_nriga();

    //se nriga > 0 vuol dire che si è aggiornata una riga già esistente;
    //altrimenti significa che ho spezzato una riga
    if (nriga > 0)
    {
      TRiga_documento& row = doc[nriga];
      TBuono_prelievo_row rdoc(row);

      rdoc.set_evaso(qr->get_evaso());
      rdoc.set_qta_ritirata(qr->get_qta_rit());
      rdoc.set_qta_consegnata(qr->get_qta_con());
      rdoc.set_qta_dacons(qr->get_qta_da_con());
      rdoc.set_num_pacchi(qr->get_pacchi());
      rdoc.set_dataeva(oggi);
    }
    else
    {
      //trovo la riga con quel codart      
      TToken_string chiave(key);
      TString80 codart = chiave.get(0);

      int i;
      for(i = 1; i <= doc.rows(); i++)
      {
        TRiga_documento& row = doc[i];
        if(codart == row.get(RDOC_CODART))
          break;
      }

      //creo una copia di questa riga
      TRiga_documento& row1 = doc[i];
      TRiga_documento& row2 = doc.new_row("24");

      row2 = row1;
      TBuono_prelievo_row rdoc(row2);

      //setto le quantità corrette
      rdoc.set_evaso(qr->get_evaso());
      rdoc.set_qta_ritirata(qr->get_qta_rit());
      rdoc.set_qta_consegnata(qr->get_qta_con());
      rdoc.set_qta_dacons(qr->get_qta_da_con());
      rdoc.set_num_pacchi(qr->get_pacchi());
      rdoc.set_dataeva(oggi);
    }
  }
  doc.rewrite();
  //visto che sto evadendo tramite barcode quando salvo salvo anche tutti i pacchi associati
  //generando i movimenti di magazzino di scarico
  TLocalisamfile pacchi(LF_PACCHI);
  TLocalisamfile movi(LF_MOVMAG);

  //cerco l'ultimo numero di chiave in movmag
  TISAM_recordset mov("USE MOVMAG");  
  long nummov = 0;

  if(mov.move_last())
    nummov += mov.get(MOVMAG_NUMREG).as_int();

  const TCausale_magazzino causale((ini_get_string(CONFIG_DITTA, "lv", "CAUSCARMAG")));
  TString8 magazzino;
  magazzino  << ini_get_string(CONFIG_DITTA, "lv", "CODMAG") << ini_get_string(CONFIG_DITTA, "lv", "CODMAGP");

  TEsercizi_contabili es;    
  int annoes = es.date2esc(oggi);

  TMov_mag movmag(++nummov);
  movmag.put(MOVMAG_ANNOES, annoes);
  movmag.put(MOVMAG_DATAREG, oggi);
  movmag.put(MOVMAG_CODCAUS, causale.codice());

  FOR_EACH_ASSOC_OBJECT(_pacchi, o, codpacco, rifdoc)
  {
    TDoc_key kdoc = *(TToken_string*)rifdoc;

    TRiga_pacco rp(codpacco);
    const TString80 codart = rp.articolo();
    const long qta = rp.quantita().integer();

    //recupero l'unità di misura principale di quest'articolo
    TToken_string key;
    key.add(codart);
    key.add(1);
    const TString4 um = cache().get(LF_UMART, key, UMART_UM);      

    rp.set_rigabolla(kdoc.anno(), kdoc.codnum(), kdoc.ndoc(), 0); //SOLUZIONE MOMENTANEA PER VEDERE SE FUNZIONA TUTTO
    rp.rewrite(pacchi);

    //faccio la nuova riga del movimento di magazzino
    TRectype& rmovmag = movmag.new_row();
    rmovmag.put(RMOVMAG_CODMAG, magazzino);
    rmovmag.put(RMOVMAG_CODART, codart);

    rmovmag.put(RMOVMAG_UM, um);
    rmovmag.put(RMOVMAG_QUANT, qta);
  }
  movmag.write(movi);
}

//RIEMPI_SHEET: metodo che riempie lo sheet di riepilogo delle righe documento ancora da evadere
void TEvasione_ter_msk::riempi_sheet()
{
  TSheet_field& sheet = sfield(F_TRIGHE);
  sheet.destroy();
  
  FOR_EACH_ASSOC_OBJECT(_ra, obj, key, itm)
  {
    TToken_string chiave(key);
    TQuantita_riga& qr = *(TQuantita_riga*)itm;
    
    if(!qr.get_evaso())
    {
      TToken_string& riga = sheet.row(-1);
      riga.add(chiave.get(0), 0);
      riga.add(qr.get_qta_da_con(), 1);
      riga.add(qr.get_qta_con(), 2);      
    }
  }
  sheet.force_update();
}

//SPEZZA_RIGHE: metodo che spezza le righe documento se richiesto
void TEvasione_ter_msk::spezza_riga()
{
  const TDate oggi(TODAY);
  const TDate nulla(NULLDATE);

  FOR_EACH_ASSOC_OBJECT(_ra, obj, key, itm)
  {
    TToken_string chiave(key);
    TQuantita_riga& qr = *(TQuantita_riga*)itm;

    if((TDate)chiave.get() == oggi && !qr.get_evaso())
    {
      int qtarit = qr.get_qta_rit();
      int qtadacon = qr.get_qta_da_con();
      int qtacon = qr.get_qta_con();
      int pacchi = qr.get_pacchi();

      qr.set_evaso(true);
      qr.set_qta_da_con(qtacon);
      qr.set_qta_rit(qtacon);

      TToken_string chiave1;
      chiave1.add(chiave.get(0), 0);
      chiave1.add(nulla, 1);

      TQuantita_riga qr1;
      qr1.set_evaso(false);
      qr1.set_qta_rit(qtadacon - qtacon);
      qr1.set_qta_da_con(qtadacon - qtacon);
      qr1.set_qta_con(0);
      qr1.set_pacchi(0);

      _ra.add(chiave1, qr1);
    }
  }
}
  
//CONTROLLA: metodo che controlla se tutte le righe del buono sono evase
bool TEvasione_ter_msk::controlla()
{
  bool evaso = true;
  FOR_EACH_ASSOC_OBJECT(_ra, obj, key, itm)
  {
    TQuantita_riga* qr = (TQuantita_riga*)itm;

    if(!qr->get_evaso())
    {
      evaso = false;
      break;
    }
  }
  return evaso;
}


//EVADI_DA_TERMINALE: metodo che somma alla riga corretta un pacco (quello pistolato) e lo assegna a un cliente,
//sottraendolo dal magazzino del pulito
void TEvasione_ter_msk::evadi_da_terminale()
{
  const TString80 codpacco = get(F_TBARCODE);

  if (codpacco.full())
  {
    const TRiga_pacco rp(codpacco);

    if (rp.empty())
    {
      warning_box(TR("Il pacco non esiste a magazzino"));
      warning_box(TR("Non è stato possibile sommare il pacco a nessuna riga del buono"));
    }
    else
    {
      if (rp.rigabolla().full())
      {
        TToken_string riga = rp.rigabolla();
        int numdoc = riga.get_int(3);
        
        TString msg;
        msg << "Il pacco risulta già associato al buono numero " << numdoc;
        warning_box(msg);
        return;
      }

      const TDate oggi(TODAY);
      
      const TString80 codart = rp.articolo();
      const long qtapacco = rp.quantita().integer();

      TToken_string key;
      key.add(codart);
      key.add(oggi);

      TDoc_key kdoc(get_date(F_TDATADOC).year(), ini_get_string(CONFIG_DITTA, "lv", "NUM_PRE", NULL, 0), get_int(F_TNDOC));
      //se il pacco è già stato pistolettato lo tolgo dai pacchi da evadere, altrimenti cerco di sommarlo
      //a una riga documento esistente
      if (_pacchi.is_key(codpacco))
      {
        _pacchi.remove(codpacco);        

        if (_ra.is_key(key))
        {
          TQuantita_riga& qr = *(TQuantita_riga*)_ra.objptr(key);
          qr.add_pacchi(-1);
          qr.add_qta_con(-1 * qtapacco);

          if (qr.get_evaso())
            qr.set_evaso(false);

          set(F_TPACCHI, qr.get_pacchi());
          set(F_TQTAPACCO, qtapacco);
          set(F_TQTACON, qr.get_qta_con());
          set(F_TQTADACON, qr.get_qta_da_con());
        }
      }
      else
      {
        if (_ra.is_key(key))
        {
          TQuantita_riga& qr = *(TQuantita_riga*)_ra.objptr(key);

          if (qr.get_evaso())
          {
            if(yesno_box(TR("Si desidera sommare il pacco a una riga già evasa?")))
            {
              qr.add_pacchi();
              qr.add_qta_con(qtapacco);
            }
          }
          else
          {
            qr.add_pacchi();
            qr.add_qta_con(qtapacco);

            if(qr.get_qta_con() > qr.get_qta_da_con())
              warning_box(TR("ATTENZIONE: si sta consegnando un quantitativo maggiore al dovuto"));

            if(qr.get_qta_con() >= qr.get_qta_da_con())
              qr.set_evaso(true);
          }
          _pacchi.add(codpacco, kdoc);
          set(F_TPACCHI, qr.get_pacchi());
          set(F_TQTAPACCO, qtapacco);
          set(F_TQTACON, qr.get_qta_con());
          set(F_TQTADACON, qr.get_qta_da_con());
        }
        else
        {
          TDoc_key kdoc(get_date(F_TDATADOC).year(), ini_get_string(CONFIG_DITTA, "lv", "NUM_PRE", NULL, 0), get_long(F_TNDOC));
          TBuono_prelievo bpre(kdoc);
          const long codcf = bpre.codcf();
          const int codcont = bpre.codcont();

          TLaundry_contract cont(codcf, codcont);
          const TRectype& rcont = cont.row(rp.articolo());

          if (!rcont.empty())
          {
            TString msg;
            msg << "L'articolo " << rp.articolo() << " non è a contratto ma non presente sul buono";
            warning_box(msg);
          }            
          else
          {
            TString msg;
            msg << "L'articolo " << rp.articolo() << " non è previsto per questo cliente";
            warning_box(msg);
          }
        }
      }
    }
  }
}

//ON_FIELD_EVENT: metodo che gestisce gli eventi sui campi della maschera
bool TEvasione_ter_msk::on_field_event(TOperable_field& f, TField_event e, long jolly)
{
  //a seconda del bottone premuto esegui un metodo diverso
  switch (f.dlg())
  {    
  case DLG_SELECT:
    if (e == fe_button)
    {
      evadi();
      if (controlla())
        genera_buono();
      return false;
    }    
    break;
  case DLG_PREVIEW:
    if (e == fe_button)
    {
      hide(F_TBARCODE);
      hide(F_TPACCHI);
      hide(F_TQTAPACCO);
      hide(F_TQTACON);
      hide(F_TQTADACON);
      
      show(F_TRIGHE);

      disable(DLG_SELECT);      
      disable(DLG_ELABORA);

      riempi_sheet();
      return false;
    }
    break;
  case DLG_ELABORA:    
    if (e == fe_button)
      if (controlla())
        genera_buono();
      else
      {
        if(yesno_box(TR("ATTENZIONE: non tutte le righe sono evase. Si desidera continuare ugualmente?")))
        {
          if(yesno_box(TR("Si desidera considerare evase tutte le righe?"
                          "(in caso contrario le righe evase parzialmente verranno spezzate su due righe)")))
          {
            evadi();
            genera_buono();
          }
          else
          {
            spezza_riga();
            genera_buono();
          }
        }
        else
          send_key(K_SPACE, DLG_CANCEL);
      }
      return false;
    break;
  case DLG_CANCEL:
    if (e == fe_button && jolly == 0)
    {
      show(F_TBARCODE);
      show(F_TPACCHI);
      show(F_TQTAPACCO);
      show(F_TQTACON);
      show(F_TQTADACON);

      enable(DLG_SELECT);
      enable(DLG_ELABORA);

      hide(F_TRIGHE);

      field(F_TBARCODE).set_focus();

      _autoselect = 1;
      return false;
    }
    break;
  case DLG_SAVEREC:
    if (e == fe_button)
    {
      registra();
      return false;
    }
    break;
  case F_TCHIAVE:
    {
      if (e == fe_modify)
      {
        TString kdoc = f.get();
        int cazzone = 1;
        if (kdoc.full())
        {
          set(F_TANNO, atol(kdoc.left(4)));
          set(F_TNDOC, atol(kdoc.mid(4)));
          field(F_TNDOC).check();

          if(!precarica_righe())
            return false;

          hide(F_TCODNUM);
          hide(F_TTPDOC);
          hide(F_TDESCR);
          hide(F_TANNO);
          hide(F_TDATAPRCO);

          show(F_TCODCF);
          show(F_TRAGSOC);
          show(F_TBARCODE);
          show(F_TPACCHI);
          show(F_TQTAPACCO);
          show(F_TQTACON);
          show(F_TQTADACON);

          enable(DLG_SELECT);
          enable(DLG_PREVIEW);
          enable(DLG_ELABORA);
          enable(DLG_SAVEREC);
          enable(DLG_CANCEL);

          disable(F_TNDOC);

          _autoselect = 1;
          field(F_TBARCODE).set_focus();
          f.hide();
        }
      }
    }
    break;
  case F_TNDOC:
    {
      if (e == fe_modify)
        if (f.get_long() != 0 && get(F_TCHIAVE).empty())
        {
          field(F_TNDOC).check();

          if(!precarica_righe())
            return false;

          hide(F_TCODNUM);
          hide(F_TTPDOC);
          hide(F_TDESCR);
          hide(F_TANNO);
          hide(F_TDATAPRCO);
          hide(F_TCHIAVE);

          show(F_TCODCF);
          show(F_TRAGSOC);
          show(F_TBARCODE);
          show(F_TPACCHI);
          show(F_TQTAPACCO);
          show(F_TQTACON);
          show(F_TQTADACON);

          enable(DLG_SELECT);
          enable(DLG_PREVIEW);
          enable(DLG_ELABORA);
          enable(DLG_SAVEREC);
          enable(DLG_CANCEL);

          disable(F_TNDOC);

          _autoselect = 1;
          field(F_TBARCODE).set_focus();
        }
        else
        {
          show(F_TCHIAVE);
          show(F_TCODNUM);
          show(F_TDESCR);
          show(F_TTPDOC);
          show(F_TANNO);
          show(F_TDATAPRCO);

          hide(F_TCODCF);
          hide(F_TRAGSOC);
          hide(F_TBARCODE);
          hide(F_TPACCHI);
          hide(F_TQTAPACCO);
          hide(F_TQTACON);
          hide(F_TQTADACON);

          disable(DLG_SELECT);
          disable(DLG_PREVIEW);
          disable(DLG_ELABORA);
          disable(DLG_SAVEREC);
          disable(DLG_CANCEL);
          
          reset(F_TDATADOC);

          enable(F_TNDOC);

          _ra.destroy();
        }
    }
    break;
  case F_TBARCODE:
    {
      if (e == fe_modify && f.get().full())
      {
        _autoselect = 1;
        evadi_da_terminale();

        if (controlla())
          send_key(K_SPACE, DLG_ELABORA);
      }
    }
    break;
  default:break;
  }
  return true;
}

void TEvasione_ter_msk:: on_idle()
{
  TMask::on_idle();
  if (_autoselect >= 0 && get(F_TBARCODE).full())
  {
    reset(F_TBARCODE);
    field(F_TBARCODE).set_focus();
    _autoselect = -1;
  }
}

TEvasione_ter_msk::TEvasione_ter_msk():TAutomask("lv3400a") 
{
  //precarico i campi fissi
  set(F_TCODNUM, ini_get_string(CONFIG_DITTA, "lv", "NUM_PRE", NULL, 0));
  set(F_TTPDOC,  ini_get_string(CONFIG_DITTA, "lv", "TIPODOC_PRE", NULL, 0));

  const TRectype& tpdoc = cache().get("%NUM", ini_get_string(CONFIG_DITTA, "lv", "TIPODOC_PRE", NULL, 0));  
  set(F_TDESCR, tpdoc.get("S0"));

   _ndoc = 0;

  TDate data(TODAY);
  TEsercizi_contabili es;
  int annoes = es.date2esc(data);
  set(F_TANNO, annoes);
  
  hide(F_TCODCF);
  hide(F_TRAGSOC);  
  hide(F_TBARCODE);
  hide(F_TPACCHI);
  hide(F_TQTAPACCO);
  hide(F_TQTACON);
  hide(F_TQTADACON);
  hide(F_TRIGHE);

  disable(DLG_SELECT);
  disable(DLG_PREVIEW);
  disable(DLG_ELABORA);
  disable(DLG_SAVEREC);
  disable(DLG_CANCEL);
}

                                 /////////////////////////////////
                                 ////    TEVASIONE_TER_APP    ////
                                 /////////////////////////////////

//classe TEvasione_ter_app
class TEvasione_ter_app : public TSkeleton_application
{
  TEvasione_ter_msk*  _msk;
protected:
  virtual bool create();
  virtual bool destroy();

public:
  bool transfer();
  virtual void main_loop();  
};

//CREATE: metodo costruttore
bool TEvasione_ter_app::create()
{
  _msk = new TEvasione_ter_msk();
  open_files(LF_DOC, LF_RIGHEDOC);
  return TSkeleton_application::create();
}

//DESTROY: metodo distruttore
bool TEvasione_ter_app::destroy()
{	
  delete _msk;
  return TApplication::destroy();
}

//TRANSFER: metodo che scorre i campi nome e, se sono pieni, richiama il metodo
//ELABORA_FILE(), che effettivamente fa l'elaborazione
bool TEvasione_ter_app::transfer()
{   
  return true;
}

void TEvasione_ter_app::main_loop()
{
  while (_msk->run() == K_ENTER)
    transfer();
 }

int lv3400(int argc, char *argv[])
{
  TEvasione_ter_app a;
  a.run (argc, argv, "Evasione Buoni di Prelievo");
  return TRUE;
}