#ifndef __VELIB01_H 
#define __VELIB01_H

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

real lordo2netto(real& lordo, const TString& codiva, bool is_valuta = FALSE);
real netto2lordo(const real& netto, const TString& codiva, bool is_valuta = FALSE);
real lordo2netto(real& lordo, const real& iva, bool is_valuta = FALSE);
real netto2lordo(const real& netto, const real& iva, bool is_valuta = FALSE);

class TMask;

class TTipo_documento : public TObject
{                    
  TRectype _rec;
  
protected:
  int read(const char* tipodoc);

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

public:       
  const TString& profile_name() const { return _rec.get("S4");}
  const TString& mask_name() const { return _rec.get("S4");}
  
  const TString& codice() const { return _rec.get("CODTAB");}  
  
  bool uguale(int u) const { return _rec.get("S2")[(int)u]; }
  
  bool operator ==(const char* cod) const { return codice() == cod; }
  
  TTipo_documento(const char* tipodoc = NULL);
  TTipo_documento(const TRectype& rec);
  virtual ~TTipo_documento();
};

class TDocumento : public TObject
{ 
  static TAssoc_array _tipi;

  TRectype      _head;  // Record di testata
  TRecord_array _rows;  // Array di TRectype per le righe documenti di vendita.
protected:  
  TRectype & row(int index) { return _rows.row(index, FALSE); } 
  long get_next_key(char provv, int anno, const char* codnum) const;

public:
  int rows() const { return _rows.rows(); } 
  
  const TRectype & head() const { return _head; } // Ritorna la testata del documento
  TRectype & head() { return _head; } // Ritorna la testata del documento
  const TRectype & operator[](int index) const { return _rows.row(index); } // Ritorna la riga n-esima del documento 
  TRectype & operator[](int index) { return _rows.row(index, FALSE); } 
  TRectype& new_row() { return _rows.row(-1, TRUE); }
  bool destroy_row(int n) { return _rows.destroy_row(n); }
  void destroy_rows() { _rows.destroy_rows(); }
  
  int read(char provv, int anno, const char* codnum, long numdoc);
  int read(const TRectype& rec);
  
  int write(bool re = FALSE) const;
  int rewrite() const { return write(TRUE); }
  int remove() const;
  
  char tipo_numerazione() const { return _head.get_int("PROVV"); }
  int anno() const { return _head.get_int("ANNO"); }
  const TString& numerazione() { return _head.get("CODNUM"); }
  long numero() const { return _head.get_long("NDOC"); }
  const TString & valuta() { return _head.get("CODVAL"); }
  const bool in_valuta();
  const real cambio() { return _head.get_real("CAMBIO"); }
  const TDate& data() const { return _head.get_date("DATADOC"); }
//  const TString& tipodoc() { return _head.get("TIPODOC"); }
  const TTipo_documento& tipo() const;                  
  
  char stato() const { return _head.get_char("STATO"); }
  void stato(char s) { _head.put("STATO", s); }
  
  bool raggruppabile() const { return _head.get_bool("RAGGR"); }
  bool raggruppabile(const TDocumento& doc) const;

  static void set_key(TRectype& rec, char provv, int anno, const char* codnum, long numdoc);
  static void copy_data(TRectype& dst, const TRectype& src);

  TDocumento ();
  TDocumento(char provv, int anno, const char* codnum, long numdoc);
  TDocumento(const TRectype& doc);
  virtual ~TDocumento() { }
};

class TLista_documenti : public TObject
{ 
  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 tipo, long clifo, int anno, const TDate& dd, const TDate& ad, 
           const char* codnum = "", long dn = 0L, long an = 0L, char provv = 'D');
  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
{                
  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);
    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'; }
};

class TElaborazione : public TObject
{ 
protected:     
  TRectype _rec;

protected:
  int read(const char* cod);

public:
  const TString& codice() const { return _rec.get("CODTAB"); }
  
  virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out) pure;

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

class TFatturazione_bolle : public TElaborazione
{ 
public:
  virtual bool raggruppa(TDocumento& din, TDocumento& dout);
  virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out);
  
  TFatturazione_bolle(const char* cod) : TElaborazione(cod) { }
  virtual ~TFatturazione_bolle() { }
};

#endif