#ifndef __VELIB_H 
#define __VELIB_H

#ifndef __RELATION_H
#include <relation.h>
#endif

#ifndef __RECARRAY_H
#include <recarray.h>
#endif

#ifndef __VARREC_H
#include <varrec.h>
#endif

#ifndef __VARMASK_H
#include <varmask.h>
#endif

#ifndef __MULTIREC_H
#include <multirec.h>
#endif

#ifndef __CLIFOR_H
#include "clifor.h"
#endif
                    
#ifndef __CGPAGAME_H
#include "../cg/cgpagame.h"
#endif
                    
#define RIGA_MERCE 'M'
#define RIGA_SPESEDOC 'S'
#define RIGA_PRESTAZIONI 'P'
#define RIGA_SCONTI 'C'
#define RIGA_OMAGGI 'O'
#define RIGA_DESCRIZIONI 'D'
#define MAX_TIPI_DOC 10

class TDocumento;
class TRiga_documento;
class TCond_vendita;
class TIVA;

// velib01
real lordo2netto(real& lordo, const TString& codiva, int ndec);
inline real lordo2netto(real& lordo, const TString& codiva, bool is_valuta = FALSE) { return lordo2netto(lordo, codiva, is_valuta ? 3 : 0);}
real netto2lordo(const real& netto, const TString& codiva, int ndec);
inline real netto2lordo(const real& netto, const TString& codiva, bool is_valuta = FALSE) { return netto2lordo(netto, codiva, is_valuta ? 3 : 0);}
real lordo2netto(real& lordo, const real& iva, int ndec);
inline real lordo2netto(real& lordo, const real& iva, bool is_valuta = FALSE) {return lordo2netto(lordo, iva, is_valuta ? 3 : 0); }
real netto2lordo(const real& netto, const real& iva, int ndec);
inline real netto2lordo(const real& netto, const real& iva, bool is_valuta = FALSE) { return netto2lordo(netto, iva, is_valuta ? 3 : 0); }
real prezzo_scontato(const real& prezzo, const char * sconto);
real iva(real imponibile, const TIVA & codiva,int ndec);   

bool ora_hndl(TMask_field& field, KEY key);
bool codcli_hndl(TMask_field& field, KEY key);
bool dummy_hndl(TMask_field& field, KEY key);
bool condpag_hndl(TMask_field& field, KEY key);
bool note_hndl(TMask_field& field, KEY key);
bool data_hndl(TMask_field& field, KEY key);

class TDocumento_variable_field : public TVariable_field
{                                           
  bool _dirty;
  
  public:
// @cmember segnala che il campo deve essere ricalcolato
  virtual bool dirty() const { return _dirty;}
// @cmember assegna lo stato di campo da ricalcolare
  virtual void set_dirty(bool on = TRUE) { _dirty = on;}

// @ cmember Costruttore con una espressione di calcolo  
  TDocumento_variable_field(const char * name, const char * expr = "", TTypeexp type = _strexpr)
                          : TVariable_field(name, expr, type), _dirty(TRUE) {}
// @ cmember Costruttore con una funzione
  TDocumento_variable_field(const char * name, VIRTUAL_GET_FUNCTION getfunc)
                          : TVariable_field(name, getfunc), _dirty(TRUE) {}
// @ cmember Costruttore con una espressione di calcolo  
  TDocumento_variable_field(const char * name, TExpression * expr, TTypeexp type = _strexpr)
                          : TVariable_field(name, expr, type), _dirty(TRUE) {}
// @ cmember Costruttore con un variable_field 
  TDocumento_variable_field(const TVariable_field & f) : TVariable_field(f), _dirty(TRUE) {}
// @ cmember Distruttore  
  ~TDocumento_variable_field() {}
};
            
class TSpesa_prest : public TRectype  // velib01
{                    

protected:
  int read(const char* codice);

public:
  TObject* dup() const { return new TSpesa_prest(codice()); }

public:       
  const TString& codice() const { return get("CODTAB");}  
  const TString& descrizione() const { return get("S0"); } 
  const TString& field_perc() const { return get("S5"); }  
  const TString & um() const { return get("S7"); }
  const TString& cod_iva() const { return get("S3"); }
  real prezzo() const { return get_real("R0"); }
  real qta() const { return get_real("R1"); }
  char tipo() const { return get_char("S6"); }
  const TString & tipo_riga() const { return get("S8"); }
  char genere() const { return get("COD") == "SPP" ? 'S' : 'P'; }

  TSpesa_prest(const char* codice = NULL, char tipo = 'S');
  TSpesa_prest(const TRectype& rec);
  virtual ~TSpesa_prest() {}
};

class TIVA : public TRectype  // velib01
{                    

protected:
  int read(const char* codice);

public:
  TObject* dup() const { return new TIVA(codice()); }

public:       
  const TString& codice() const { return get("CODTAB");}  
  const TString& descrizione() const { return get("S0"); } 
  const real aliquota() const { return get_real("R0"); } 
  const TString& tipo() const { return get("S1"); } 

  TIVA(const char* codice = NULL);
  TIVA(const TRectype& rec);
  virtual ~TIVA() {}
};

class TExpr_documento : public TExpression  // velib01
{     
  TDocumento * _doc; 
  TRiga_documento * _row;
  
protected:                       
  virtual void evaluate_user_func(int index, int nparms, TEval_stack & stack, TTypeexp type) const;
  virtual int parse_user_func(const char * name, int nparms) const;

public:            
  // @cmember Duplica l'espressione
  virtual TObject* dup() const;
  // @cmember Assegna il documento corrente
  void set_doc(TDocumento * doc) { _doc = doc; }
  // @cmember Assegna il documento corrente
  void set_row(TRiga_documento * row) { _row = row; }
  // @cmember Costruttore (assegna l'estressione e il suo tipo)
  TExpr_documento(const char* expression, TTypeexp type = _numexpr,
                  TDocumento * doc = NULL, TRiga_documento * row = NULL);
  // @cmember Costruttore (assegna il tipo dell'istruzione) 
  TExpr_documento(TTypeexp type = _numexpr,
                  TDocumento * doc = NULL, TRiga_documento * row = NULL)
                 : TExpression(type), _doc(doc), _row(row) {}
  // @cmember Costruttore di copia
  TExpr_documento(const TExpr_documento & expr)
                 : TExpression(expr), _doc(expr._doc), _row(expr._row) {}
  // @cmember Distruttore
  virtual ~TExpr_documento() {}
};

enum TTipo_formula { _documento, _riga };

class TFormula_documento : public TRectype  // velib01
{               
  TString16       _tab;
  TExpr_documento * _expr;
  
protected:
  int read(const char* codice, const char* expr = NULL, bool numexpr = TRUE);

public:
  TObject* dup() const { return new TFormula_documento(_tab == "%FRD" ? _documento : _riga, codice(), NULL, TRUE); }

public:       
  const TString& codice() const { return get("CODTAB");}  
  const TString& name() const { return codice();}
  TExpr_documento * expr() const { return _expr ? new TExpr_documento(*_expr) : NULL;}
  
  const TString& descrizione() const { return get("S0"); } 
  const TString& expr_string() const { return get("S1"); }
  TTypeexp expr_type() const { return get_bool("B0") ? _numexpr : _strexpr;}
  
  TFormula_documento(TTipo_formula tipo = _documento, const char* codice = NULL, const char* expr = NULL, bool numexpr = TRUE);
  TFormula_documento(const TRectype& rec);
  virtual ~TFormula_documento();
};

class TTipo_documento : public TRectype  // velib03
{              
  enum { _altro, _fattura, _bolla, _ordine};
  
  static TAssoc_array _formule_documento;
  TToken_string _formule;
  TString16 _imponibile;
  TString16 _imposta;
  TString16 _totale;
  TString16 _totale_netto;
  TString16 _basesconto; 
  TString16 _spese;
        
protected:     
  void read_formule();
  int read(const char* tipodoc);

public:
  TObject* dup() const { return new TTipo_documento(codice()); }

public:       
  const TString& profile_name() const { return get("S4");}
  const TString& mask_name() const { return get("S4");}
  const TString& causale() const { return get("S6"); } 
  int tipo() const { return get_int("I1"); }
  const TString& codice() const { return get("CODTAB");}  
  
  bool is_generic() const { return tipo() == _altro; }
  bool is_fattura() const { return tipo() == _fattura; }
  bool is_bolla() const { return tipo() == _bolla; }
  bool is_ordine() const { return tipo() == _ordine; }
  
  const TString & descrizione() const { return get("S0"); } 
  const TString & riferimento() const { return get("S1"); }
  const TString & imponibile() const { return _imponibile;}  
  const TString & imposta() const { return _imposta;}  
  const TString & totale_doc() const { return _totale;}  
  const TString & totale_netto() const { return _totale_netto; }
  const TString & basesconto() const { return _basesconto;}  
  const TString & spese() const { return _spese;}  
  bool mov_mag() const { return get_bool("B1"); }
  const TString & stato_mov_iniziale() const {return get("S7"); }
  const TString & stato_mov_finale() const {return get("S8"); }
  const TString & caus_mov() const {return get("S9"); } 
  bool stato_with_mov_mag(const TString & stato) const;
  
  TFormula_documento * first_formula() { return succ_formula(TRUE); }
  TFormula_documento * succ_formula(bool restart = FALSE);

  const int ncopie() const { return get_int("I0"); }
  bool spese_aut() const { return get_bool("B0"); }
  
  TTipo_documento(const char* tipodoc = NULL);
  TTipo_documento(const TRectype& rec);
  virtual ~TTipo_documento();
};
          
class TTipo_riga_documento : public TRectype  // velib02
{                    

  static TAssoc_array _formule_riga;
  TToken_string _formule;
  TString16 _name;
  TString16 _imponibile;
  TString16 _imposta;
  TVariable_mask * _mask;

protected:
  void read_formule();
  int read(const char* tiporig);

public:
  TObject* dup() const { return new TTipo_riga_documento(codice()); }

public:       
  const TString& profile_name() const { return _name;}
  const TString& mask_name() const { return profile_name();}
  const TString& codice() const { return get("CODTAB");}  
  bool mask_loaded() const { return _mask != NULL; }
  TVariable_mask * mask(); 
    
  const TString& descrizione() const { return get("S0"); } 
  char tipo() const { return get_char("S7"); }
  const TString& imponibile() const { return _imponibile;}  
  const TString& imposta() const { return _imposta;}  

  TFormula_documento * first_formula() { return succ_formula(TRUE); }
  TFormula_documento * succ_formula(bool restart = FALSE);
  
  TTipo_riga_documento(const char* tiporig = NULL);
  TTipo_riga_documento(const TRectype& rec);
  virtual ~TTipo_riga_documento();
};


class TRiga_documento : public TAuto_variable_rectype  // velib02
{
  TDocumento * _doc; 
  static TAssoc_array _tipi;
  static TAssoc_array _spese;
  static TAssoc_array _ive;  
  bool _iva_calc;


protected:  
   // @cmember Setta il contenuto del campo <p fieldname> (non tipizzata)
  virtual void put_str(const char* fieldname, const char* val);

protected:
  TObject* dup() const { return new TRiga_documento(*this); }
  
public:  
  void dirty_fields(bool   dirty_document = TRUE); 
  bool doc_dependent() const;
  int numero() const { return get_int("NRIGA");}
  void set_numero(int numero) { put("NRIGA", numero);}
  bool is_generata() const { return get_bool("GENERATA");}
  void generata(bool on = TRUE) { put("GENERATA", on);}
  bool is_merce() const { return tipo().tipo() == 'M';}
  bool is_spese() const { return tipo().tipo() == 'S';}
  bool is_prestazione() const { return tipo().tipo() == 'P';}
  bool is_sconto() const {return tipo().tipo() ==  'C';}
  bool is_omaggio() const { return tipo().tipo() == 'O';}
  bool is_descrizione() const { return tipo().tipo() == 'D';}
  bool is_articolo() const; 
  bool is_checked() const { return get_bool("CHECKED");}
  void checked(bool on = TRUE) { put("CHECKED", (bool) on);}
  void unchecked() { checked(FALSE);}
  // @cmember Assegna il documento corrente
  void set_doc(TDocumento * doc) { _doc = doc; }
  const TDocumento & doc() const { CHECK(_doc, "Documento nullo"); return *_doc;}

  virtual void zero(const char * fieldname);
  virtual void zero(char c = '\0');
  // row -> sheet
  void autoload( TSheet_field& f);
  // sheet -> row
  void autosave( TSheet_field& f);

  const TTipo_riga_documento & tipo() const;
  const TSpesa_prest & spesa() const;
  static const TIVA & iva(const char * codice);
  const TIVA & iva() const {const TString16 cod(get("CODIVA")); return iva(cod);}
  
  const bool tipo_valido() const { return get("TIPORIGA").not_empty(); }
  void set_tipo(const char * tipo) { put("TIPORIGA", tipo);}
  bool sola_descrizione() const;
  void forza_sola_descrizione();
  
  virtual TRectype & operator =(const TRectype & r); 
  virtual TRectype & operator =(const char * r); 
  
  bool raggruppabile(const TRiga_documento& r, TToken_string& campi) const;
  TRiga_documento& operator +=(const TRiga_documento& r);
  
  void reset_fields(TAuto_variable_rectype & rec) { rec.remove_field(); }
  void set_fields(TAuto_variable_rectype & rec);

  real prezzo(bool scontato, bool lordo, int ndec) const ;
  real importo(bool scontato , bool lordo, int ndec) const ;   
  real iva(int ndec) const;
  real imponibile() const; 
  real imposta(bool round = TRUE) const;
  
  TRiga_documento(TDocumento* doc, const char * tipo = NULL);
  TRiga_documento(const TRiga_documento& rec, TDocumento* doc,
                  const char * tipo = NULL);
  virtual ~TRiga_documento() {}
};

enum TTipo_importo { _lordo, _netto, _imposta };

class TDocumento : public TAuto_variable_rectype  // velib03
{               
  TRecfield *_tipocf;
  TRecfield *_codcf; 
  TRecfield *_cod_occas; 
  static TAssoc_array _tipi;
  int _liv_len[4];

  TRecord_array _rows;  // Array di TRectype per le righe documenti di vendita.
  bool _nuovo;

  TRelation * _rel;
  TCond_vendita * _condv;
  TCli_for _cli_for;
  TOccasionale _occas;
  TPagamento _pag;  
  TRiga_documento * _sconto; // Riga per lo sconto di testata
  TRiga_documento * _esenzione; // Riga per l' esenzione iva

protected:  
  TRiga_documento & row(int index);
  long get_next_key(char provv, int anno, const char* codnum) const;
  virtual void put_str(const char* fieldname, const char* val);
  long renum(long numdoc = 0);  
  void set_riga_sconto();
  void set_riga_esenzione();
  int write_rewrite(TBaseisamfile & f, bool re) const;

public:
  void dirty_fields();
  const TAuto_variable_rectype& head() const { return *this; } // Ritorna la testata del documento
  TAuto_variable_rectype& head() { return *this; } // Ritorna la testata del documento

  TCond_vendita & condv() const {CHECK(_condv, "Condizioni di vendita nulle"); return *_condv;}
  TCli_for & clifor() const;
  TOccasionale & occas() const;
  TRelation & get_relation() const {CHECK(_rel, "Relazione nulla"); return *_rel;}
  void set_condv(TCond_vendita * condv) { _condv = condv; }
  void set_relation(TRelation * rel) { _rel = rel; }
    
  virtual TDocumento & operator =(const TDocumento & d); 
  virtual TRectype & operator =(const TRectype & r); 
  virtual TRectype & operator =(const char * r); 
  virtual void zero(const char * fieldname);
  virtual void zero(char c = '\0');
  
  int physical_rows() const { return  _rows.rows(); } 
  int rows() const { return physical_rows() + ((_sconto != NULL) ? 1 : 0) + ((_esenzione != NULL) ? 1 : 0); } 
  const TRiga_documento& operator[](int index) const { return (const TRiga_documento&)((TDocumento *)this)->row(index); }
  TRiga_documento& operator[](int index) { return (TRiga_documento&)row(index); } 
  
  TRiga_documento& insert_row(int row, const char *tipo = NULL);
  TRiga_documento& new_row(const char *tipo = NULL);
  bool destroy_row(int n, bool pack = FALSE) { return _rows.destroy_row(n, pack); }
  void destroy_rows() { _rows.destroy_rows(); } 
  virtual int read(TBaseisamfile& f, word op = _isequal, word lockop = _nolock);
  virtual int write(TBaseisamfile& f) const { return write_rewrite(f, FALSE); }
  virtual int rewrite(TBaseisamfile& f) const { return write_rewrite(f, TRUE); }
  virtual int remove(TBaseisamfile& f) const;         

  int read(char provv, int anno, const char* codnum, long numdoc, word op = _isequal, word lockop = _nolock);
  int read(const TRectype& rec, word op = _isequal, word lockop = _nolock) { *this = rec; return read(op, lockop); }
  int read(word op = _isequal, word lockop = _nolock) { TLocalisamfile f(LF_DOC); return read(f, op, lockop);}
  
  int write(bool re = FALSE) const { TLocalisamfile f(LF_DOC); return write_rewrite(f, re);}
  int rewrite() const { return write(TRUE); }
  int remove() const { TLocalisamfile f(LF_DOC); return remove(f);}

  char tipo_numerazione() const { return get_char("PROVV"); }
  int anno() const { return get_int("ANNO"); }
  const TString& numerazione() { return get("CODNUM"); }
  long numero() const { return get_long("NDOC"); }
  TDate data() const { return get_date("DATADOC"); }
  const bool in_valuta() const;
  const TString& valuta() const { return get("CODVAL"); }
  const real cambio() const { return get_real("CAMBIO"); }    
  bool tipo_valido() const { return get("TIPODOC").not_empty(); }
  const TTipo_documento& tipo() const;                  
  void set_tipo(const char * tipo) { head().put("TIPODOC", tipo);}
  void set_liv_giac_len(int liv, int len) { _liv_len[liv - 1] = len;}
  int liv_giac_len(int liv) const { return _liv_len[liv - 1];}
  
  char stato() const { return get_char("STATO"); }
  void stato(char s) { put("STATO", s); }
  
  bool raggruppabile() const { return get_bool("RAGGR"); }
  bool raggruppabile(const TDocumento& doc, TToken_string& campi) const;
  
  char tipocf() const {return *(const char *) (*_tipocf);}
  long codcf() const {return (long) *_codcf;}
  const char * cod_occas() const { return (const char *) *_cod_occas; }
  static void set_key(TRectype& rec, char provv, int anno, const char* codnum, long numdoc);
  static void copy_data(TRectype& dst, const TRectype& src);
  void copy_contents(const TDocumento & src);
  
  void reset_fields(TAuto_variable_rectype & rec) { rec.remove_field(); }
  void set_fields(TAuto_variable_rectype & rec);


  real spese_incasso(real & imp, int ndec, TTipo_importo netto = _lordo) const ;
  real bolli(real & imp, int ndec, TTipo_importo netto = _lordo) const ;
  real descrizione() const;
  real riferimento() const;
  real imponibile(bool spese = FALSE, int ndec = 100) const;
  real imposta(bool spese = FALSE, int ndec = 100) const;
  real totale_doc() const;
  real totale_netto() const;
  real basesconto() const;
  real spese() const;
  
  TPagamento & pagamento();
  
  void update_spese_aut(TString_array & spese, bool preserve_old = FALSE, TSheet_field * sh = NULL);
  
  bool is_generic() const { return tipo_valido() && tipo().is_generic(); }
  bool is_fattura() const { return tipo_valido() && tipo().is_fattura(); }
  bool is_bolla() const { return tipo_valido() && tipo().is_bolla(); }
  bool is_ordine() const { return tipo_valido() && tipo().is_ordine(); }
  
  
  TDocumento ();
  TDocumento(char provv, int anno, const char* codnum, long numdoc, 
             TCond_vendita * condv = NULL, TRelation * rel = NULL);
  TDocumento(const TRectype& doc, TCond_vendita * condv = NULL,
             TRelation * rel = NULL);
  virtual ~TDocumento();
 };

class TDocumento_mask : public TVariable_mask  // velib06
{
  int _progs_page;  // pagina in cui cominciano i progressivi
  int _last_prog;   // numero dell'ultimo progressivo
  TDocumento * _doc; // documento                    

protected:
  virtual void next_page(int p);
  void sconto_testa2mask( TCli_for & c, TConfig & ditta );
  void spese2mask(TCli_for & c);

public:
  virtual bool on_key(KEY key);
  TDocumento & doc() const {CHECK(_doc, "Documento nullo"); return *_doc;}
  TCond_vendita & condv() const {CHECK(_doc, "Documento nullo"); return _doc->condv();}
  TRelation & get_relation() const {CHECK(_doc, "Documento nullo"); return _doc->get_relation();}
  void cli2mask( TCli_for & c, TOccasionale & o, TConfig & ditta);
  void occ2mask(TOccasionale & o);

  TDocumento_mask(const char* name, TDocumento * _doc, int num = 0, int max = MAX_PAGES);
  virtual ~TDocumento_mask() { }
};

class TLista_documenti : public TObject  // velib04
{ 
  TArray _documenti;
  
protected:  
  const TDocumento& doc(int n) const { return (const TDocumento&)_documenti[n]; }
  TDate num2date(char provv, int anno, const char* codnum, long num) const;

public:
  int read(char provv, char tipo, long clifo, int anno, 
           TToken_string& tipidoc, TToken_string& statidoc,
           const TDate& dd, const TDate& ad, 
           const char* codnum = "", long dn = 0L, long an = 0L);
  int write(bool re = FALSE) const;
  int rewrite() const { return write(TRUE); }
  
  int add(TDocumento* doc) { return _documenti.add(doc); }
  
  const TDocumento& operator[] (int n) const { return doc(n); }
  TDocumento& operator[] (int n) { return (TDocumento&)_documenti[n]; }
  int items() const { return _documenti.items(); }

  TLista_documenti() { }
  virtual ~TLista_documenti() { }
};

class TLista_clifo : public TObject  // velib04
{                
  class TClifo : public TObject
  { 
    long _codice;
    long _agente;
    long _zona;
    
  protected:
    void zero() { _codice = _agente = _zona = 0L; }  
    void init(const TRectype& rec, const TRectype& ven); 
    bool read(char tipo, long cod);
  
  public: // TObject
    virtual bool ok() const { return _codice > 0; }
  
  public:     
    long codice() const { return _codice; }
    long agente() const { return _agente; }
    long zona() const { return _zona; }
  
    TClifo() { zero(); }
    TClifo(char tipo, long cod) { read(tipo, cod); }
    TClifo(const TRectype& rec, const TRectype& ven) { init(rec, ven); }
    TClifo(const TRectype& rec);
    virtual ~TClifo() { }
  };

  TArray _clifo;
  
protected:  
  virtual char tipo() const pure;
  const TClifo& clifo(int n) const { return (TClifo&)_clifo[n]; }
  
  static int sort_by_code(const TObject** o1, const TObject** o2);
  static int sort_by_agent(const TObject** o1, const TObject** o2);
  static int sort_by_zone(const TObject** o1, const TObject** o2);

public:
  int ordina_per_codice();
  int ordina_per_agente();
  int ordina_per_zona();
  
  int leggi(long dc, long ac, long da = 0, long aa = 0, long dz = 0, long az = 0);
  
  long operator[] (int n) const { return clifo(n).codice(); }
  int items() const { return _clifo.items(); }
  int find(long cod) const;
  int add(long cod);

  TLista_clifo() { }
  virtual ~TLista_clifo() { }
};

class TLista_clienti : public TLista_clifo 
{
protected:
  virtual char tipo() const { return 'C'; }
};

class TLista_fornitori : public TLista_clifo 
{
protected:
  virtual char tipo() const { return 'F'; }
};
     
enum TTipo_elaborazione {_esterna, _consegna_ordini, _fatturazione_bolle, _contabilizzazione,  _copia_documento, _generazione_effetti };

class TElaborazione : public TRectype // velib04
{ 
protected:
  int read(const char* cod);

public:
  const TString& codice() const { return get("CODTAB"); }
  const TTipo_elaborazione tipo() const { return (TTipo_elaborazione) get_int("I0"); } 

  bool doc_uguale(int u) const  { return get("S1")[u] == 'X'; }
  bool riga_uguale(int u) const { return get("S1")[40+u] == 'X'; }
  bool raggruppa_righe() const      { return get_bool("B0"); }
  bool gestione_riferimenti() const { return get_bool("B1"); }
  bool riferimenti_in_testa() const { return get_bool("B2"); }
  bool ignora_descrizioni() const   { return get_bool("B3"); }
  bool interattivo() const   { return get_bool("B5"); }
  bool insert_mode() const   { return get_bool("B6"); }
  
  const TString& tipo_iniziale(int i) const { return get("S8").mid(i*4, 4); }
  const char stato_iniziale(int i) const { return get("S9")[i]; }
  const TString& tipo_finale() const { return get("S8"); }
  const TString& stato_finale() const { return get("S9"); }
  
  char tipo_numerazione() const { return get_bool("B4") ? 'P' : 'D'; }
  const TString& codice_numerazione_finale() const { return get("S6"); }
  const TString & applicazione_esterna() const { return get("S5"); }
  
  virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
                       const TDate& data_elab) pure;

  TElaborazione(const char* cod);
  TElaborazione(const TRectype& rec) : TRectype(rec) { }
  virtual ~TElaborazione() { }
};

class TEsterna : public TElaborazione  // velib04
{ 
public:
  virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
                       const TDate& data_elab);

  TEsterna(const char* cod);
  TEsterna(const TRectype& rec) : TElaborazione(rec) { }
  virtual ~TEsterna() { }
};

class TConsegna_ordini : public TElaborazione  // velib05
{ 
public:
  virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
                       const TDate& data_elab);

  TConsegna_ordini(const char* cod);
  TConsegna_ordini(const TRectype& rec) : TElaborazione(rec) { }
  virtual ~TConsegna_ordini() { }
};

class TFatturazione_bolle : public TElaborazione  // velib04
{ 
  TToken_string _cod_desc;

public:
  virtual bool raggruppa(TDocumento& din, TDocumento& dout);
  virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
                       const TDate& data_elab);
                       
  void tipi_validi(TToken_string& tipi) const;                     
  void stati_validi(TToken_string& stati) const;                     
  
  TFatturazione_bolle(const char* cod);
  TFatturazione_bolle(const TRectype& rec) : TElaborazione(rec) { }
  virtual ~TFatturazione_bolle() { }
};

class TContabilizzazione : public TElaborazione  // velib04
{ 
public:
  virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
                       const TDate& data_elab);

  TContabilizzazione(const char* cod);
  TContabilizzazione(const TRectype& rec) : TElaborazione(rec) { }
  virtual ~TContabilizzazione() { }
};

class TCopia_documento : public TElaborazione  // velib04
{ 
public:
  virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
                       const TDate& data_elab);

  TCopia_documento(const char* cod);
  TCopia_documento(const TRectype& rec) : TElaborazione(rec) { }
  virtual ~TCopia_documento() { }
};


class TGenerazione_effetti : public TElaborazione  // velib04
{ 
public:
  virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
                       const TDate& data_elab);

  TGenerazione_effetti(const char* cod);
  TGenerazione_effetti(const TRectype& rec) : TElaborazione(rec) { }
  virtual ~TGenerazione_effetti() { }
};

class TLista_elaborazioni : public TObject  // velib04
{    
  TAssoc_array * _elab;            
  
protected:
  void read();
    
public:                                     
  TElaborazione & operator [](const char * key) const;
  int select(TString_array & result, bool interattivo, bool insert_mode, const char * tipo_iniziale = NULL, const char * stato_iniziale = NULL, const char * tipo_finale = NULL, const char * stato_finale = NULL);
  void update(); 
  TLista_elaborazioni() : _elab(NULL) {}
  virtual ~TLista_elaborazioni();
};

struct dec_parm {
  int pri_lit,
      pri_val, 
      qta_lit, 
      qta_val,  // si lo so non ha senso, ma lo faccio lo stesso
      imp_lit, 
      imp_val;
      // add other groups here
};
       
class TCodice_numerazione : public TRectype
{
  int _status;
public:
  TObject* dup() const { return new TCodice_numerazione(codice()); }

public:
  int read(const char * cod);
  const TString& codice() const { return get("CODTAB"); }
  const TString& descrizione() const { return get("S0"); }
  const TString& prefisso() const { return get("S6"); }
  const TString& postfisso() const { return get("S7"); }
//  const bool manual_num() const { return get_bool("B0"); }
  const bool num_provv() const { return get_bool("B0"); }
  const bool auto_num() const { return get_bool("B1"); }
//  const TString& tipo_doc1() { return get("S2").mid(0,4);}
//  const TString& tipo_doc2() { return get("S2").mid(4,4);}
//  const TString& tipo_doc3() { return get("S2").mid(8,4);}
//  const TString& tipo_doc4() { return get("S2").mid(12,4);}
//  const TString& tipo_doc5() { return get("S2").mid(16,4);}
  const TString & tipo_doc(int i) const { CHECK(i < MAX_TIPI_DOC, "Impossibbile tipo documento"); return ((TString& ) get("S2").mid(i << 2, 4)).trim();}
  int ntipi_doc() const {const int l = get("S2").len(); return l ? (((l - 1) >> 2) + 1) : 0;}
  
  const char * complete_num (long num);
  int status() { return _status; }
  TCodice_numerazione(const char* codnum = NULL);
  TCodice_numerazione(const TRectype& rec);
  virtual ~TCodice_numerazione();
};

//////////////////////////////////////////////////////////////////////////////////////////////
// classe TDocumentoEsteso: oggetto che ha come finalita' il calcolo dei riepiloghi IVA
//////////////////////////////////////////////////////////////////////////////////////////////

class TRiepilogo_Iva : public TObject
{
  real _imp;
  real _iva;
  real _ali;
  byte _tipo;
  TString16 _cod;
  TString   _des;
  
protected:
  
public:
  real& imp()    { return _imp;} // Imponibile
  real& iva()    { return _iva;} // Iva
  real& ali()    { return _ali;} // Aliquota
  TString& cod() { return _cod;} // Descrizione
  TString& des() { return _des;} // Descrizione
  byte&    tipo(){ return _tipo;}// Tipo (Vedi opzioni per la selzione di filtro nella validate())
  void     zero(){ _imp = 0.0; _iva = 0.0; _ali = 0.0; _tipo = 0; _cod = ""; _des = ""; }
  virtual TObject* dup() const { return new TRiepilogo_Iva(*this); }
  TRiepilogo_Iva& operator = (TRiepilogo_Iva& a);
  TRiepilogo_Iva() {_imp = 0.0; _iva = 0.0; _ali = 0.0; _tipo = 0;}  
  ~TRiepilogo_Iva() {};
};

class TDocumentoEsteso : public TDocumento
{ 
  // Parametri del documento
  dec_parm        _parm;          // Parametri per gli arrotondamenti
  TTable        * _iva;           // Tabella codici IVA
  
  // Totali del documento ricalcolati non appena la tabellina di riepilogo IVA e' completa
  real _importi_netti, _imposte;

  // membri per il calcolo del riepilogo IVA
  bool            _sum_selected;  // TRUE se ha selezionato una riga del riepilogo, funge da semaforo per leggere la prossima
  int             _sum_filter;    // Filtro corrente della riga TRiepilogo_Iva in corso di stampa (-1 se non ha ancora calcolato la tabella)
  TString_array   _order_array;   // Array di TToken_string contenenti i codici IVA soddisfacenti ad ogni tipo di filtro
  TAssoc_array    _summary_table; // Array dove vengono memorizzate le imposte per aliquota
  TArray          _summary_array; // Array dove vengono memorizzate le imposte/imponibili per riga
  TRiepilogo_Iva  _sum_current;   // Riga corrente del riepilogo

  // membri per il calcolo del riepilogo scadenze
  TString_array   _scadenze_array;// Array che contiene le scadenze ("<data>|<importo>")
  int             _scadenze_current;  // indice per identificare l'elementi corrente sull'array (-1 se non ha ancora calcolato)

public:

  
  // Funzioni per il riepilogo IVA
  const bool summary_compiled() { return _sum_filter > -1; }
  void compile_summary(); // Aggiorna la tabella riepilogativa    
  void summary_filter(byte selector);  // filtra la tabellina secondo il filtro corrente se non e' gia' stato fatto
  void summary_reset(bool force=FALSE); // riposiziona l'array dei codici IVA (_order_array). Se il parametro e' TRUE forza il ricalcolo della tabella 
  void summary_set_next(); // seleziona il prossimo elemento del filtro
  const TRiepilogo_Iva& sum_current() { return _sum_current; } // ritorna la riga corrente del filtro corrente
  const char * summary_get(const TString& w); // ritorna l'informazione richiesta estratta dall'elemento corrente
  int  summary_items() { return _summary_table.items();} // ritorna il numero di righe in totale della tabellina
  const TAssoc_array& summary() { return _summary_table; }
  const TArray& summary_array() { return _summary_array;}
  

  // Funzioni per il ricalcolo delle scadenze
  void scadenze_reset(); // riposiziona sulla prima scadenza
  void scadenze_recalc(); // resetta e ricalcola le scadenze
  void scadenze_set_next(); // seleziona il prossimo elemento dell'array delle scadenze
  const char * scadenze_get(const TString& w); // reperisce l'informazione richiesta dall'elemento corrente
  int  scadenze_items() { return _scadenze_array.items(); }  // restituisce il numero di scadenze
  TString_array& scadenze() { return _scadenze_array; }

  // Funzioni di totalizzazione
  real& tot_importi_netti();
  real& tot_imposte();
  real tot_spese();
  real tot_documento();
  // restituisce tot_imponibili, tot_esenti, tot_nonsoggetti a seconda del selettore:  
  // 1 = regime normale
  // 2 = da ventilare (non usato)
  // 4 = esenti
  // 8 = non imponibili
  // 16 = non soggetti
  // pertanto i non imponibili avranno selettore 1 e gli esenti selettore 4.
  // per avere esenti + non soggetti il selettore sara' 20 e cosi' via.
  real tot_imponibili(byte selector);
  
  // Reperisce l'informazione <what> dal campo G1 della testata
  const char* get_head_info(const TString& what);
  
  // Funzioni per settare i parametri
  void set_decimals(dec_parm & parm) { _parm = parm ; }
  void set_condv(TCli_for * cli); // Cambia le condizioni di vendita
  TDocumentoEsteso (const TRectype & rec, dec_parm & parm, TCond_vendita * condv = NULL) ;
  TDocumentoEsteso (const TRectype & rec, TCond_vendita * condv = NULL) ;
  TDocumentoEsteso () ;
  ~TDocumentoEsteso();
};


#endif