#ifndef __PAGAMENT_H
#define __PAGAMENT_H

#ifndef __ASSOC_H
#include <assoc.h>
#endif                                         

#ifndef __MSKSHEET_H
#include <msksheet.h>
#endif                                         

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

#ifndef __TABUTIL_H
#include <tabutil.h>
#endif

#ifndef __CONTO_H
#include "conto.h"
#endif                                         

// Error codes for pagation
const word P_OK     = 0x0000;     // ok
const word P_RSUM   = 0x0001;     // percentages do not sum up to 100
const word P_IMPNC  = 0x0002;     // inconsistenza percentuali / importi
const word P_SCAD   = 0x0004;     // scadenze non consecutive 
const word P_INIZIO = 0x0008;     // data 1a rata < data inizio pagamenti

class TPagamento : public TObject
{   
  TString   _code;       // codice
  TString   _name;       // descrizione
  real      _imponibile; // imponibile da affettare
  real      _imposta;    // imposta da affettare
  real      _spese;      // spese da affettare
  TDistrib  _slicer;     // affettatrice
  bool      _new;        // non letto da database
  TArray    _rate;       // rate medesime
  char      _inscad;     // inizio scadenze:    S1    
  bool      _mcomm;      // mese commerciale:   B0   
  bool      _rdiff;      // rate differenziate: B1
  int       _tpr;        // tipo prima rata:    S3
  bool      _dirty;      // modificato (strutturalmente!)
  TDate     _inizio;     // data inizio pagamenti
  bool      _inited;     // vero se c'e' un movimento di riferimento
  real      _firstr;     // importo da pagare in prima rata (o distribuire se tpr == 0)
  real      _secndr;     // importo da distribuire
  
  int       _fixd[3];    // giorni scadenza fissa, se desiderati
  int       _round;      // decimali arrotondamento importo 
  int       _int_rate;   
  
  int       _rata_ifield(int n, int f) const;
  real      _rata_rfield(int n, int f) const;
  TDate     _rata_dfield(int n, int f) const;
  const char* _rata_sfield(int n, int f) const;
  
  int       _def_tpr;    // tipo rata default
  TString16 _def_ulc;    // ulteriore classificazione default
  
public:

  // pregasi notare la straordinaria dovizia di const
  int    n_rate()             const { return _rate.items();    }
  bool   is_new()             const { return _new;             }  
  bool   dirty()              const { return _dirty;           }

  real   imponibile()         const { return _imponibile;      }
  real   imposta()            const { return _imposta;         }
  real   spese()              const { return _spese;           }

  int    tipo_rata(int n)     const { return _rata_ifield(n,2);}
  real   perc_rata(int n)     const { return _rata_rfield(n,1);}
  int    scad_rata(int n)     const { return _rata_ifield(n,0);}               
  TDate  data_rata(int n)     const { return _rata_dfield(n,3);}
  real   tpay_rata(int n)     const { return _rata_rfield(n,4);}
  const char* ulc_rata(int n) const { return _rata_sfield(n,5);}
  char   inizio_scadenza()    const { return _inscad;          }           
  bool   mese_commerciale()   const { return _mcomm;           }           
  bool   rate_differenziate() const { return _rdiff;           }
  int    tipo_prima_rata()    const { return _tpr;             }
  int    decs()               const { return _round;           }
  
  // mi scuso per la mancanza di underscore, ma mi piaceva cosi'
  bool   ratapagata(int n);
  
  const TString& name()       const { return _name;            }                                    
  const TString& code()       const { return _code;            }                                    
  const char* desc_tpr()      const;
  const char* desc_tipo(int)  const;
  
  // giorni scadenza fissi, aggiunti poi  
  void  set_fixed_scad(int a, int ind) { _fixd[ind] = a;  }
  
  // queste vengono usate solo per movimenti editabili nella struttura
  // (da tabella pagamenti) e riaggiustano tutte le rate in accordo
  // con il parametro modificato
  void   set_intervallo_rate(int i);     
  void   set_mese_commerciale(bool v, int& sscad);          
  void   set_rate_differenziate(int v);
  void   set_tipo_prima_rata(int v, int sscad = -1);
  void   set_numero_rate(int n, int sscad = -1);
  
  void   set_inizio_scadenza(char v)    { _inscad = v; }           
  void   set_code(const char* c)        { _code = c;   }       
  void   set_round(int n)               { _round = n;  }
  
  // check consistency: returns word with errors flagged, 0 if ok
  word   validate() const;
  void   strerr(word err, TString& s);
  
  // read/write from database 
  // relapp passa i files, se no vengono aperti
  bool   read(TTable* cpg = NULL, TTable* rpg = NULL);
  
  // chiamabili solo da relapp, agiscono solo su %RPG
  int   write(TTable& rpg);
  int   rewrite(TTable& rpg);
  int   remove(TTable& rpg);
  
  // modifica rate manualmente o non
  TToken_string&   rata(int r) { return (TToken_string&)_rate[r]; }
  TToken_string&   add_rata (real perc, int day, int type, const char* ulc = "");
  TToken_string&   set_rata (int index, real perc, int day, int type, 
                             const char* ulc = NULL, const char* imp = NULL,
                             const char* data = NULL);     
  // questa calcola percentuali e scadenze a partire dagli importi
  TToken_string&   set_rata (int index, const real& howmuch, const TDate& date, int type,
                             const char* ulc, bool pagato);                    
  
  // settano tipo rata e ult. class default per le rate; se bool = TRUE
  // modificano anche le eventuali rate esistenti
  void set_default_type(int type, bool change_existing = TRUE);
  void set_default_ulc(const char* ulc, bool change_existing = TRUE);
  
  void   remove_rata(int r);  
  void   zap_rate () { _rate.destroy(); } 
  // calcola le rate automaticamente secondo quanto specificato
  void   set_rate_auto();          
  // data una rata esistente, riaggiusta gli importi usando lo slicer e 
  // le scadenze usando la data di inizio
  void   set_imprata(int i, real r);

  // slicer interface
  void   set_total(const real& ib, const real& im, const real& sp);
  
  // istanzia uno sheet field come diobue comanda                                   
  void   set_sheet(TSheet_field& sf, int sscad = -1);         
  // ricalcola automaticamente tutto il ricalcolabile
  // alla modifica di una percentuale (o di un importo)
  // ritorna TRUE se non si poteva; non occorre che sia inizializzato
  // con un importo
  word   recalc_rate(int row, bool is_perc_modified, const char* new_value,
                     const char* scad, const char* typ, int rdiff,
                     bool mcomm, bool& need_recalc);
  
  // determina la prossima scadenza
  void   next_scad(TDate& d, int scad, bool mcomm, int rata);

  // se codtab non e' NULL legge da file (e da' errore se non c'e')
  // se si vuole fare un pagamento nuovo si da' il codice con set_code                                                              
  TPagamento(const char* codtab = NULL, const char* data = NULL);
  virtual ~TPagamento() {}
};                          


#ifndef __PARTITE_H
#include <partite.h>
#endif

class TTree_rectype : public TRectype
{
protected:
  TRecord_array _recarr;

  void copy_key_to_row(TRectype& row) const;
  int fill_array();

protected: // TRectype 
  virtual TObject* dup() const;
  
  virtual int read(TBaseisamfile& f, word op = _isequal);
  virtual int next(TBaseisamfile& f);
  virtual int write(TBaseisamfile& f) const;
  virtual int rewrite(TBaseisamfile& f) const;
  virtual int remove(TBaseisamfile& f);
  
public:
  const TRecord_array& rows_array() const { return _recarr; }
  TRecord_array& rows_array() { return _recarr; }
  const TRectype& row(int r) const { return ((TRecord_array&)_recarr).row(r, FALSE); }
  TRectype& row(int r, bool create) { return _recarr.row(r, create); }

  TTree_rectype(const TRectype& testata, const TRectype& riga, const char* num);   
  TTree_rectype(int testata, int riga, const char* num);   
  TTree_rectype(const TTree_rectype& t);
  virtual ~TTree_rectype() {}
};


class TRiga_scadenze : public TTree_rectype
{              
  friend class TPartita;      
  friend class TRiga_partite;      
  
  TRiga_partite* _riga;
  
protected:                                       
  char calcola_abbuono(TImporto& abbuono, bool val) const;
  TImporto calcola_differenza_cambio(bool update);

  bool modifica_pagamento(const TRectype& new_pag, 
                          char& old_ap, TImporto& old_abb, TImporto& old_diffcam,
                          char& new_ap, TImporto& new_abb, TImporto& new_diffcam);

protected:  // TRecord_tree
  virtual TObject* dup() const { return new TRiga_scadenze(*this); }
  
public:
  int pagata() const;          // Riga che chiude la rata o 0 se non pagata completamente

  real residuo() const;
  
  bool in_valuta() const;
  
  TPartita& partita() const;
  TRiga_partite& riga() const { return *_riga; }    // Riga partite generante (fattura)               
  
  TImporto importo_pagato(bool val) const;
  TImporto importo_da_pagare(bool val) const;
  
  TRiga_scadenze(TRiga_partite* riga);
  TRiga_scadenze(const TRiga_scadenze& s);
  virtual ~TRiga_scadenze() {}
};

class TRiga_partite : public TTree_rectype
{         
  friend class TPartita;
  friend class TRiga_scadenze;
  TPartita* _partita;

protected:
  bool update(const TRectype& vec, const TRectype& nuo, const char* field);
  
public: // TTree_rectype     
  virtual TObject* dup() const { return new TRiga_partite(*this); }
  virtual int read(TBaseisamfile& f, word op);

public:
  int rate() const { return _recarr.rows(); }
  TRiga_scadenze& rata(int r) const { return (TRiga_scadenze&)_recarr.row(r); }

  int ultimo_pagamento(int rata) const;
  char sezione() const { return get_char("SEZ"); }

  TPartita& partita() const { return *_partita; }   // Partita di appartenenza

  TRiga_partite(TPartita* game);
  TRiga_partite(const TRiga_partite& r);
  virtual ~TRiga_partite() {}
};

class TPartita : public TObject
{             
  TRecord_array _part;
  TRecord_array _unassigned;
  
public: // TObject
  virtual bool ok() const { return _part.rows() > 0; }

public:
  TRiga_partite& riga(int r) const { return (TRiga_partite&)_part.row(r); } 
  TRiga_partite& nuova_riga() { return (TRiga_partite&)_part.row(last()+1, TRUE); }
  
  int succ(int r) const { return _part.succ_row(r); } 
  int pred(int r) const { return _part.pred_row(r); } 
  int first() const { return _part.first_row(); }
  int last() const { return _part.last_row(); }

  bool reread();         
  bool read(const TBill& clifo, int anno, const char* num);
  bool write(bool re = FALSE);
  bool rewrite() { return write(TRUE); }
  
  int mov2rig(long nreg, int rmov) const;
  int rig2mov(int rmov) const;
  int prima_fattura() const;
  bool utilizzata(int r) const;    // Controlla se esistono pagamenti sommati alla riga r

  void conto(TBill& c) const { c.get(_part.key()); }
  int anno() const { return _part.key().get_int(PART_ANNO); }
  const TString& numero() const { return _part.key().get(PART_NUMPART); }
  const TString& descrizione() const { return _part.key().get(PART_DESCR); }

  TImporto importo_speso(long numreg, int numrig) const;
  void update_reg_num(long nreg, const TRectype& mov);
  void calcola_saldo(TImporto& saldo, TImporto& doc, TImporto& pag, TImporto& imp) const;
  
  bool modifica_pagamento(const TRectype& new_pag,
                          char& old_ap, TImporto& old_abb, TImporto& old_diffcam,  
                          char& new_ap, TImporto& new_abb, TImporto& new_diffcam);

  TPartita(const TBill& clifo, int anno, const char* num);
  TPartita();
};           


class TPartite_array : private TAssoc_array
{ 
  TString80 _key;    // Work string
  
protected:
  const TString& key(const TBill& clifo, int anno, const char* num); // Build key for TAssoc_array
  TPartita* find(const TBill& clifo, int anno, const char* numero, bool create);
  TPartita* find(const TRectype& part, bool create);

public:              // TAssoc_array
  virtual void destroy() { TAssoc_array::destroy(); }

public:
  TPartita& partita(const TBill& clifo, int anno, const char* numero);
  TPartita& partita(const TRectype& r);
  
  TPartita* exist(const TBill& clifo, int anno, const char* numero) const
  { return ((TPartite_array*)this)->find(clifo, anno, numero, FALSE); }
  
  TPartita* exist(const TRectype& part) const
  { return ((TPartite_array*)this)->find(part, FALSE); }
  
  bool write(bool re = FALSE);
  bool rewrite() { return write(TRUE); }
  
  int add_reg_num(long numreg, int numrig);
  TImporto importo_speso(long numreg, int numrig);
  void update_reg_num(long nreg, const TRectype& mov);
  
  TPartita* first() { restart(); return next(); }
  TPartita* next() { return (TPartita*)get(); }
  
  TPartite_array() {} 
  virtual ~TPartite_array() {}
};

#endif