#ifndef __SALDACON_H
#define __SALDACON_H

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

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

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

#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);
  
  const TRecord_array& rows_array() const { return _recarr; }
  TRecord_array& rows_array() { return _recarr; }

public:
  const TRectype& row(int r) const { return _recarr.row(r); }
  TRectype& row(int r) { return _recarr.row(r, FALSE); }
  TRectype& new_row(int r = -1) { return _recarr.row(r > 0 ? r : last()+1, TRUE); }
  
  int first() const { return _recarr.first_row(); }
  int last() const { return _recarr.last_row(); }
  int pred(int r) const { return _recarr.pred_row(r); }
  int succ(int r) const { return _recarr.succ_row(r); }

  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
  
  bool in_valuta() const;
  
  TPartita& partita() const;
  TRiga_partite& riga() const { return *_riga; } // Riga partite
  
  TImporto importo_pagato(bool val) const;
  TImporto importo_da_pagare(bool val) const;
  real residuo(bool val) const;       // Differenza delle due funzioni precedenti

  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);
  bool update(const TImporto& vec, const TImporto& nuo, const char* sez, const char* val);
  
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); }
  TRiga_scadenze& new_row(int r = -1);

  int ultimo_pagamento(int rata) const;
  char sezione() const { return get_char(PART_SEZ); }
  bool in_valuta() const { return get(PART_CODVAL).not_empty(); }

  TPartita& partita() const { CHECK(_partita, "Partita nulla"); return *_partita; }

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

class TPartita : public TObject
{             
  enum { UNASSIGNED = 9999 };

  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();
  TRiga_scadenze& rata(int nriga, int nrata) const;
  
  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); }
  bool remove();
  
  int mov2rig(long nreg, int rmov) const;
  int rig2mov(int rmov) const;
  int prima_fattura(long nreg = -1l) const;
  int primo_pagamento(long nreg = -1l) const; 
  
  bool utilizzata(int r) const;    // Controlla se esistono pagamenti sommati alla riga r
  bool remove_unassigned(long nreg);
  
  bool chiusa(bool update = FALSE);

  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, bool extra) const;
  void update_reg(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);
  bool modifica_pagamento(const TRectype& new_pag);

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


class TPartite_array : private TAssoc_array
{ 
  TString80 _key;    // Work string
  long _numreg;        // Last registration loaded
  
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();

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_numreg(long numreg);        // Carica tutte le partite relative alla registrazione numreg
  TImporto importo_speso(long numreg, int numrig, bool extra);
  void update_reg(const TRectype& mov, long old_reg = 0);
  
  TPartita* first() { restart(); return next(); }
  TPartita* next() { return (TPartita*)get(); }
  
  TPartite_array() : _numreg(0) {} 
  virtual ~TPartite_array() {}
};

#endif