#ifndef __CGLIB_H
#define __CGLIB_H

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

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

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

#ifndef __CG2103_H
#include "cg2103.h"  // per TCausale
#endif

class TCaus : public TCausale
{
private:
  TRectype _rec;
  
public:
  bool            chiusura() const;
  bool            apertura() const;
  virtual bool    read(const char* cod);
  
  TCaus(const char* cod);
  ~TCaus() {}
};

class TSaldi_list : public TAssoc_array
{
public:
  TSaldi_list (int g, int c, int aec, int aep=0);
  TRectype* saldi() const;
};

enum tipobil { DataLimite=1, UltimaImmissione };        
const int EsePre(const int EseCorr);

class TSaldo 
{
  real      _saldo, _saldo_iniziale, _saldoiniziale;
  real      _prg_dare, _prg_avere, _prg_daresca, _prg_averesca;
  int       _indbil;
  TRectype*  _saldo_ep;
  int       _annoes;
  TDate     _inizioEs, _fineEs;
  TString16 _codcaus;
  TDate     _datareg;
  TDate     _datacomp;
  TString   _provv;

  bool      _movimentato;
  bool      _significativo;
  bool      _rec_presente_ec;
  bool      _rec_presente_ep;
  bool      _prec;
  
protected:
  void      InFinEs(int);
  void      leggi_mov(long numreg);       // Leggi testata      
  real      calcola_saldo_iniziale(int g, int c, long s, int indbil);
  
public:

  bool  movimentato()   const { return _movimentato; }
  bool  significativo() const { return _significativo; }
  bool  esiste_saldo()  const { return _rec_presente_ec || _rec_presente_ep;}
  bool  esiste_saldo_ep() const { return _rec_presente_ep; }
  
  int   annoes () const { return _annoes; }
  void  set_annoes (int anno) { _annoes = anno; }

  bool  causale_mov(long, const TDate&, const TDate&, TString&);
  const char*   causale_chiusura_es();
  const char*   causale_apertura_es();

  bool ultima_immissione_bilancio(int anno,int g,int c,long s,int indbil,int prov);
  bool ultima_immissione_verifica(int anno,int g,int c,long s,int indbil,int prov);
  bool data_limite_bilancio(int,int,int,long,const TDate&,const TDate&,int,int);

  TRectype& ricerca_progr_prec(int, int, int, long);

  real saldofin_esprec(int,int,int,long); 
  bool prg_attuali(int,TConto&,real&,real&);
  bool prg_mov_eliminati(int,TConto&,real&,real&);

  const real& saldo() const { return _saldo;}
  const real& saldoini() const { return _saldo_iniziale;}
  const real& saldoinisusaldi() const { return _saldoiniziale;}
  const real& prgdare() const { return _prg_dare;}
  const real& prgavere() const { return _prg_avere;}
  const bool flagprec() { return _prec; }
  bool prg_attuali(int,TConto&,int,real&,real&);
  bool prg_mov_eliminati(int,TConto&,int,real&,real&);
  TSaldo();
  ~TSaldo();
};



class TTab_conti : public TAssoc_array
{
public:
  void aggiorna_conto(const TBill& tc, int anno_es, const TImporto& importo,
                      bool movap, bool provv, bool somma, bool movimentato);
  
  TConto* add(const TBill& c, int anno);
  TConto* find(const TBill& c, int anno);                    
  void remove(const TBill& c, int anno);
};


class TSaldo_agg : public TObject
{
  TTab_conti _tab_conti;
  bool       _movap;       // se e' mov. d'apertura (aggiorno SALDO e FLAGSALINI in saldi)
  bool       _provv;      
  int        _anno_es;     // anno esercizio
  TDate      _data_ulmov;  // data ultimo movimento
  long       _num_ulmov;   // numero ultimo movimento 
  TRectype*  _rec;         // record corrente sui saldi
  bool       _movimentato; // di default e' FALSE; viene usato a TRUE solo quando voglio
                           // che un conto sia movimentato sui saldi anche se progressivi
                           // e saldo iniziale non sono significativi. Usato dalla Chiusura/Apertura conti  
public:
  void clear_saldi(int year);
  void registra();
  void aggiorna (const TBill& tc, const TImporto& importo, bool somma=TRUE);  
  void aggiorna (int gruppo, int conto, long sottoconto, 
                 const real& importo, char sezione, bool somma=TRUE);  
  
  TConto* find(const TBill& c, int anno) { return _tab_conti.find(c, anno); }               

  void set_anno_es(int anno) { _anno_es = anno; }
  int anno_es() const { return _anno_es; }

  void set_movap (bool movap) { _movap = movap; }
  bool movap() const { return _movap; }

  void set_movprovv (bool p) { _provv = p; }
  bool movprovv() const { return _provv; }

  void set_movimentato (bool movimentato) { _movimentato = movimentato; }
  bool movimentato() const { return _movimentato; }

  void set_data_ulmov (const TDate& data) { _data_ulmov = data; }
  const TDate& data_ulmov() const { return _data_ulmov; }

  void set_num_ulmov (long num) { _num_ulmov = num; }
  long num_ulmov() const { return _num_ulmov; }

  void reset(); // pulisce l'array dei conti
  TSaldo_agg();
  int items() const { return _tab_conti.items();}
};

class TEsercizio : public TSortable
{            
  int _codice;
  TDate _inizio, _fine, _scarico;
  
protected:  // TSortable
  int compare(const TSortable& s) const;

public:    
  int codice() const           { return _codice; }
  const TDate& inizio() const  { return _inizio; }
  const TDate& fine() const    { return _fine; }
  const TDate& scarico() const { return _scarico; }

  TEsercizio(const TRectype& rec);
  virtual ~TEsercizio() {}
};

class TEsercizi_contabili : private TArray
{               
  long _firm;

protected:
  static int ordina_esercizi(const TObject** o1, const TObject** o2);
  void check();
  
  const TEsercizio& esc(int i) const 
  { return (const TEsercizio&)operator[](i); }

  int date2index(const TDate& d);
  int esc2index(int codice);
     
public:
  void update();
  
  const TEsercizio& esercizio(int codice);
  
  int date2esc(const TDate& date);
  int pred(int codice);
  int next(int codice);
  int first();
  int last();
  bool exist(int codice);

  TEsercizi_contabili();
  virtual ~TEsercizi_contabili() {}
};

#endif

