#ifndef __LVLIB_H
#define __LVLIB_H

#ifndef __RECSET_H
#include <recset.h>
#endif

#ifndef __REPORT_H
#include <report.h>
#endif

#ifndef __MGLIB_H 
#include "../mg/mglib.h"
#endif

#ifndef __PACCHI_H 
#include "../ve/pacchi.h"
#endif

#ifndef __VELIB_H 
#include "../ve/velib.h"
#endif

#ifndef __VELIB07_H 
#include "../ve/velib07.h"
#endif

#define RDOC_QTAREALE "CIN01"
#define RDOC_TOTREALE "CIN02"
#define RDOC_PROVV1REALE "CIN03"
#define RDOC_PROVV2REALE "CIN04"
#define RDOC_QTARITREALE "CIN05"

void lv_set_creation_info(TRectype& rec);
void lv_set_update_info(TRectype& rec);
long lv_find_contract(const long codcf, const long indsped, const TDate& data);
bool lv_is_holiday(const TDate& data); 
bool lv_is_02_active(); 
const TFilename & lv_backup_path();

class TLaundry_contract : public TRectype
{
protected:
  TRectype& modify_row(const char* codart);  //restituisce una riga modificabile

public:

  virtual bool ok() const;
  
  bool read(const long codcf, const long codcont);
  bool read(const long codcf, const long indsped, const TDate& data);
  bool can_be_deleted() const;

  //metodi per la gestione delle righe
  const TRectype& row(const char* codart) const;
	const int rows() const ;
  const TRectype& row(int i) const;

  int add_row(const char* codart);
  int update_row(const char* codart, const char* fieldname, const bool bol);
  int update_row(const char* codart, const char* fieldname, const char* str);
  int update_row(const char* codart, const char* fieldname, const long nmr);
  int update_row(const char* codart, const char* fieldname, const real nmr);
  int update_row(const char* codart, const char* fieldname, const TDate& data);

  TLaundry_contract();
  TLaundry_contract(const TRectype & rec);
  TLaundry_contract(const long codcf, const long codcont);
  TLaundry_contract(const long codcf, const long indsped, const TDate& data);
};

class TRecmag_lavanderie : public TVariable_rectype
{
	real _consmese;
	long _update_time;

protected:
  virtual const TString & get_str(const char* fieldname) const ;
	virtual void put_str(const char* fieldname, const char* val) { return TRectype::put_str(fieldname, val);}

public:
	virtual int read(TBaseisamfile& f, word op = _isequal, word lockop = _nolock);
  virtual int readat(TBaseisamfile& f, TRecnotype nrec, word lockop = _nolock);

	virtual int name2index(const char* fieldname) const;
	virtual TFieldtypes type(const char* fieldname) const;
	virtual int length(const char* fieldname) const;
	virtual int ndec(const char* fieldname) const;
	virtual bool exist(const char* fieldname) const;
  virtual TObject* dup() const;

  void update();
  const real consmese(const TDate& dadata, const TDate& adata) const;

  TRecmag_lavanderie();
	TRecmag_lavanderie(const TRecmag_lavanderie & rec) : TVariable_rectype(rec), _update_time(0L) {}
	TRecmag_lavanderie(const TRectype & rec) : TVariable_rectype(rec), _update_time(0L) {}
  virtual ~TRecmag_lavanderie() {}
};

class TArticolo_lavanderie : public TArticolo_giacenza_data
{      
	int _anno_lav;
	char _tipocf;
	long _codcf;
	int _indsped;

protected:
  // la get_str supporta anche la sintassi:
  //     #LF->fieldname              
  //     #LF_par1->fieldname              
  //     #LF_par1_par2->fieldname              
  //     #LF_par1_par2_par3->fieldname              
  // dove:
  //   LF = numero logico del sottofile collegato (LF_UMART, LF_DESLIN, LF_CODCORR
  //   par1, par2, par3 = varie parti della chiave dell'indice del file collegato
  //          il numero di queste parti ed il loro valore dipende dal file collegato
  //          se parX comincia per # rappresenta il numero progressivo nell'indice 
  //   fieldname = nome del campo nel file collegato
  virtual const TString & get_str(const char* fieldname) const ;
  virtual void set_body_key(TRectype & rowrec);
  void set_anno_lav (int anno = 0);
	void set_anno_lav (const char * anno) { set_anno_mag(atoi(anno)); }
  virtual TRectype * new_body_record(int logicnum = 0);
public:
  virtual TObject* dup() const { return new TArticolo_lavanderie(codice(), _tipocf, _codcf, _indsped); }

  int find_clifomag(TRecord_array& rclifomag, const char * livello = NULL, int from = 0) const ;
  int find_clifomag(int annoes, const char * livello = NULL, int from = 0) const ;
	int find_clifomag(const char * annoes, const char * livello = NULL, int from = 0) const { return find_clifomag(atoi(annoes), livello, from); }

  TRecord_array & clifomag(int annoes) const;
	TRecord_array & clifomag(const char * annoes) const { return clifomag(atoi(annoes));}

	void set_tipocf(char tipocf);
	void set_codcf(long codcf);
	void set_indsped(int indsped);

	const TRecmag_lavanderie & find_rec(int annoes) const;
	const TRecmag_lavanderie & find_rec(const char * annoes) const { return find_rec(atoi(annoes)); }
  
	TArticolo_lavanderie(const char* codice = NULL, const char tipocf = ' ', const long codcf = 0L, const int indsped = 0);
	TArticolo_lavanderie(const TRectype& rec, const char tipocf = ' ', const long codcf = 0L, const int indsped = 0);
  virtual ~TArticolo_lavanderie() {}
};  

TArticolo_lavanderie& cached_article_laundry(const char * codart, const char tipocf, const long codcf, const int indsped);

class TLavanderie_calendar : public TObject
{
	int _year;
  TBit_array _days;

public:
	int read(int year = 0);
  int write() const;
  int rewrite() const { return write(); }
  int remove() const;

  void set_holiday(const TDate& date, bool holiday = true);
	void reset_holiday(const TDate& date) { set_holiday(date, false);}
  bool is_holiday(const TDate& date) const;

  TLavanderie_calendar(int year);
  virtual ~TLavanderie_calendar() {}
};

class TCausale_lavanderie : public TRectype
{
protected:
  //metodi che restituiscono le indicazioni sulle causali di magazzino associate
  const TString& caurit()  const {return get("S1");}
  const TString& caucon()  const {return get("S2");}

public:
  //metodi che restituiscono i dati di interesse sulla causale di lavanderia
  const TString& codice()  const {return get("CODTAB");}
  const TString& descr()   const {return get("S0");}
  const TString& caucol()  const {return get("S4");}
  const bool is_ritiro()   const {return get_bool("B0");}
  const bool is_consegna() const {return get_bool("B1");}
  const bool is_reso()     const {return get_bool("B2");}
  const bool is_rotto()    const {return get_bool("B3");}
  const bool movcong()     const {return !get_bool("B4");}
  //metodi che restituiscono le causali di magazzino associate
  const TCausale_magazzino& causale_ritiro()   const {return cached_causale_magazzino(caurit());}
  const TCausale_magazzino& causale_consegna() const {return cached_causale_magazzino(caucon());}
  //costruttore
  TCausale_lavanderie(const char * codice);
	TCausale_lavanderie(const TRectype &r);

  virtual ~TCausale_lavanderie() {}  
};

TCausale_lavanderie & cached_causale_lavanderie(const char * codcaus);



                                 /////////////////////////////////////////////////////
                                 ////    TBUONO_PRELIEVO & TBUONO_PRELIEVO_ROW    ////
                                 /////////////////////////////////////////////////////


//classe TBuono_prelievo
class TBuono_prelievo: public TDocumento
{
public:
  const TToken_string& chiave() const;  
  const TDate datadoc() const;
  const long codcont() const;

  void set_dataprco(const TDate& data);
  void set_itinerario(const int coditi);
  void set_contratto(const int codcont);

  TBuono_prelievo& operator= (const TBuono_prelievo bpre){bpre;}

  TBuono_prelievo(TDoc_key& key): TDocumento(key.provv(), key.anno(), key.codnum(), key.ndoc()){};
  TBuono_prelievo(TBuono_prelievo& bpre): TDocumento(bpre){};
};

//classe TBuono_prelievo_row
class TBuono_prelievo_row: public TObject
{
  TRiga_documento&  _rdoc;
public:
  const bool evaso() const;
  const TString& codart() const;
  const TString& desart() const;
  const TString& causale() const;
  const real qta_ritirata() const;
  const real qta_dacons() const;
  const real qta_consegnata() const;
  const int num_pacchi() const;
  const real prezzo() const;
  const long cong_pre() const;
  const long cong_att() const;
  const TToken_string& rifbcon() const;
  const TToken_string& rifbrit() const;
  const TDate& dataeva() const;

  void set_evaso(const bool evaso);
  void set_codart(const char* codart);
  void set_desart(const TString& desart);
  void set_causale(const char* causale);
  void set_qta_ritirata(const real qta);
  void set_qta_dacons(const real qta);
  void set_qta_consegnata(const real qta);
  void set_num_pacchi(const int numpacchi);
  void set_codiva(const char* codiva);
  void set_um(const char* um);
  void set_prezzo(const real prezzo);
  void set_mag(const char* mag);
  void set_magc(const char* magc);
  void set_cong_pre(const real qtacong);
  void set_cong_att(const real qtacong);
  void set_rifbcon(const TToken_string& keybcon);
  void set_rifbrit(const TToken_string& keybrit);
  void set_dataeva(const TDate& data);

  void add_qta_consegnata(const real qta);
  void add_pacchi(const int nmr = 1);

  TBuono_prelievo_row(TRiga_documento& rdoc):_rdoc(rdoc){}
};


                                 ///////////////////////////
                                 ////    TRIGA_PACCO    ////
                                 ///////////////////////////

//classe TRiga_pacco
class TRiga_pacco: public TRectype
{
public:  
  TRiga_pacco & operator =(const TRiga_pacco& rpacco);

  bool read(const TString& codpacco, const long codriga = 1);

  const TString&        codpacco()  const;
  const TToken_string&  key()       const;
  const TString&        articolo()  const;
  const real            quantita()  const;
  const TString&        um()        const;
  const TDate           data()      const;
  const long            cliente()   const;
  const TDate           databo()    const;
  const bool            annullato() const;
  const TToken_string&  rigabolla() const;
  const long            movmag()    const;

  void set_key(const char* codpacco, const int codriga = 1);
  void set_articolo(const char* codart);
  void set_quantita(const real qta);
  void set_um(const char* um);
  void set_data(const TDate& data);
  void set_cliente(const long codcf);
  void set_databo(const TDate& data);
  void set_annullato(const bool ann);
  void set_rigabolla(const int anno, const char* codnum, const long ndoc, const long idriga);
  void set_movmag(const long movmag);

  bool is_annullato();
  bool is_associato();

  TRiga_pacco(const TRectype& rec);
  TRiga_pacco(const TRiga_pacco& rpacco);
  TRiga_pacco(const char* codpacco, const long codriga = 1);
  TRiga_pacco();
};


                            ////////////////////////////////////
                            ////    CLASSE TGIAC_PER_CLI    ////
                            ////////////////////////////////////

//Definizione della classe Giacenza per Cliente
class TGiac_per_cli : public TObject
{
private:
  TAssoc_array  _odierna;     //TAssoc_array che conterrą le dotazioni odierne
  TAssoc_array  _temporanea;  //TAssoc_array che conterrą le dotazioni temporanee
  long          _clifo;       //variabile che conterrą il cliente selezionato
  long          _cont;        //variabile che conterrą il contratto selezionato
  int           _year;        //variabile che conterrą l'anno documento
  long          _indsped;     //variabile che conterrą l'indirizzo di spedizione

protected:
  real& giacart_od(const TString& codart);  //restituisce un puntatore al valore della dot. od. salvato
  real& giacart_tmp(const TString& codart); //restituisce un puntatore al valore valore della dot. temp. salvato
  long giac_in_mag(const TString& codart, bool odierna) const;  //restituisce il valore salvato nel magazzino

public:
  bool preset(const TDocumento& doc); //precarico le variabili globali della classe 
  bool reset(const TDocumento& doc);  //svuota i TAssoc_array e carica cli e cont
  bool load_row(TRiga_documento& rdoc, const bool aggiorna = false, const bool reading = false);  //popola i TAssoc_array
  real giac_att(TRiga_documento& rdoc, bool odierna); //restituisce le quantitą attuali di dotazione
  TGiac_per_cli(); //costruttore 
};

class TLV_recordset : public TDocument_recordset
{
public:
  virtual TCursor* cursor() const;

	TLV_recordset(const char* use) : TDocument_recordset(use) {}
	virtual ~TLV_recordset() {}
};

class TLV_report : public TDocument_report
{
  //size_t _first_lv_msg;

protected:
  bool msg_lv_nextcons(TVariant& var) const;
  bool msg_lv_dot(TVariant& var, const char tipo) const;
  bool msg_lv_consmese(TVariant& var) const;

  //virtual size_t get_usr_words(TString_array& words) const;
  //virtual bool execute_usr_word(unsigned int opcode, TVariant_stack& stack);
  virtual bool get_usr_val(const TString& name, TVariant& var) const;

public:
	virtual bool set_recordset(TRecordset* rs) { return TReport::set_recordset(rs); }
  virtual bool set_recordset(const TString& sql);
	TLV_report() {}
	virtual ~TLV_report() {}
};

                                          ///////////////////////////////////
                                          ////    TDOC_INVENTARIO_ROW    ////
                                          ///////////////////////////////////

//Classe TDoc_inventario_row
class TDoc_inventario_row: public TObject
{
  TRiga_documento&  _rinv;
public:  
  const TString&       codart()     const;
  const TString&       desart()     const;
  const real           qta()        const;
  const TString&       um()         const;
  const int            num_pacchi() const;
  const TToken_string& cod_pacchi() const;
  const TString&       magazzino()  const;
  const TString&       magazzinoc() const;

  void set_codart(const char* codart);
  void set_desart(const TString& desart);
  void set_qta(const real qta);
  void set_um(const char* um);
  void set_num_pacchi(const int numpacchi);
  void set_cod_pacchi(const char* codpacchi);
  void set_magazzino(const char* mag);
  void set_magazzinoc(const char* magc);

  TDoc_inventario_row(TRiga_documento& rinv):_rinv(rinv){}
};

                                          ///////////////////////////////
                                          ////    TDOC_INVENTARIO    ////
                                          ///////////////////////////////

//Classe TDoc_inventario
class TDoc_inventario: public TDocumento
{
public:
  const TToken_string& chiave()  const;
  const TDate          datadoc() const;
  
  TDoc_inventario_row find_or_create_row(const char* codart);

  void set_difinv(const bool difinv = true);

  TDoc_inventario& operator= (const TDoc_inventario dinv){dinv;}

  TDoc_inventario(TDoc_key& key): TDocumento(key.provv(), key.anno(), key.codnum(), key.ndoc()){};
  TDoc_inventario(TDoc_inventario& dinv): TDocumento(dinv){};  
};

#endif