//Stampa riepilogo gruppi/conti

#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 "cglib.h"
#include "cg3.h"
#include "cg3500.h"

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

class CG3500_application : public TPrintapp
{
  TProgind * _prog;
  TSaldi_list* _lista;
  TLocalisamfile* _com, * _pcn, * _clifo, * _saldi, * _nditte,* _anag;
  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:

  bool menu (MENU_TAG m) { return TPrintapp::menu(m) ; }
  bool user_create() ;
  bool user_destroy();
  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);
  
  CG3500_application() {} 
};

bool CG3500_application::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", 2);

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

  for (_pcn->first(); !_pcn->eof(); _pcn->next())
  {
    _prog->addstatus(1);
    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_PDARESCA,saldo_conto);
      else
      {
        saldo_conto = saldo_conto * (-1.00); 
        _tmp_saldi->put(SLD_PAVERESCA,saldo_conto);
      }
      _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_PDARESCA,saldo_gruppo);
      else
      {
        saldo_gruppo = saldo_gruppo * (-1.00); 
        _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();
        }
        TRecnotype recnum = _pcn->recno();
        _pcn->next();
        if (_pcn->eof())
        {  
          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_PDARESCA,saldo_conto);
            else
            {
              saldo_conto = saldo_conto * (-1.00); 
              _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_PDARESCA,saldo_gruppo);
            else
            {
              saldo_gruppo = saldo_gruppo * (-1.00); 
              _tmp_saldi->put(SLD_PAVERESCA,saldo_gruppo);
            }
            _tmp_saldi->write();
          }  
        } 
        _pcn->readat(recnum);
        
        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_PDARESCA,saldo);
        else
        {
          saldo = saldo * (-1.00); 
          _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();
    }
    
    TRecnotype recnum = _pcn->recno();
    _pcn->next();
    if (_pcn->eof())
    {
      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_PDARESCA,saldo_conto);
        else
        {
          saldo_conto = saldo_conto * (-1.00); 
          _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_PDARESCA,saldo_gruppo);
        else
        {
          saldo_gruppo = saldo_gruppo * (-1.00); 
          _tmp_saldi->put(SLD_PAVERESCA,saldo_gruppo);
        }
        _tmp_saldi->write();
      } 
    }
    _pcn->readat(recnum);
  }  
  return TRUE;
}

bool CG3500_application::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++)
  {
    _prog->addstatus(1);
    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_PDARESCA,saldo);
        else
        {
          saldo = saldo * (-1.00); 
          _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 CG3500_application::preprocess_print(int file, int counter)
{
  set_real_picture ("###.###.###.###");
  set_print_zero(FALSE);
  _tmp_saldi->setkey(2);
  _prg_dare_tot  = 0.00;
  _prg_avere_tot = 0.00;
  _gprec = -1;
  _cprec = -1;

  return TRUE;
}

tipo CG3500_application::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_PDARESCA);
    _saldo_avere = _tmp_saldi->get_real(SLD_PAVERESCA);

    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_PDARESCA);
  _saldo_avere = _tmp_saldi->get_real(SLD_PAVERESCA);
  _tmp_saldi->next();

  return stampasottoconto;
}

tipo CG3500_application::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_PDARESCA);
    _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_PDARESCA);
  _saldo_avere_conto = _tmp_saldi->get_real(SLD_PAVERESCA);
  _tmp_saldi->next();

  return stampaconto;
}


bool CG3500_application::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);
  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_PDARESCA);
    _saldo_avere_conto = _tmp_saldi->get_real(SLD_PAVERESCA);
    
    return TRUE;
  }
  return FALSE;
}

bool CG3500_application::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);
  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_PDARESCA);
    _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 CG3500_application::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 CG3500_application::postclose_print()
{                    
  if (_tmp_saldi)
  { delete _tmp_saldi; _tmp_saldi = NULL; }

  //return NEXT_PAGE;
} 

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

  return REPEAT_PAGE;
}

void CG3500_application::setta_riga_sottoconto()
{
  TString udata = _ultima_data.string();
  
  //set_row(1,"%06ld",  _scorr);
  set_row(1,"%6ld",  _scorr);
  //set_row(1,"@i %.32s@r",(const char*) _descr);
  set_row(1," %.32s@r",(const char*) _descr);
  set_row(1,"@42g%s",(const char*) udata);
  set_row(1,"@57g%r@77g%r@97g%r@117g%r",&_prg_dare,&_prg_avere,&_saldo_dare,&_saldo_avere);
}

void CG3500_application::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,"****  Totali conto   %03d.%03d",_gconto,_cconto);
    set_row(r,"****  Totali conto   %3d %3d",_gconto,_cconto);
    // set_row(r,"@i %.27s@r",(const char*)_descrconto);
    set_row(r," %.27s@r",(const char*)_descrconto);

  }
  if (_scelta == 2)
  {
    set_row(r,"%3d",  _ccorr);
    //set_row(r,"@i %.32s@r",(const char*)_descrconto);
    set_row(r," %.32s@r",(const char*)_descrconto);
    set_row(r,"@42g%s",(const char*)udata);
  }
  set_row(r++,"@57g%r@77g%r@97g%r@117g%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 CG3500_application::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,"****  TOTALI GRUPPO  %3d-",_ggruppo);
  set_row(r,"****  TOTALI GRUPPO  %3d ",_ggruppo);
  //set_row(r,"@i %.30s@r",(const char*)_descrgruppo);
  set_row(r," %.30s@r",(const char*)_descrgruppo);
  set_row(r++,"@57g%r@77g%r@97g%r@117g%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 CG3500_application::setta_riga_totale()
{
  int r;

  _saldo_tot = _prg_dare_tot - _prg_avere_tot;
  if (_scelta == 1) r = 8;
  else r = 6; 
  //17/11/1995
  TString pdt(_prg_dare_tot.string("#.###.###.###.###"));
  TString pat(_prg_avere_tot.string("#.###.###.###.###"));
  //set_row(r,"****  TOTALE GENERALE @57g%r@77g%r",&_prg_dare_tot,&_prg_avere_tot);
  set_row(r,"****  TOTALE GENERALE @55g%s@75g%s",(const char*)pdt,(const char*)pat);

  if (_saldo_tot > 0.00)
  {
    //set_row(r,"@97g%r",&_saldo_tot);
    TString st(_saldo_tot.string("#.###.###.###.###"));
    set_row(r,"@95g%s",(const char*)st);
  }
  else
  {
    _saldo_tot = _saldo_tot * (-1.00);
    TString st(_saldo_tot.string("#.###.###.###.###"));
    //set_row(r,"@117g%r",&_saldo_tot);
    set_row(r,"@115g%s",(const char*)st);    
  }
}

TDate CG3500_application::UltimaData(int g, int c, long s)
{
  TLocalisamfile saldi(LF_SALDI, FALSE); //il parametro a false permette di usare un record corrente del file saldi differente a quello del file temporaneo
  TDate uldata;

  saldi.zero();
  if (_annoese != 0)
    saldi.put(SLD_ANNOES, _annoese);
  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 CG3500_application::user_create()
{
  _clifo     = new TLocalisamfile(LF_CLIFO);
  _com       = new TLocalisamfile(LF_COMUNI);
  _pcn       = new TLocalisamfile(LF_PCON); 
  _saldi     = new TLocalisamfile(LF_SALDI);
  _nditte    = new TLocalisamfile(LF_NDITTE);
  _anag      = new TLocalisamfile(LF_ANAG);
  _tmp_saldi = NULL;
  return TRUE;
}

bool CG3500_application::user_destroy()
{
  delete _com;
  delete _pcn;
  delete _clifo;
  delete _saldi;
  delete _nditte;
  delete _anag;
  delete _tmp_saldi;
  return TRUE;
}

bool CG3500_application::set_print(int)
{
  TMask m ("cg3500a");
  KEY tasto;
  
  tasto = m.run();
  if (tasto == K_ENTER)
  {
    _annoese   = atoi(m.get(F_ANNO));
    _scelta    = atoi(m.get(F_STAMPA));
    _richiesta = atoi(m.get(F_RICHIESTA));
    _data      = m.get(F_DATASTAMPA);
    _prog = new TProgind(_pcn->items(),"Elaborazione in corso... prego attendere",FALSE);

    riepilogo();

    delete _prog;
    return TRUE;
  }
  return FALSE;
}

TRectype& cerca_com (const char * cod, TLocalisamfile *comuni)
{
  comuni->zero();
  comuni->put(COM_COM, cod);
  comuni->read();
  if (comuni->bad())
    comuni->zero();

  return comuni->curr();
}

void CG3500_application::get_dati_ditta()
{
  TLocalisamfile nditte(LF_NDITTE); 
  TLocalisamfile anag(LF_ANAG); 
  TString        codanagr;
  TString        tipoa;

  nditte.zero();
  nditte.put(NDT_CODDITTA, get_firm());   
  nditte.read();

  if (nditte.bad()) nditte.zero();

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

  anag.setkey(1);
  anag.zero();
  anag.put (ANA_TIPOA, tipoa);
  anag.put (ANA_CODANAGR, codanagr);
  anag.read();
  if (anag.bad()) anag.zero();
  
  _cofi      = anag.get(ANA_COFI);
  _paiva     = anag.get(ANA_PAIV);
  _comunefis = anag.get(ANA_COMRF);

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

  TRectype dep = cerca_com (_comunefis, _com);

  _comunefis   = dep.get(COM_DENCOM);
  _provfis     = dep.get(COM_PROVCOM);
  _cap         = dep.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 CG3500_application::stampa_intestazione_ditta()
{
  int r = 1;
  TString codice_ditta;
  TString riga(132);

  get_dati_ditta();
  codice_ditta << get_firm(); 

  set_header (r, "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 = "Data @<  Pag. @#";
  riga.right_just(127);
  riga.overwrite (format ("Partita iva %s Codice fiscale %s", (const char*)_paiva, (const char*)_cofi));
  set_header (r, "%s", (const char*) riga);
  r++;

  return r; 
}

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

  r++;
  if (_scelta == 1) //stampa riepilogo conti
    set_header(r,"*** MASTRO DI CONTO ***");
  else set_header(r,"*** MASTRO DI GRUPPO ***");
  set_header(r,"@33gAnno esercizio %d", _annoese);
  if (_richiesta == 1)
    set_header(r,"@70gPROGRESSIVI ATTUALI@114gSALDO ATTUALE");
  else set_header(r,"@70gPROG. MOV. ELIMINATI@110gSALDO MOV. ELIMINATI");     
  
  r++;
  r++;
  if (_scelta == 1)
    set_header(r,"SOTTOC DESCRIZIONE");
  else set_header(r,"CONTO DESCRIZIONE");
  set_header(r++,"@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[])
{

  CG3500_application a;

  a.run(argc, argv, "Stampa riepilogo gruppi/conti");

  return 0;
}






