//Stampa riepilogo gruppi/conti

// W96SALDI e' la sigla di tutte le modifiche effettuate riguardo il cambiamento dell' archivio 
// SALDI. L' archivio e' cambiato nel seguente modo:
// - Non esistono piu' i progressivi dei movimenti scaricati PDARESCA e PAVERESCA;
// - Ora esistono un record per i movimenti normali e un record per i movimenti scaricati; la 
//   distinzione e' resa possibile dall' introduzione in chiave di un flag FLSCA (vedi tracciato)
//   che e' un booleano. Il record con FLSCA = FALSE contiene la somma dei saldi dei movimenti
//   normali e dei movimenti scaricati, mentre il record con FLSCA = TRUE, contiene solo i saldi
//   dei movimenti scaricati.
// Tutti i saldi che nel programma venivano memorizzati nei campi PDARESCA e PAVERESCA dei
// file temporanei ora sono memorizzati in PDAREPRO e PAVEREPRO.
// Le funzioni che sono state modificate sono:
// - riepilogo();
// - ricerca_cf(...);
// - leggi_conti(...);
// - leggi_gruppi(...);
// - CercaConto(...);
// - CercaGruppo(...);
// - UltimaData(...);

#include <config.h>
#include <mask.h>
#include <printapp.h>
#include <progind.h>
#include <tabutil.h>
#include <utility.h>

#include <pconti.h>
#include <comuni.h>
#include <clifo.h> 
#include <saldi.h>
#include <nditte.h>
#include <anagr.h>

#include "cg3.h"
#include "cg3500.h"
#include "cglib02.h"

typedef enum {stampagruppo, stampaconto, stampasottoconto, fine} tipo;

class TStampa_riepilogo : public TPrintapp
{
  TSaldi_list* _lista;
  TIsamtempfile * _tmp_saldi;
  tipo _tp; 
  real _prg_dare,_prg_avere,_saldo_dare,_saldo_avere,_prg_dare_tot,_prg_avere_tot,_saldo_tot;
  real _prg_dare_gruppo,_prg_avere_gruppo,_saldo_dare_gruppo,_saldo_avere_gruppo,_prg_dare_conto,_prg_avere_conto,_saldo_dare_conto,_saldo_avere_conto;
  int  _ggruppo,_gconto,_cgruppo,_cconto,_gcorr,_ccorr,_gprec,_cprec,_scelta,_richiesta,_annoese,_eof;
  long _scorr;
  char _tipo;
  TDate _ultima_data,_data,_udata_max;
  TString _descr,_descrconto,_descrgruppo,_cofi,_cap,_paiva,_ragsoc,_comunefis,_provfis,_viafis,_g_descr,_c_descr;

public:

  virtual bool user_create() ;
  virtual bool user_destroy();
  virtual bool set_print(int);

  virtual bool preprocess_print(int,int);
  virtual void preprocess_header();
  virtual bool preprocess_page(int,int);
  virtual print_action postprocess_page(int,int);
  virtual void postclose_print();

  bool riepilogo();
  bool ricerca_cf(TConto&,int,real&,real&);
  tipo leggi_conti(int);
  tipo leggi_gruppi(int);
  bool CercaConto(int,int);
  bool CercaGruppo(int);
  void setta_riga_conto();
  void setta_riga_gruppo();
  void setta_riga_sottoconto();
  void setta_riga_totale();
  void get_dati_ditta();
  int  stampa_intestazione_ditta();
  TDate UltimaData(int,int,long);
  
  TStampa_riepilogo() { } 
  virtual ~TStampa_riepilogo() { }
};

bool TStampa_riepilogo::riepilogo() 
{
  TSaldo sld;
  int g, c, gp, cp, indbil;
  long s;
  char tipo_conto = ' ';
  bool esiste_conto = FALSE, esiste_sc = FALSE;
  real saldo_conto,prg_conto_dare,prg_conto_avere,saldo_gruppo,prg_gruppo_dare,prg_gruppo_avere,prg_dare,prg_avere,saldo;
  
  CHECK(_tmp_saldi == NULL, "La minchia che riapro cg01!");                                                    
  _tmp_saldi = new TIsamtempfile(LF_SALDI, "cg01", TRUE, TRUE);

  gp=-1;
  cp=-1;
  _udata_max = 0l;

  TRelation rel(LF_PCON);
  TCursor cur(&rel);
  cur.freeze();
  const TRectype& pcn = rel.curr();
  const TRecnotype items = cur.items();
  TProgind prog(items, TR("Elaborazione in corso..."), true, true);

	for (cur = 0L; cur.pos() < items; ++cur)
  {
    if (!prog.addstatus(1))
      break;
    g          = pcn.get_int (PCN_GRUPPO);
    c          = pcn.get_int (PCN_CONTO);
    s          = pcn.get_long(PCN_SOTTOCONTO);
    tipo_conto = pcn.get_char(PCN_TMCF);

    TConto conto (g,c,s,tipo_conto);

    //il "conto" e' cambiato anche se e' rimasto invariato il conto ma e' cambiato il gruppo
    if ( (((cp != -1) && (conto.conto() != cp)) || ((gp != -1) && (conto.gruppo() != gp)))
        && esiste_sc )
    {
      saldo_conto      = prg_conto_dare - prg_conto_avere;
      prg_gruppo_dare  += prg_conto_dare;
      prg_gruppo_avere += prg_conto_avere;

      //scrivo il record del conto;
      _tmp_saldi->zero();
      _tmp_saldi->put(SLD_GRUPPO,gp);
      _tmp_saldi->put(SLD_CONTO,cp);
      _tmp_saldi->put(SLD_SOTTOCONTO,0L);
      _tmp_saldi->put(SLD_ANNOES,_annoese);
      _tmp_saldi->put(SLD_DATAULMOV,_udata_max);
      _tmp_saldi->put(SLD_PDARE,prg_conto_dare);
      _tmp_saldi->put(SLD_PAVERE,prg_conto_avere);
      if (saldo_conto > 0.00) //va stampato in Dare
        _tmp_saldi->put(SLD_PDAREPRO,saldo_conto);    // W96SALDI del 10-06-96  
      else
      {
        saldo_conto = saldo_conto * (-1.00);         
        _tmp_saldi->put(SLD_PAVEREPRO,saldo_conto);   // W96SALDI del 10-06-96
      }
      _tmp_saldi->write();
      esiste_conto = TRUE;
      esiste_sc    = FALSE;
      cp = conto.conto();
      prg_conto_dare    = 0.00;
      prg_conto_avere   = 0.00;
    }
    if ( ((gp != -1) && (conto.gruppo() != gp)) && esiste_conto )
    {
      saldo_gruppo = prg_gruppo_dare - prg_gruppo_avere;

      //scrivo il record del gruppo
      _tmp_saldi->zero();
      _tmp_saldi->put(SLD_GRUPPO,gp);
      _tmp_saldi->put(SLD_CONTO,0);
      _tmp_saldi->put(SLD_SOTTOCONTO,0L);
      _tmp_saldi->put(SLD_ANNOES,_annoese);
      _tmp_saldi->put(SLD_PDARE,prg_gruppo_dare);
      _tmp_saldi->put(SLD_PAVERE,prg_gruppo_avere);
      if (saldo_gruppo > 0.00) //va stampato in Dare
        _tmp_saldi->put(SLD_PDAREPRO,saldo_gruppo);       // W96SALDI del 10-06-96
        //_tmp_saldi->put(SLD_PDARESCA,saldo_gruppo);
      else
      {
        saldo_gruppo = saldo_gruppo * (-1.00);      
        _tmp_saldi->put(SLD_PAVEREPRO,saldo_gruppo);      // W96SALDI del 10-06-96
        //_tmp_saldi->put(SLD_PAVERESCA,saldo_gruppo);
      }
      _tmp_saldi->write();
      gp = conto.gruppo();
      esiste_conto = FALSE;
      prg_gruppo_dare   = 0.00;
      prg_gruppo_avere  = 0.00;
    }   
    if ( (conto.sottoconto() == 0) && (conto.conto() != 0) ) //si tratta di un conto
    {
      if ( (tipo_conto == 'C') || (tipo_conto == 'F') ) //si tratta di un conto cliente/fornitore
      {
        _udata_max = 0l;
        indbil     = pcn.get_int(PCN_INDBIL);
        esiste_sc  = ricerca_cf(conto,indbil,prg_conto_dare,prg_conto_avere);
        if (esiste_sc)
        {
          gp = conto.gruppo();
          cp = conto.conto();
        }
        if (cur.pos() == items-1)
        {  
          saldo_conto      = prg_conto_dare - prg_conto_avere;
          prg_gruppo_dare  += prg_conto_dare;
          prg_gruppo_avere += prg_conto_avere;
          if (esiste_sc)
          {
            //scrivo il record del conto;
            _tmp_saldi->zero();
            _tmp_saldi->put(SLD_GRUPPO,gp);
            _tmp_saldi->put(SLD_CONTO,cp);
            _tmp_saldi->put(SLD_SOTTOCONTO,0L);
            _tmp_saldi->put(SLD_ANNOES,_annoese);
            _tmp_saldi->put(SLD_DATAULMOV,_udata_max);
            _tmp_saldi->put(SLD_PDARE,prg_conto_dare);
            _tmp_saldi->put(SLD_PAVERE,prg_conto_avere);
            if (saldo_conto > 0.00) //va stampato in Dare
              _tmp_saldi->put(SLD_PDAREPRO,saldo_conto);       // W96SALDI del 10-06-96
              //_tmp_saldi->put(SLD_PDARESCA,saldo_conto);
            else
            {
              saldo_conto = saldo_conto * (-1.00);       
              _tmp_saldi->put(SLD_PAVEREPRO,saldo_conto);      // W96SALDI del 10-06-96
              //_tmp_saldi->put(SLD_PAVERESCA,saldo_conto);
            }
            _tmp_saldi->write();
            esiste_conto = TRUE;
            esiste_sc = FALSE;
          }
          if (esiste_conto)
          {   
            saldo_gruppo = prg_gruppo_dare - prg_gruppo_avere;
            //scrivo il record del gruppo
            _tmp_saldi->zero();
            _tmp_saldi->put(SLD_GRUPPO,gp);
            _tmp_saldi->put(SLD_CONTO,0);
            _tmp_saldi->put(SLD_SOTTOCONTO,0L);
            _tmp_saldi->put(SLD_ANNOES,_annoese);
            _tmp_saldi->put(SLD_PDARE,prg_gruppo_dare);
            _tmp_saldi->put(SLD_PAVERE,prg_gruppo_avere);
            if (saldo_gruppo > 0.00) //va stampato in Dare
              _tmp_saldi->put(SLD_PDAREPRO,saldo_gruppo);
              //_tmp_saldi->put(SLD_PDARESCA,saldo_gruppo);     // W96SALDI del 10-06-96
            else
            {
              saldo_gruppo = saldo_gruppo * (-1.00);      
              _tmp_saldi->put(SLD_PAVEREPRO,saldo_gruppo);      // W96SALDI del 10-06-96
              //_tmp_saldi->put(SLD_PAVERESCA,saldo_gruppo);
            }
            _tmp_saldi->write();
          }  
        } 
        
        continue;
      }
    }
    
    if (conto.conto() == 0)
      indbil = pcn.get_int(PCN_INDBIL);
    
    if ( (conto.conto() == 0) || (conto.sottoconto() == 0) ) //e' un gruppo o un conto
    {     
      _udata_max = 0l;
      esiste_sc = FALSE;
      continue;
    }
    // ho trovato un sottoconto
    //esiste_sc = TRUE;
    prg_dare  = 0.00;
    prg_avere = 0.00;
    if (_richiesta == 1)
      sld.prg_attuali(_annoese,conto,prg_dare,prg_avere);
    else sld.prg_mov_eliminati(_annoese,conto,prg_dare,prg_avere);
    
    saldo = prg_dare - prg_avere;
    
    prg_conto_dare  += prg_dare;
    prg_conto_avere += prg_avere; 
    
    if (prg_dare != ZERO || prg_avere != ZERO)
    {    
      esiste_sc = TRUE;
      if (_scelta == 1) //riepilogo conti
      {
        _tmp_saldi->zero();
        _tmp_saldi->put(SLD_GRUPPO,conto.gruppo());
        _tmp_saldi->put(SLD_CONTO,conto.conto());
        _tmp_saldi->put(SLD_SOTTOCONTO,conto.sottoconto());
        _tmp_saldi->put(SLD_ANNOES,_annoese);
        _tmp_saldi->put(SLD_FLAGSALINI,tipo_conto);
        _tmp_saldi->put(SLD_PDARE,prg_dare);
        _tmp_saldi->put(SLD_PAVERE,prg_avere);
        if (saldo > 0.00) //va stampato in Dare           
          _tmp_saldi->put(SLD_PDAREPRO,saldo);      // W96SALDI del 10-06-96
          //_tmp_saldi->put(SLD_PDARESCA,saldo);
        else
        {
          saldo = saldo * (-1.00); 
          _tmp_saldi->put(SLD_PAVEREPRO,saldo);     // W96SALDI del 10-06-96
          //_tmp_saldi->put(SLD_PAVERESCA,saldo);
        }
        _tmp_saldi->write();
      }
      if (_scelta == 2)
      {
        _ultima_data = UltimaData(conto.gruppo(),conto.conto(),conto.sottoconto());
        _udata_max   = fnc_max(_udata_max,_ultima_data);
      }

      gp = conto.gruppo();
      cp = conto.conto();
    }
    
    if (cur.pos() == items-1)
    {
      saldo_conto      = prg_conto_dare - prg_conto_avere;
      prg_gruppo_dare  += prg_conto_dare;
      prg_gruppo_avere += prg_conto_avere;
      if (esiste_sc)
      {
        esiste_conto = TRUE;
        //scrivo il record del conto;
        _tmp_saldi->zero();
        _tmp_saldi->put(SLD_GRUPPO,gp);
        _tmp_saldi->put(SLD_CONTO,cp);
        _tmp_saldi->put(SLD_SOTTOCONTO,0L);
        _tmp_saldi->put(SLD_ANNOES,_annoese);
        _tmp_saldi->put(SLD_DATAULMOV,_udata_max);
        _tmp_saldi->put(SLD_PDARE,prg_conto_dare);
        _tmp_saldi->put(SLD_PAVERE,prg_conto_avere);
        if (saldo_conto > 0.00) //va stampato in Dare
          _tmp_saldi->put(SLD_PDAREPRO,saldo_conto);     // W96SALDI del 10-06-96
          //_tmp_saldi->put(SLD_PDARESCA,saldo_conto);
        else
        {
          saldo_conto = saldo_conto * (-1.00); 
          _tmp_saldi->put(SLD_PAVEREPRO,saldo_conto);    // W96SALDI del 10-06-96
          //_tmp_saldi->put(SLD_PAVERESCA,saldo_conto);
        }
        _tmp_saldi->write();
      }
      saldo_gruppo = prg_gruppo_dare - prg_gruppo_avere;
      if (esiste_conto)
      {
        //scrivo il record del gruppo
        _tmp_saldi->zero();
        _tmp_saldi->put(SLD_GRUPPO,gp);
        _tmp_saldi->put(SLD_CONTO,0);
        _tmp_saldi->put(SLD_SOTTOCONTO,0L);
        _tmp_saldi->put(SLD_ANNOES,_annoese);
        _tmp_saldi->put(SLD_PDARE,prg_gruppo_dare);
        _tmp_saldi->put(SLD_PAVERE,prg_gruppo_avere);
        if (saldo_gruppo > 0.00) //va stampato in Dare
          _tmp_saldi->put(SLD_PDAREPRO,saldo_gruppo);       // W96SALDI del 10-06-96
          //_tmp_saldi->put(SLD_PDARESCA,saldo_gruppo);
        else
        {
          saldo_gruppo = -saldo_gruppo;
          _tmp_saldi->put(SLD_PAVEREPRO,saldo_gruppo);      // W96SALDI del 10-06-96
          //_tmp_saldi->put(SLD_PAVERESCA,saldo_gruppo);
        }
        _tmp_saldi->write();
      } 
    }
  }  

  return TRUE;
}

bool TStampa_riepilogo::ricerca_cf(TConto& conto,int indbil,real& prg_conto_dare,real& prg_conto_avere) 
{
  TSaldo sld;
  bool esiste_sc = FALSE;
  int     g = conto.gruppo();
  int     c = conto.conto();
  char tipo = conto.tipo();  
  long s;
  
  real prg_dare, prg_avere, saldo;
  _lista = new TSaldi_list (g,c,_annoese);
  TRecnotype items = _lista->items();
  prg_conto_dare   = 0.00;
  prg_conto_avere  = 0.00;
  for (int i = 0; i < items; i++)
  {
    const TRectype* r = _lista->saldi();
    s = r->get_long(SLD_SOTTOCONTO);
    prg_dare  = 0.00;
    prg_avere = 0.00;  
    conto.set(g, c, s, tipo); //aggiunge a conto s
    if (_richiesta == 1)
      sld.prg_attuali(_annoese,conto,prg_dare,prg_avere);
    else sld.prg_mov_eliminati(_annoese,conto,prg_dare,prg_avere);
    
    saldo = prg_dare - prg_avere;
    prg_conto_dare  += prg_dare;
    prg_conto_avere += prg_avere;
    
    if (prg_dare != ZERO || prg_avere != ZERO)
    {
      esiste_sc = TRUE;
      if (_scelta == 1)
      {
        _tmp_saldi->zero();
        _tmp_saldi->put(SLD_GRUPPO,g);
        _tmp_saldi->put(SLD_CONTO,c);
        _tmp_saldi->put(SLD_SOTTOCONTO,s);
        _tmp_saldi->put(SLD_ANNOES,_annoese);
        _tmp_saldi->put(SLD_FLAGSALINI,tipo);
        _tmp_saldi->put(SLD_PDARE,prg_dare);
        _tmp_saldi->put(SLD_PAVERE,prg_avere);
        if (saldo > 0.00) //va stampato in Dare
          _tmp_saldi->put(SLD_PDAREPRO,saldo);       // W96SALDI del 10-06-96
          //_tmp_saldi->put(SLD_PDARESCA,saldo);
        else
        {
          saldo = saldo * (-1.00); 
          _tmp_saldi->put(SLD_PAVEREPRO,saldo);      // W96SALDI del 10-06-96
          //_tmp_saldi->put(SLD_PAVERESCA,saldo);
        }
        _tmp_saldi->write();
      }
      if (_scelta == 2)
      {
        _ultima_data = UltimaData(conto.gruppo(),conto.conto(),conto.sottoconto());
        _udata_max   = fnc_max(_udata_max,_ultima_data);
      } 
    } 
  }  
  delete _lista;
  return esiste_sc;
}

bool TStampa_riepilogo::preprocess_print(int file, int counter)
{ 
  set_real_picture ("###.###.###.###.###");
  set_print_zero(FALSE);    
  set_magic_currency(TRUE);
  
  _tmp_saldi->setkey(2);
  _prg_dare_tot  = 0.0;
  _prg_avere_tot = 0.0;
  _gprec = -1;
  _cprec = -1;

  return TRUE;
}

tipo TStampa_riepilogo::leggi_conti(int counter)
{
  TRecnotype pos;

  if (counter == 0)
  { 
    _eof = _tmp_saldi->first();
    if (_eof)
      return fine;
  } 
  
  do 
  {   
    _gcorr = _tmp_saldi->get_int(SLD_GRUPPO);
    _ccorr = _tmp_saldi->get_int(SLD_CONTO);
    _scorr = _tmp_saldi->get_long(SLD_SOTTOCONTO);
    pos    = _tmp_saldi->recno();
    _eof   = _tmp_saldi->next();
  } while ( (_scorr == 0l) && (!_eof) );
  
  if ( (_gprec != _gcorr) && (_gprec != -1) )
  {
    CercaConto(_gprec,_cprec);
    CercaGruppo(_gprec);
    _cprec = _ccorr;
    _gprec = _gcorr;
    _tmp_saldi->readat(pos);

    return stampagruppo;
  }

  if ( (_cprec != _ccorr)&&(_cprec != -1) )
  {
    CercaConto(_gprec,_cprec);
    _cprec = _ccorr;
    _tmp_saldi->readat(pos);
    
    return stampaconto;
  }

  if (_eof)
  {
    _ultima_data = UltimaData(_gcorr,_ccorr,_scorr);
    _tmp_saldi->readat(pos);
    _tipo        = _tmp_saldi->get_char(SLD_FLAGSALINI);
    if (_tipo != 'C' && _tipo != 'F')
      _tipo = ' ';
    TConto conto (_gcorr,_ccorr,_scorr,_tipo);
    _descr       = conto.descrizione();
    _prg_dare    = _tmp_saldi->get_real(SLD_PDARE);
    _prg_avere   = _tmp_saldi->get_real(SLD_PAVERE);  
    _saldo_dare  = _tmp_saldi->get_real(SLD_PDAREPRO);     // W96SALDI del 10-06-96
    _saldo_avere = _tmp_saldi->get_real(SLD_PAVEREPRO);

    CercaConto(_gcorr,_ccorr);
    CercaGruppo(_gcorr);

    return fine;
  }

  if ( (_gprec == -1) && (_cprec == -1) )
  {
    _gprec = _gcorr;
    _cprec = _ccorr;
  }
  
  _ultima_data = UltimaData(_gcorr,_ccorr,_scorr);
  _tmp_saldi->readat(pos);
  _tipo        = _tmp_saldi->get_char(SLD_FLAGSALINI);
  if (_tipo != 'C' && _tipo != 'F')
    _tipo = ' ';
  TConto conto (_gcorr,_ccorr,_scorr,_tipo);
  _descr       = conto.descrizione();
  _prg_dare    = _tmp_saldi->get_real(SLD_PDARE);
  _prg_avere   = _tmp_saldi->get_real(SLD_PAVERE);  
  _saldo_dare  = _tmp_saldi->get_real(SLD_PDAREPRO);   // W96SALDI del 10-06-96
  //_saldo_dare  = _tmp_saldi->get_real(SLD_PDARESCA); 
  _saldo_avere = _tmp_saldi->get_real(SLD_PAVEREPRO);
  //_saldo_avere = _tmp_saldi->get_real(SLD_PAVERESCA);
  _tmp_saldi->next();

  return stampasottoconto;
}

tipo TStampa_riepilogo::leggi_gruppi(int counter)
{
  TRecnotype pos;

  if (counter == 0)
  { 
    _eof = _tmp_saldi->first();
    if (_eof)
      return fine;
  }  
  
  do 
  {   
    _gcorr = _tmp_saldi->get_int(SLD_GRUPPO);
    _ccorr = _tmp_saldi->get_int(SLD_CONTO);
    pos    = _tmp_saldi->recno();
    _eof   = _tmp_saldi->next();
  } while ( (_ccorr == 0l) && (!_eof) ); //esco dal ciclo quando ho trovato un gruppo oppure quando e' finito il file
  
  if ( (_gprec != _gcorr) && (_gprec != -1) )
  {
    CercaGruppo(_gprec);
    _gprec = _gcorr;
    _tmp_saldi->readat(pos);

    return stampagruppo;
  }

  if (_eof)
  {
    _tmp_saldi->readat(pos);
    _ultima_data       = _tmp_saldi->get_date(SLD_DATAULMOV);
    _tipo              = _tmp_saldi->get_char(SLD_FLAGSALINI);
    if (_tipo != 'C' && _tipo != 'F')
      _tipo = ' ';
    TConto conto (_gcorr,_ccorr,0l,_tipo);
    _descrconto        = conto.descrizione();
    _prg_dare_conto    = _tmp_saldi->get_real(SLD_PDARE);
    _prg_avere_conto   = _tmp_saldi->get_real(SLD_PAVERE);  
    _saldo_dare_conto  = _tmp_saldi->get_real(SLD_PDAREPRO);       // W96SALDI del 10-06-96
    //_saldo_dare_conto  = _tmp_saldi->get_real(SLD_PDARESCA);
    _saldo_avere_conto = _tmp_saldi->get_real(SLD_PAVEREPRO);
    //_saldo_avere_conto = _tmp_saldi->get_real(SLD_PAVERESCA);

    CercaGruppo(_gcorr);

    return fine;
  }

  if (_gprec == -1) 
    _gprec = _gcorr;
  
  _tmp_saldi->readat(pos);
  _ultima_data       = _tmp_saldi->get_date(SLD_DATAULMOV);
  _tipo              = _tmp_saldi->get_char(SLD_FLAGSALINI);
  if (_tipo != 'C' && _tipo != 'F')
    _tipo = ' ';
  TConto conto (_gcorr,_ccorr,0l,_tipo);
  _descrconto        = conto.descrizione();
  _prg_dare_conto    = _tmp_saldi->get_real(SLD_PDARE);
  _prg_avere_conto   = _tmp_saldi->get_real(SLD_PAVERE);
  _saldo_dare_conto  = _tmp_saldi->get_real(SLD_PDAREPRO);       // W96SALDI del 10-06-96
  //_saldo_dare_conto  = _tmp_saldi->get_real(SLD_PDARESCA);      
  _saldo_avere_conto = _tmp_saldi->get_real(SLD_PAVEREPRO);
  //_saldo_avere_conto = _tmp_saldi->get_real(SLD_PAVERESCA);
  _tmp_saldi->next();

  return stampaconto;
}


bool TStampa_riepilogo::CercaConto(int g, int c)
{
  _tmp_saldi->zero();
  _tmp_saldi->put(SLD_GRUPPO,g);
  _tmp_saldi->put(SLD_CONTO,c);
  _tmp_saldi->put(SLD_SOTTOCONTO,0l);
  _tmp_saldi->put(SLD_ANNOES,_annoese);
  _tmp_saldi->put(SLD_FLSCA,FALSE);         // W96SALDI del 10-06-96
  if (_tmp_saldi->read() == NOERR)
  {
    _gconto            = _tmp_saldi->get_int(SLD_GRUPPO);
    _cconto            = _tmp_saldi->get_int(SLD_CONTO);
    _tipo              = _tmp_saldi->get_char(SLD_FLAGSALINI);
    if (_tipo != 'C' && _tipo != 'F')
      _tipo = ' ';
    if (_scelta == 2)
      _ultima_data = _tmp_saldi->get_date(SLD_DATAULMOV); 
    TConto conto       (_gconto,_cconto,0l,_tipo);
    _descrconto        = conto.descrizione();
    _prg_dare_conto    = _tmp_saldi->get_real(SLD_PDARE);
    _prg_avere_conto   = _tmp_saldi->get_real(SLD_PAVERE);  
    _saldo_dare_conto  = _tmp_saldi->get_real(SLD_PDAREPRO);
    //_saldo_dare_conto  = _tmp_saldi->get_real(SLD_PDARESCA);   // W96SALDI del 10-06-96
    _saldo_avere_conto = _tmp_saldi->get_real(SLD_PAVEREPRO);
    //_saldo_avere_conto = _tmp_saldi->get_real(SLD_PAVERESCA);
    
    return TRUE;
  }
  return FALSE;
}

bool TStampa_riepilogo::CercaGruppo(int g)
{
  _tmp_saldi->zero();
  _tmp_saldi->put(SLD_GRUPPO,g);
  _tmp_saldi->put(SLD_CONTO,0);
  _tmp_saldi->put(SLD_SOTTOCONTO,0l);
  _tmp_saldi->put(SLD_ANNOES,_annoese);
  _tmp_saldi->put(SLD_FLSCA, "");
  if (_tmp_saldi->read() == NOERR)
  {
    _ggruppo            = _tmp_saldi->get_int(SLD_GRUPPO);
    _tipo               = _tmp_saldi->get_char(SLD_FLAGSALINI);
    if (_tipo != 'C' && _tipo != 'F')
      _tipo = ' ';
    TConto conto        (_ggruppo,0,0l,_tipo);
    _descrgruppo        = conto.descrizione();
    _prg_dare_gruppo    = _tmp_saldi->get_real(SLD_PDARE);
    _prg_avere_gruppo   = _tmp_saldi->get_real(SLD_PAVERE);  
    _saldo_dare_gruppo  = _tmp_saldi->get_real(SLD_PDAREPRO);        // W96SALDI del 10-06-96
    //_saldo_dare_gruppo  = _tmp_saldi->get_real(SLD_PDARESCA);
    _saldo_avere_gruppo = _tmp_saldi->get_real(SLD_PAVEREPRO);
    //_saldo_avere_gruppo = _tmp_saldi->get_real(SLD_PAVERESCA);
    _prg_dare_tot      += _prg_dare_gruppo;
    _prg_avere_tot     += _prg_avere_gruppo;

    return TRUE;
  }
  return FALSE;
}

bool TStampa_riepilogo::preprocess_page(int file, int counter)
{
  reset_print();
  
  if (_scelta == 1)
    _tp = leggi_conti(counter);
  if (_scelta == 2)
    _tp = leggi_gruppi(counter);
  
  if (_tp == fine && counter == 0)
    return FALSE;
  
  if (_tp == fine) 
  {
    if (_scelta == 1)
      setta_riga_sottoconto();
    setta_riga_conto();
    setta_riga_gruppo();
    setta_riga_totale();
  }
  if (_tp == stampagruppo)
  {
    if ( _scelta == 1) setta_riga_conto();
    setta_riga_gruppo();
  }
  if (_tp == stampaconto) 
    setta_riga_conto();
  if (_tp == stampasottoconto)
    setta_riga_sottoconto();

  return TRUE;
}

void TStampa_riepilogo::postclose_print()
{                    
  if (_tmp_saldi)
  { delete _tmp_saldi; _tmp_saldi = NULL; }

  //return NEXT_PAGE;
} 

print_action TStampa_riepilogo::postprocess_page(int file, int counter)
{
  if (_tp == fine)
    return NEXT_PAGE;

  return REPEAT_PAGE;
}

void TStampa_riepilogo::setta_riga_sottoconto()
{
  TString udata = _ultima_data.string();
  
  set_row(1,"%6ld",  _scorr);
  set_row(1," %.34s@r",(const char*) _descr);
  set_row(1,"@42g%s",(const char*) udata);
  set_row(1,"@53g%r@73g%r@93g%r@113g%r",&_prg_dare,&_prg_avere,&_saldo_dare,&_saldo_avere);
}

void TStampa_riepilogo::setta_riga_conto()
{
  TString riga (132);
  TString udata = _ultima_data.string();
  int r; 

  riga = "";
  if ( (_tp == fine) && (_scelta == 1) ) 
    r = 2;
  else 
    r = 1;
  
  if (_scelta == 1)
  {
    set_row(r++,"%s",(const char*)riga);
    set_row(r,FR("**** Totali conto  %3d %3d"),_gconto,_cconto);
    set_row(r,"@27g%.25s@r",(const char*)_descrconto);

  }
  if (_scelta == 2)
  {
    set_row(r,"%3d",  _ccorr);
    set_row(r," %.25s@r",(const char*)_descrconto);
    set_row(r,"@42g%s",(const char*)udata);
  }
  set_row(r++,"@53g%r@73g%r@93g%r@113g%r",&_prg_dare_conto,&_prg_avere_conto,&_saldo_dare_conto,&_saldo_avere_conto);
  if ( (_scelta == 1) || ((_scelta == 2) && (_tp == fine)) )
    set_row(r,"%s",(const char*)riga);
}

void TStampa_riepilogo::setta_riga_gruppo()
{
  TString riga (132);
  int r = 0;

  riga.fill('-');
  if (_scelta == 1)
    if (_tp == fine) r = 5;
    else r = 4;
  if (_scelta == 2)
    if (_tp == fine) r = 3;
    else r = 2;
  set_row(r,FR("**** TOTALI GRUPPO %3d"),_ggruppo);
  set_row(r,"@27g%.25s@r",(const char*)_descrgruppo);
  set_row(r++,"@53g%r@73g%r@93g%r@113g%r",&_prg_dare_gruppo,&_prg_avere_gruppo,&_saldo_dare_gruppo,&_saldo_avere_gruppo);
  set_row(r++,"%s",(const char*)riga);
  riga = "";
  set_row(r,"%s",(const char*)riga);
}

void TStampa_riepilogo::setta_riga_totale()
{
  _saldo_tot = _prg_dare_tot - _prg_avere_tot;

  const int r = _scelta == 1 ? 8 : 6; 

  //17/11/1995
  set_row(r, FR("****  TOTALE GENERALE @53g%r@73g%r"), &_prg_dare_tot, &_prg_avere_tot);
  
  // Guy: 10/01/97 errore MI6125
  if (_saldo_tot != 0.0)
  {              
    int go = 93;
    if (_saldo_tot < 0.0)
    {
      _saldo_tot = -_saldo_tot;
      go += 20;
    }

    TString16 st;
    st << '@' << go << "g%r";
    set_row(r, st, &_saldo_tot);    
  }  
}

TDate TStampa_riepilogo::UltimaData(int g, int c, long s)
{ 
  TLocalisamfile saldi(LF_SALDI);
  TDate uldata;

  saldi.zero();
  if (_annoese != 0)
    saldi.put(SLD_ANNOES, _annoese);
  saldi.put(SLD_FLSCA, FALSE);            // W96SALDI del 10-06-96
  saldi.put(SLD_GRUPPO,g);
  if (c != 0)
    saldi.put(SLD_CONTO, c);
  if (s != 0)
    saldi.put(SLD_SOTTOCONTO, s);
  saldi.read();
  if (saldi.bad())
    saldi.zero();
  uldata = saldi.get(SLD_DATAULMOV);

  return uldata;  
} 

bool TStampa_riepilogo::user_create()
{
  open_files(LF_CLIFO, LF_COMUNI, LF_PCON, LF_SALDI, LF_NDITTE, LF_ANAG, 
						 LF_TABCOM, LF_TAB, 0);
  _tmp_saldi = NULL;
  return TRUE;
}

bool TStampa_riepilogo::user_destroy()
{
  delete _tmp_saldi;
  return TRUE;
}

bool TStampa_riepilogo::set_print(int)
{
  TMask m ("cg3500a");
  if (m.run() == K_ENTER)
  {
    _annoese   = m.get_int(F_ANNO);
    _scelta    = m.get_int(F_STAMPA);
    _richiesta = m.get_int(F_RICHIESTA);
    _data      = m.get(F_DATASTAMPA);
    riepilogo();

    return TRUE;
  }
  return FALSE;
}

void TStampa_riepilogo::get_dati_ditta()
{
  TString        codanagr;
  TString        tipoa;

	const TRectype & nditte = cache().get(LF_NDITTE, get_firm());

  codanagr = nditte.get(NDT_CODANAGR);
  tipoa    = nditte.get(NDT_TIPOA);
  _ragsoc  = nditte.get(NDT_RAGSOC);

	TToken_string key;
  key.add(tipoa);
  key.add(codanagr);

	const TRectype & anag = cache().get(LF_ANAG, key);
  
  _cofi      = anag.get(ANA_COFI);
  _paiva     = anag.get(ANA_PAIV);
  _comunefis = anag.get(ANA_COMRF);

  if (_comunefis.empty()) 
    _comunefis   = anag.get(ANA_COMRES);

	key.cut(0);
	key.add("");
	key.add(_comunefis);

  const TRectype & com = cache().get(LF_COMUNI, key);

  _comunefis   = com.get(COM_DENCOM);
  _provfis     = com.get(COM_PROVCOM);
  _cap         = com.get(COM_CAPCOM);
  if (_comunefis.empty()) 
  {
    _viafis      = anag.get(ANA_INDRF);
    _viafis.rtrim();
    _viafis << " " << anag.get (ANA_CIVRF); 
  }
  else
  {
    _viafis      = anag.get(ANA_INDRES);
    _viafis.rtrim();
    _viafis << " " << anag.get (ANA_CIVRES); 
  }
}

int TStampa_riepilogo::stampa_intestazione_ditta()
{
  int r = 1;
  TString codice_ditta;
  TString riga(132);

  get_dati_ditta();
  codice_ditta << get_firm(); 

  set_header (r, FR("Ditta %s %s %s %s %s %s"), (const char*)codice_ditta,
              (const char*)_ragsoc, (const char*)_viafis,
              (const char*)_cap, (const char*)_comunefis,
              (const char*)_provfis);
  r++;
  printer().setdate(_data);
  riga = FR("Data @<  Pag. @#");
  riga.right_just(127);
  riga.overwrite (format (FR("Partita iva %s Codice fiscale %s"), (const char*)_paiva, (const char*)_cofi));
  set_header (r, "%s", (const char*) riga);
  r++;

  return r; 
}

void TStampa_riepilogo::preprocess_header()
{
  int r;
  reset_header();
  r = stampa_intestazione_ditta();
  TString riga (132); 

  r++;
  if (_scelta == 1) //stampa riepilogo conti
    set_header(r,TR("*** MASTRO DI CONTO ***"));
  else set_header(r,TR("*** MASTRO DI GRUPPO ***"));
  set_header(r,FR("@33gCod. esercizio %d"), _annoese);
  if (_richiesta == 1)
    set_header(r,FR("@70gPROGRESSIVI ATTUALI@114gSALDO ATTUALE"));
  else set_header(r,FR("@70gPROG. MOV. ELIMINATI@110gSALDO MOV. ELIMINATI"));     
  
  r++;
  r++;
  if (_scelta == 1)
    set_header(r,TR("SOTTOC DESCRIZIONE"));
  else set_header(r,TR("CONTO DESCRIZIONE"));
  set_header(r++,FR("@40gDATA ULT.MOV@68gDARE@87gAVERE@108gDARE@127gAVERE"));
  riga.fill('-');
  set_header(r,"%s",(const char*)riga);
  r++;
  riga = "";
  set_header(r,"%s",(const char*)riga);
}

int cg3500 (int argc, char* argv[])
{
  TStampa_riepilogo a;
  a.run(argc, argv, TR("Stampa riepilogo gruppi/conti"));
  return 0;
}