#include <applicat.h>
#include <automask.h>
#include <defmask.h>
#include <execp.h>
#include <reputils.h>
#include <reprint.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  "lv3200a.h"

                                 /////////////////////////////
                                 ////    TEVASIONE_MSK    ////
                                 /////////////////////////////

//classe TEvasione_msk
class TEvasione_msk: public TAutomask
{
  TDocumento    _buonori;

  int           _ndoc;
  int           _autoselect;

  TString4      _tpev;
  
  TAssoc_array  _pacchi;
  

protected:
  void setta_campi_data();
  void setta_campi_cliente();

  void carica_righe();
  void riordina_righe();
  void genera_documento();
  void evadi_tutto();
  void spezza_riga();
  void salva();
  void annulla_operazioni();
  bool controlla();

  void sistema_quantita();
  void sistema_pacchi();

  void evadi_da_barcode();

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

public:
  TEvasione_msk();
};


//SORT_BY_QTA_EVASA: è la rows_comapre_function, cioè la funzione che viene utilizzata
//dal metodo sort degli sheet per riordinare le righe secondo le quantità evase
static int sort_by_qta_evasa(TSheet_field& sheet, int r1, int r2)
{
  TToken_string& row1 = sheet.row(r1);
  TToken_string& row2 = sheet.row(r2);

  const int qta1 = row1.get_int(6);
  const int qta2 = row2.get_int(6);

  int dif = qta1 - qta2;

  if (dif == 0)
  {
    const TString& codart1 = row1.get(1);
    const TString& codart2 = row2.get(1);

    dif = codart1.compare(codart2);
  }  
  return dif;
}

//SORT_BY_CODART: è la rows_comapre_function, cioè la funzione che viene utilizzata
//dal metodo sort degli sheet per riordinare le righe secondo i codart e le qta evase
static int sort_by_codart(TSheet_field& sheet, int r1, int r2)
{
  TToken_string& row1 = sheet.row(r1);
  TToken_string& row2 = sheet.row(r2);

  const TString& codart1 = row1.get(1);
  const TString& codart2 = row2.get(1);

  int dif = codart1.compare(codart2);

  if (dif == 0)
  {
    const int qta1 = row1.get_int(6);
    const int qta2 = row2.get_int(6);

    dif = qta2 - qta1;
  }
  
  return dif;
}

//SETTA_CAMPI_DATA: metodo che compila tutti i campi legati alla data
void TEvasione_msk::setta_campi_data()
{
  TDate data = get_date(F_DATADOC);

  if (data.ok())
  {
    TDate primo = data;
    primo.set_day(1);
    
    TEsercizi_contabili es;  
    int annoes = es.date2esc(data);
    set(F_ANNO, annoes);

    //decodifica del giorno della settimana
    set(F_GIORNO, itow(data.wday()));  
    //settimana del mese = settimana(oggi) - settimana(primo del mese) + 1
    long tmp = data.week() - primo.week() + 1;
    TString4 settimana;
    settimana << tmp;
    set(F_SETTIMANA, settimana);
  }
  else
  {
    TString8 str = data.string();
    if (str.empty())
    {
      reset(F_GIORNO);
      reset(F_SETTIMANA);
    }
    else
      warning_box(TR("Data non valida!"));
  }
}

//SETTA_CAMPI_CLIENTE: metodo che compila tutti i campi legati al cliente
void TEvasione_msk::setta_campi_cliente()
{
  const long codcf = get_int(F_CODCF);
  const TDate data = get_date(F_DATADOC);

  if (codcf > 0)
  {
    TLaundry_contract cont(codcf, 0, data);

    //se trovo un contratto, allora scrivo il codice contratto e cerco itinerario e data di prevista consegna
    //se no avviso che non c'è neanche un contratto valido e svuoto i campi interassati
    if(!cont.empty())
    {
      set(F_CODCONT, cont.get_int(LVCONDV_CODCONT));
      
      TDate adata = data;
      adata.addmonth(1);

      TString query = "USE LVRCONSPLAN KEY 3\n";
      query << "FROM CODCF=" << get(F_CODCF) << " CODCONT=" << get(F_CODCONT) << " DTCONS=" << data << "\n";
      query << "TO CODCF="   << get(F_CODCF) << " CODCONT=" << get(F_CODCONT) << " DTCONS=" << adata   << "\n";
      TISAM_recordset consegne(query);

      if (consegne.items() >= 2)
      {
        consegne.move_to(1);
        set(F_DATAPRCO, consegne.get(LVRCONSPLAN_DTCONS).as_date());
        set(F_CODITI, consegne.get(LVRCONSPLAN_CODITI).as_int());
      }
      else
      {
        reset(F_DATAPRCO);
        reset(F_CODITI);
      }

      if (get(F_RAGSOC).empty())
      {
        TToken_string key;
        key.add('C');
        key.add(codcf);
        const TRectype& clifo = cache().get(LF_CLIFO, key);
        set(F_RAGSOC, clifo.get(CLI_RAGSOC));
        set(F_RICALT, clifo.get(CLI_RICALT));
      }
    }
    else
    {
      TString msg;
      msg << "ATTENZIONE: nessun contratto in essere per il cliente " << codcf << " alla data " << data;
      warning_box(msg);

      reset(F_CODCONT);
      reset(F_DATAPRCO);
      reset(F_CODITI);
    }
  }
  else
  {
    reset(F_RICALT);
    reset(F_RAGSOC);
    reset(F_CODCONT);
    reset(F_DATAPRCO);
    reset(F_CODITI);
  }
}

//CARICA_RIGHE: metodo che carica sullo sheet le righe di un documento selezionato
void TEvasione_msk::carica_righe()
{  
  TDoc_key kdoc(get_int(F_ANNO), get(F_CODNUM), get_long(F_NDOC));
  TBuono_prelievo doc(kdoc);

  const TString4 stato = doc.get(DOC_STATO);

  set(F_STATO, stato);
  disable(F_STATO);

  set(F_DATABOLLA, doc.get_date(DOC_DATADOC));
  set(F_DATADOC, doc.get_date(DOC_DATADOC));  setta_campi_data();
  set(F_CODCF, doc.get_long(DOC_CODCF));      setta_campi_cliente(); field(F_CODCF).set_dirty();

  _buonori = doc;
  _pacchi.destroy();

  if(doc.rows() > 0)
  {
    enable(DLG_SELECT);
    enable(DLG_PREVIEW);
    
    if(stato == "1")
      enable(DLG_ELABORA);

    enable(DLG_SAVEREC);
    enable(DLG_CANCEL);
    show(F_RIGHE);
  }

  TSheet_field& sheet = sfield(F_RIGHE);

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

    if (rdoc.qta_dacons() > 0)
    {
      TToken_string& riga =  sheet.row(-1);
      riga.add(rdoc.evaso() ? "X" : "", sheet.cid2index(S_EVASO));

      riga.add(rdoc.codart(),           sheet.cid2index(S_CODART));
      riga.add(rdoc.desart(),           sheet.cid2index(S_ARTDESCR));
      riga.add(rdoc.causale(),          sheet.cid2index(S_CAUSALE));
      riga.add(rdoc.qta_ritirata(),     sheet.cid2index(S_RITIRATO));
      riga.add(rdoc.qta_dacons(),       sheet.cid2index(S_DACONS));
      riga.add(rdoc.qta_consegnata(),   sheet.cid2index(S_CONSEGNATO));

      const TRectype& anamag = cache().get(LF_ANAMAG, rdoc.codart());
      //recupero i dati di interesse dall'anagrafica di magazzino
      const long ppconf = anamag.get_long(ANAMAG_PPCONF);
      if (ppconf > 0)
        riga.add(rdoc.num_pacchi(), sheet.cid2index(S_PACCHI));
      else
      {
        riga.add(0, sheet.cid2index(S_PACCHI));
        sheet.disable_cell(i, sheet.cid2index(S_PACCHI));
      }

      riga.add(rdoc.cong_pre(), sheet.cid2index(S_CONGPRE));
      riga.add(rdoc.cong_att(), sheet.cid2index(S_CONGATT));
      riga.add(rdoc.rifbcon(),  sheet.cid2index(S_RIFBCON));      
    }
    else
      rdoc.set_evaso(true);
  }

  doc.rewrite();
  sheet.sort(sort_by_codart);
  sheet.force_update();
}

//RIORDINA_RIGHE: metodo che riordina le righe dello sheet in base alle quota di evasione
void TEvasione_msk::riordina_righe()
{
  TSheet_field& sheet = sfield(F_RIGHE);
  sheet.sort(sort_by_qta_evasa);
  sheet.force_update();
}

//GENERA_DOCUMENTO: metodo che genera il buono di consegna partendo dal buono di ritiro
void TEvasione_msk::genera_documento()
{
  //per prima cosa salva il buono di prelievo
  salva();

  TDoc_key kdoc(get_int(F_ANNO), get(F_CODNUM), get_long(F_NDOC));
  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_DATABOLLA);
  const TDate datagen(TODAY);
  TDate dadata = databpre;
  TDate adata = datagen;
  adata.addmonth();

  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();
  }

  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();

  //recupero il codpag
  TToken_string key;
  key.add('C');
  key.add(codcf);
  const TString4 codpag = cache().get(LF_CLIFO, key, CLI_CODPAG);
   
  //reupero la cuasale di magazzino di testata
  const TString16 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_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);    

    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();
    const TString4 stato = cache().get("%TIP", ini_get_string(CONFIG_DITTA, "lv", "TIPODOC_PRE", NULL, 0), "S2").mid(1,1);
    bpre.put(DOC_STATO, stato);
    bpre.rewrite();
    set(F_STATO, stato);
  }

  if (err == NOERR)
  {
    if (yesno_box(TR("Il documento è stato generato; si desiderla stamparlo?")))
    {
      //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"));  

  reset(F_NDOC);
  send_key(K_SPACE, F_NDOC);
}

//EVADI_TUTTO: metodo che forza a "evaso" tutte le righe e lancia la generazione del buono di consegna associato
void TEvasione_msk::evadi_tutto()
{
  TSheet_field& sheet = sfield(F_RIGHE);
  const int posevaso = sheet.cid2index(S_EVASO);  
  
  FOR_EACH_SHEET_ROW(sheet, r, riga)
  {
    riga->add("X", posevaso);
  }
  genera_documento();
}

//SPEZZA_RIGA: metodo che spezza una riga del buono in due righe, una per la quota evasa e una per la quota da evadere
void TEvasione_msk::spezza_riga()
{
  TSheet_field& sheet = sfield(F_RIGHE);

  FOR_EACH_SHEET_ROW_BACK(sheet, r, riga1)
  {
    char flgev = riga1->get_char(sheet.cid2index(S_EVASO));
    if (flgev != 'X')
    {
      TToken_string& riga2 = sheet.row(-1);
      riga2 = *riga1;

      const int dacons2 = riga2.get_int(sheet.cid2index(S_RITIRATO)) - riga2.get_int(sheet.cid2index(S_CONSEGNATO));
      riga2.add(dacons2, sheet.cid2index(S_DACONS));
      riga2.add(0L, sheet.cid2index(S_CONSEGNATO));
      riga2.add(0L, sheet.cid2index(S_PACCHI));

      const int dacons1 = riga1->get_int(sheet.cid2index(S_RITIRATO)) - riga1->get_int(sheet.cid2index(S_CONSEGNATO));
      riga1->add(dacons1, sheet.cid2index(S_DACONS));
      riga1->add("X", sheet.cid2index(S_EVASO));
    }
  }
  sheet.sort(sort_by_codart);
  sheet.force_update();
}

//SALVA: metodo che salva il buono di prelievo così com'è, senza compiere altre operazioni
void TEvasione_msk::salva()
{
  TDoc_key kdoc(get_int(F_ANNO), get(F_CODNUM), get_long(F_NDOC));
  TBuono_prelievo doc(kdoc);
  TDate datadoc = doc.get_date(DOC_DATADOC);

  TLaundry_contract cont(get_long(F_CODCF), get_long(F_CODCONT));

  //nel caso avessi spezzato le righe, risrcivendole da capo mi vengono ordinate per codice
  //ATTENZIONE: devo eliminare le sole righe che sono sullo sheet, cioè quelle che hanno 
  //quantità da consegnare maggiore di zero
  for (int i = doc.rows(); i > 0; i--)
  {
    TRiga_documento& row = doc[i];
    TBuono_prelievo_row rdoc(row);

    if (rdoc.qta_dacons() > 0)
      doc.destroy_row(i, true);    
  }

  TSheet_field& sheet = sfield(F_RIGHE);
  //riordino lo sheet
  sheet.sort(sort_by_codart);
  sheet.force_update();
   
  //per ogni riga dello sheet genero una riga documento
  FOR_EACH_SHEET_ROW(sheet, r, riga)  
  {
    TRiga_documento& row = doc.new_row("24");
    TBuono_prelievo_row rdoc(row);

    const char flgev = riga->get(sheet.cid2index(S_EVASO))[0];
    bool flag;
    if (flgev == 'X')
      flag = true;
    else
      flag = false;

    const TString80 codart = riga->get(sheet.cid2index(S_CODART));

    rdoc.set_evaso(flag);
    rdoc.set_codart(codart);
    rdoc.set_desart(riga->get(sheet.cid2index(S_ARTDESCR)));
    rdoc.set_causale(riga->get(sheet.cid2index(S_CAUSALE)));
    rdoc.set_qta_ritirata(riga->get_int(sheet.cid2index(S_RITIRATO)));
    rdoc.set_qta_dacons(riga->get_int(sheet.cid2index(S_DACONS)));
    rdoc.set_qta_consegnata(riga->get_int(sheet.cid2index(S_CONSEGNATO)));
    rdoc.set_num_pacchi(riga->get_int(sheet.cid2index(S_PACCHI)));    
    rdoc.set_cong_att(riga->get_int(sheet.cid2index(S_CONGPRE)));
    rdoc.set_cong_pre(riga->get_int(sheet.cid2index(S_CONGATT)));
    rdoc.set_rifbcon(riga->get(sheet.cid2index(S_RIFBCON)));

     //recupero l'unità di misura principale di quest'articolo
    TToken_string key;
    key.add(codart);
    key.add(1);
    const TRectype& umart = cache().get(LF_UMART, key);    
    rdoc.set_um(umart.get(UMART_UM));
    
    //recupero il codiva di quest'articolo
    const TRectype& anamag = cache().get(LF_ANAMAG, codart);
    rdoc.set_codiva(anamag.get(ANAMAG_CODIVA));

    const TRectype& rcont = cont.row(codart);

    //controllo da dove devo prendere il  prezzo
    real prezzo;

    if (cont.get_int(LVCONDV_TIPOLIS) == 0)
      prezzo = rcont.get_real(LVRCONDV_PREZZO);
    else
      prezzo = anamag.get_real(ANAMAG_COSTSTD);
    rdoc.set_prezzo(prezzo);

    //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.set_mag(magazzino);
    rdoc.set_magc(magazzinoc);
  }
  doc.rewrite();

  //se sto evadendo tramite barcode quando salvo salvo anche tutti i pacchi associati
  //generando i movimenti di magazzino di scarico
  if (_tpev == "B")
  {
    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(datadoc);

    TMov_mag movmag(++nummov);
    movmag.put(MOVMAG_ANNOES, annoes);
    movmag.put(MOVMAG_DATAREG, datadoc);
    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);
  }
}

//ANNULLA_OPERAZIONI: metodo elimina tutte le quantità scritte durante l'ultima evasione
//e libera i pacchi eventualmente allocati
void TEvasione_msk::annulla_operazioni()
{
  //ANNULLA PACCHI
  _pacchi.destroy();

  //elimino lo sheet senza salvarlo
  TSheet_field& sheet = sfield(F_RIGHE);
  sheet.destroy();

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

    TToken_string& riga =  sheet.row(-1);
    riga.add(rdoc.evaso() ? "X" : "", sheet.cid2index(S_EVASO));
    riga.add(rdoc.codart(),           sheet.cid2index(S_CODART));
    riga.add(rdoc.desart(),           sheet.cid2index(S_ARTDESCR));
    riga.add(rdoc.causale(),          sheet.cid2index(S_CAUSALE));
    riga.add(rdoc.qta_ritirata(),     sheet.cid2index(S_RITIRATO));
    riga.add(rdoc.qta_dacons(),       sheet.cid2index(S_DACONS));
    riga.add(rdoc.qta_consegnata(),   sheet.cid2index(S_CONSEGNATO));

    const TRectype& anamag = cache().get(LF_ANAMAG, rdoc.codart());
    //recupero i dati di interesse dall'anagrafica di magazzino
    const long ppconf = anamag.get_long(ANAMAG_PPCONF);
    if (ppconf > 0)
      riga.add(rdoc.num_pacchi(), sheet.cid2index(S_PACCHI));
    else
    {
      riga.add(0, sheet.cid2index(S_PACCHI));
      sheet.disable_cell(i, sheet.cid2index(S_PACCHI));
    }

    riga.add(rdoc.cong_pre(),       sheet.cid2index(S_CONGPRE));
    riga.add(rdoc.cong_att(),       sheet.cid2index(S_CONGATT));
    riga.add(rdoc.rifbcon(),        sheet.cid2index(S_RIFBCON));    
  }
  sheet.force_update();
}

//CONTROLLA: metodo che controlla se tutte le righe sono evase
bool TEvasione_msk::controlla()
{
  TSheet_field& sheet = sfield(F_RIGHE);

  bool evaso = true;

  FOR_EACH_SHEET_ROW(sheet, r, row)
  {
    const char flgev = row->get(sheet.cid2index(S_EVASO))[0];
    if (flgev != 'X')
      evaso = false;
  }
  return evaso;
}

//SISTEMA_QUANTITA: metodo che mantiene allineate le quantita consegnate e il numero
//dei pacchi, moltiplicando il numero dei pacchi per i pezzi per pacco; se scrivo una quantità
//a mano ed è prevista una evasione a pacchi, allora aggiorno il numero dei pacchi
void TEvasione_msk::sistema_quantita()
{
  TMask& msk = sfield(F_RIGHE).sheet_mask();
  TString80 codart = msk.get(S_CODART);

  const TRectype& anamag = cache().get(LF_ANAMAG,codart);
  //recupero i dati di interesse dall'anagrafica di magazzino
  const long ppconf = anamag.get_long(ANAMAG_PPCONF);

  if (ppconf > 0)
  {
    int pacchi = msk.get_int(S_PACCHI);
    
    int qta_consegnata = pacchi * ppconf;    
    msk.set(S_CONSEGNATO, qta_consegnata);
  }
}

void TEvasione_msk::sistema_pacchi()
{
  TMask& msk = sfield(F_RIGHE).sheet_mask();
  TString80 codart = msk.get(S_CODART);

  const TRectype& anamag = cache().get(LF_ANAMAG,codart);
  //recupero i dati di interesse dall'anagrafica di magazzino
  const long ppconf = anamag.get_long(ANAMAG_PPCONF);

  if (ppconf > 0)
  {
    int qta_consegnata = msk.get_int(S_CONSEGNATO);
    
    int pacchi = qta_consegnata / ppconf;
    
    if (qta_consegnata % ppconf > 0)
      pacchi += 1;

    msk.set(S_PACCHI, pacchi);    
  }
}

//EVADI_DA_BARCODE: metodo che somma alla riga corretta un pacco (quello pistolato) e lo assegna a un cliente,
//sottraendolo dal magazzino del pulito
void TEvasione_msk::evadi_da_barcode()
{
  TString80 codpacco = get(F_BARCODE);

  if (codpacco.full())
  {
    const TRiga_pacco rp(codpacco);    
    const TString80 codart = rp.articolo();
    const long qtapacco = rp.quantita().integer();

    TSheet_field& sheet = sfield(F_RIGHE);

    const int pospa = sheet.cid2index(S_PACCHI);
    const int posco = sheet.cid2index(S_CONSEGNATO);
    
    //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);
      FOR_EACH_SHEET_ROW(sheet, r, riga)
      {
        const TString80 scodart = riga->get(sheet.cid2index(S_CODART));
        const char sevaso = riga->get_char(sheet.cid2index(S_EVASO));

        if (scodart == codart)
        {
          int qtadacon = riga->get_int(sheet.cid2index(S_DACONS));
          int pacchi = riga->get_int(pospa);  pacchi -= 1;
          int qtacon = riga->get_int(posco);  qtacon -= qtapacco;

          riga->add(pacchi, pospa);
          riga->add(qtacon, posco);

          if(qtacon <= qtadacon && sevaso == 'X')
            riga->add("", sheet.cid2index(S_EVASO));
        }
      }
    }
    else
    {
      TDoc_key kdoc(get_int(F_ANNO), get(F_CODNUM), get_int(F_NDOC));

      bool trovato = false;
      //cerco la prima riga non evasa di quell'articolo
      FOR_EACH_SHEET_ROW(sheet, r, riga)
      {
        const TString80 scodart = riga->get(sheet.cid2index(S_CODART));
        const char sevaso = riga->get_char(sheet.cid2index(S_EVASO));
        if (scodart == codart && sevaso != 'X')
        {
          int qtadacon = riga->get_int(sheet.cid2index(S_DACONS));
          int pacchi = riga->get_int(pospa);  pacchi += 1;
          int qtacon = riga->get_int(posco);  qtacon += qtapacco;

          riga->add(pacchi, pospa);
          riga->add(qtacon, posco);

          if (qtacon > qtadacon)
          {
            warning_box(TR("ATTENZIONE: si sta consegnando un quantitativo maggiore al dovuto"));
            riga->add('X', sheet.cid2index(S_EVASO));
          }

          if (qtacon == qtadacon)
            riga->add('X', sheet.cid2index(S_EVASO));

          trovato = true;
          _pacchi.add(codpacco, kdoc);
        }
      }

      if (!trovato)
      {
        if(yesno_box(TR("Si desidera provare a sommare il pacco a una riga già evasa?")))
        {
          FOR_EACH_SHEET_ROW(sheet, r, riga)
          {
            const TString80 scodart = riga->get(sheet.cid2index(S_CODART));
            if (scodart == codart)
            {
              int pacchi = riga->get_int(pospa);  pacchi += 1;
              int qtacon = riga->get_int(posco);  qtacon += qtapacco;

              riga->add(pacchi, pospa);
              riga->add(qtacon, posco);

              trovato = true;            
              _pacchi.add(codpacco, kdoc);
            }
          }
        }
      }

      if (!trovato)
        warning_box(TR("Non è stato possibile sommare il pacco a nessuna riga del buono"));
    }
  }
}

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

//ON_FIELD_EVENT: metodo che gestisce gli eventi sui campi della maschera
bool TEvasione_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_tutto();
    }
    break;
  case DLG_PREVIEW:
    {
      riordina_righe();
    }
    break;
  case DLG_ELABORA:
    {
      if (e == fe_button)
        if (controlla())
          genera_documento();
        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_tutto();
            else
            {
              spezza_riga();
              genera_documento();
            }
          }
          else
            riordina_righe();
        }
    }
    break;
  case DLG_SAVEREC:
    {
      if (e == fe_button)
        salva();
    }
    break;
  case DLG_CANCEL:
    {
      if (e ==  fe_button && jolly == 0)
      {
        annulla_operazioni();
        return false;
      }
    }
    break;
  case F_NDOC:    
    {
      if (e == fe_modify)
        if (f.get_long() > 0)
          carica_righe();        
        else
        {
          sfield(F_RIGHE).destroy();
          disable(DLG_SELECT);
          disable(DLG_PREVIEW);
          disable(DLG_ELABORA);
          disable(DLG_SAVEREC);
          disable(DLG_CANCEL);
          reset(F_STATO);
          reset(F_DATADOC);  setta_campi_data();
          reset(F_CODCF);    setta_campi_cliente();
          hide(F_RIGHE);
        }         
    }
    break;
  case F_DATADOC:
    {
      if (e == fe_modify)
        setta_campi_data();      
    }
    break;
  case F_CODCF:
    {
      if (e == fe_modify)
        setta_campi_cliente();
    }
    break;
  case F_BARCODE:
    {
      if (e == fe_modify && f.get().full())
      {
        _autoselect = 1;
        evadi_da_barcode();
        sfield(F_RIGHE).force_update();

        if (controlla())
          send_key(K_SPACE, DLG_ELABORA);        
      }
    }
    break;
  case S_CONSEGNATO:
    {
      if (e == fe_modify)
      {
        TSheet_field& sheet = sfield(F_RIGHE);
        TMask& msk = sheet.sheet_mask();
        //la riga risulta evasa se la quantità consegnata è maggiore o uguale alla quantità da consegnare
        if(msk.get_long(S_CONSEGNATO) > msk.get_long(S_DACONS))
        {
          warning_box(TR("ATTENZIONE: si sta consegnando un quantitativo maggiore al dovuto"));
          msk.set(S_EVASO, "X");
          TToken_string& riga = sheet.row(sheet.selected());
          riga.add("X", sheet.cid2index(S_EVASO));
        }
        else if (msk.get_long(S_CONSEGNATO) == msk.get_long(S_DACONS))
        {
          msk.set(S_EVASO, "X");
          TToken_string& riga = sheet.row(sheet.selected());
          riga.add("X", sheet.cid2index(S_EVASO));
        }
          
        sistema_pacchi();

        if (controlla())
          send_key(K_SPACE, DLG_ELABORA, &f);
      }
    }
    break;
  case S_PACCHI:
    {
      if (e == fe_modify)
        sistema_quantita();
    }
    break;
  default:break;
  }

  return true;
}

//metodo costruttore che precarica i campi di interesse sulla maschera
TEvasione_msk::TEvasione_msk():TAutomask("lv3200a") 
{
  //precarico i campi fissi
  set(F_CODNUM, ini_get_string(CONFIG_DITTA, "lv", "NUM_PRE", NULL, 0));
  set(F_TPDOC,  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_DESCR, tpdoc.get("S0"));

  TDate data(TODAY);
  TEsercizi_contabili es;
  int annoes = es.date2esc(data);
  set(F_ANNO, annoes);

  _tpev = main_app().argv(2);

  if (_tpev == "B")
  {
    _autoselect = 1;
    show(F_BARCODE);
  }
  else
  {
    _autoselect = -1;
    hide(F_BARCODE);
  }

  hide(F_RIGHE);
  disable(DLG_SELECT);
  disable(DLG_PREVIEW);
  disable(DLG_ELABORA);
  disable(DLG_SAVEREC);
  disable(DLG_CANCEL);

  _ndoc = 0;
}

                                 /////////////////////////////
                                 ////    TEVASIONE_APP    ////
                                 /////////////////////////////

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

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

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

//DESTROY: metodo distruttore
bool TEvasione_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_app::transfer()
{   
  return true;
}

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

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