// Chiusura/Apertura Conti

#include <mask.h>
#include <printapp.h>
#include <relation.h>
#include <tabutil.h>
#include <utility.h>
#include <config.h>
#include <urldefid.h>

#include "cglib.h"
#include "cg4.h"
#include "cg4600.h"
#include "cg2101.h"

#include <pconti.h>
#include <mov.h>
#include <saldi.h>
#include <rmov.h>

bool mask_datac    (TMask_field&, KEY);
bool mask_dataap   (TMask_field&, KEY);
bool mask_distinti (TMask_field&, KEY);

#define MAX 200

class CG4600_application : public TApplication
{
  friend bool mask_datac    (TMask_field&, KEY);
  friend bool mask_dataap   (TMask_field&, KEY);
  friend bool mask_distinti (TMask_field&, KEY);
  
  TTable*         _esc, * _reg; 
  TRelation*      _rel;
  TMovimentoPN*   _pn;
  TLocalisamfile* _saldi;
  TRectype*       _rec;
  TLocalisamfile* _mov;
  TCursor*        _cur;
  TSaldo_agg*     _sld;
  Saldo*          _sale;
  TConto          _tcbilch,_tcproper,_tcbilap,_tcutilp,_tcperdp,_tcutile,_tcperde, _conto_corrente;

  real    _saldo, _totale_saldo;
  int     _annoesch, _annoesap;
  long    _numreg;
  TDate   _dataregap, _dataregch;
  TString _codcausap, _codcausch;
  
public:
  virtual bool create();
  virtual bool destroy();
  virtual bool menu(MENU_TAG m);
  void costi ();
  void ricavi();
  void attivita();
  void passivita();
  void rmov_proper (int, long, TDate&, TRectype&, TConto&, real&, bool);
  void ultima_registrazione();
  void compila_testata(int,TDate&,TString&);
  void chiusura_conto_economico();
  void chiusura_conto_patrimoniale();
  bool  set();
  //    bool  epilogo_conti();
  
  CG4600_application() {}
};

HIDDEN CG4600_application* app() { return (CG4600_application *) MainApp(); }

bool mask_datac (TMask_field& f, KEY k)
{ 
  TTable TabEs ("ESC");
  TTable TabReg("REG");
  TString annos (4);
  int anno = 0;;
  bool ok = TRUE;

  if ( (k == K_ENTER) && f.to_check(k) )
  {
    TabEs.last();
    TDate inizio  = TabEs.get_date("D0");
    TDate fine    = TabEs.get_date("D1");
    TDate scarico = TabEs.get_date("D2");
    TabEs.prev();
    TDate iniziop = TabEs.get_date("D0");                     
    TDate finep   = TabEs.get_date("D1");
    if (f.get() < finep)
    {
      f.warning_box ("La data di chiusura non puo' essere inferiore alla data di fine esercizio precedente");
      return FALSE;
    }
    if (f.get() > fine)
    {
      f.warning_box ("La data di chiusura non puo' essere superiore alla data di fine esercizio in corso");
      return FALSE;
    }
    if ( scarico.ok() && (f.get() <= scarico) )
    {
      f.warning_box ("La data di chiusura non puo' essere inferiore o uguale alla data di scarico"); 
      return FALSE;
    }
    if ( (f.get() >= inizio) && (f.get() <= fine) ) //la data di chiusura e' cioe' relativa all'esercizio in corso   
      anno = fine.year();
else if ( (f.get() >= iniziop) && (f.get() <= finep) ) //la data di chiusura e' cioe' relativa all'esercizio precedente 
  anno = finep.year();
    
    TabReg.zero();
    annos = format ("%04d", anno);
    TabReg.put ("CODTAB", annos);
    TRectype r (TabReg.curr());
    TabReg.read(_isgteq);
    for (; !TabReg.eof(); TabReg.next())
    {
      if (TabReg.curr() != r) break;
      
      int tiporeg = TabReg.get_int("I0");
      if (tiporeg == 5)
      {
        TDate datast = TabReg.get_date("D3");
        if (f.get() < datast.string())
        {
          ok = FALSE;
          break;
        }  
      }     
    }
    if (!ok)
    {
      f.warning_box("La data di chiusura non puo' essere inferiore alla data ultima stampa bollato"); 
      return FALSE;
    }
  }     
  return TRUE;
}

bool mask_dataap (TMask_field& f, KEY k)
{
  TTable TabEs ("ESC");
  TTable TabReg("REG"); 
  int anno = 0;
  TString annos (4);
  bool ok = TRUE;

  if ( (k == K_ENTER) && f.to_check(k) )
  {
    TabEs.last();
    TDate inizio  = TabEs.get_date("D0");
    TDate fine    = TabEs.get_date("D1");
    TDate scarico = TabEs.get_date("D2");
    TabEs.prev();
    TDate iniziop = TabEs.get_date("D0");
    TDate finep   = TabEs.get_date("D1");
    if (f.get() < inizio)
    {
      f.warning_box ("La data di apertura non puo' essere inferiore alla data di inizio esercizio in corso");
      return FALSE;
    }
    if (f.get() > fine)
    {
      f.warning_box ("La data di apertura non puo' essere superiore alla data di fine esercizio in corso");
      return FALSE;
    }
    if ( scarico.ok() && (f.get() <= scarico) )
    {
      f.warning_box ("La data di apertura non puo' essere inferiore o uguale alla data di scarico"); 
      return FALSE;
    }
    
    if ( (f.get() >= inizio) && (f.get() <= fine) ) //la data di apertura e' cioe' relativa all'esercizio in corso   
      anno = fine.year();
else if( (f.get() >= iniziop) && (f.get() <= finep) ) //la data di apertura e' cioe' relativa all'esercizio precedente 
  anno = finep.year();
    
    TabReg.zero();
    annos = format ("%04d", anno);
    TabReg.put ("CODTAB", annos);
    TRectype r (TabReg.curr());
    TabReg.read(_isgteq);
    for (; !TabReg.eof(); TabReg.next())
    {
      if (TabReg.curr() != r) break;
      
      int tiporeg = TabReg.get_int("I0");
      if (tiporeg == 5)
      {
        TDate datast = TabReg.get_date("D3");
        if (f.get() < datast)
        {
          ok = FALSE;
          break;
        }  
      }     
    }
    if (!ok)
    {
      f.warning_box("La data di apertura non puo' essere inferiore alla data ultima stampa bollato"); 
      return FALSE;
    }
  }     
  return TRUE;
}  

bool mask_distinti (TMask_field& f, KEY k)
{
  int idg,idc,ids,idg1,idc1,ids1;

  if (k == K_ENTER)
  {
    idg = 108;
    idc = 109;
    ids = 110;

    for (int i = 0; i < 7; i++)
    {
      int  g = f.mask().get_int(idg);
      int  c = f.mask().get_int(idc);
      long s = f.mask().get_long(ids);
      
      idg1 = idg;
      idc1 = idc;
      ids1 = ids;
      
      for (int j = i+1; j < 7; j++)
      {
        idg1 = idg1 + 3;
        idc1 = idc1 + 3;
        ids1 = ids1 + 3;
        
        int  gruppo = f.mask().get_int(idg1);
        int  conto  = f.mask().get_int(idc1);
        long sottoc = f.mask().get_long(ids1);
        
        if ((g == gruppo)&&(c == conto)&&(s == sottoc))
        {
          f.warning_box("Nessun sottoconto puo' essere ripetuto!");
          return FALSE;
        }
      }
      
      idg = idg + 3;
      idc = idc + 3;
      ids = ids + 3;
      
    }   
  }
  return TRUE;
}

bool CG4600_application::create()
{
  TApplication::create();

  _rel   = new TRelation (LF_PCON);

  _cur   = new TCursor(_rel,"((GRUPPO!=\"\")&&(CONTO!=\"\")&&(SOTTOCONTO==\"\"))",1);

  _pn    = new TMovimentoPN();
  _saldi = new TLocalisamfile (LF_SALDI);
  _rec   = new TRectype(LF_SALDI);
  _mov   = new TLocalisamfile (LF_MOV);
  _esc   = new TTable ("ESC");
  _reg   = new TTable ("REG");
  _sld   = new TSaldo_agg();
  _sale  = new Saldo();

  dispatch_e_menu (BAR_ITEM(1));

  return TRUE;
}

bool CG4600_application::destroy()
{
  delete _saldi;
  delete _sale;
  delete _mov;
  delete _esc;
  delete _reg;
  delete _pn;
  delete _rel;
  delete _cur;
  delete _sld;
  delete _rec;

  return TApplication::destroy();
}

void CG4600_application::ultima_registrazione()
{
  long numregmov;

  _mov->setkey(1);                        //Leggo il numero di registrazione
  _mov->last();                           //dell'ultimo record di mov, e lo 
  numregmov = _mov->get_long(MOV_NUMREG); //incremento di uno per ottenere
  _numreg    = numregmov + 1;             //un numero di registrazione 
  //sicuramente non esistente.
}

bool CG4600_application::set()
{
  TTable TabEs ("ESC");
  TMask m ("cg4600a");
  KEY     tasto;
  int     gbilch, cbilch , gproper, cproper, gbilap, cbilap, gutilp;
  int     cutilp, gperdp, cperdp, gutile, cutile, gperde, cperde;
  long    sbilch, sproper, sbilap, sutilp, sperdp, sutile, sperde;


  TConfig conf(CONFIG_DITTA);
  
  m.set(F_CHIUSURA, conf.get("CoCaCh"));
  m.set(F_APERTURA, conf.get("CoCaAp"));
  
  TabEs.last();
  int   annoap   = TabEs.get_int ("CODTAB"); 
  TDate inizio = TabEs.get_date("D0"); //data inizio es. in corso
  TabEs.prev();
  int   annoch   = TabEs.get_int ("CODTAB");
  TDate fine   = TabEs.get_date("D1"); //data fine es. precedente
  m.set(F_ANNO,   annoap);
  m.set(F_ANNOCH, annoch);
  m.set(F_DATAC, fine.string());
  m.set(F_DATAAP,inizio.string());  
  
  m.set(F_BILCHG,  conf.get("CsBiChG"));
  m.set(F_BILCHC,  conf.get("CsBiChC"));
  m.set(F_BILCHS,  conf.get("CsBiChS"));
  m.set(F_PROPERG, conf.get("CsPrPeG"));
  m.set(F_PROPERC, conf.get("CsPrPeC"));
  m.set(F_PROPERS, conf.get("CsPrPeS"));
  m.set(F_BILAPG,  conf.get("CsBiApG"));
  m.set(F_BILAPC,  conf.get("CsBiApC"));
  m.set(F_BILAPS,  conf.get("CsBiApS"));
  m.set(F_UTILPG,  conf.get("CsUeCpG"));
  m.set(F_UTILPC,  conf.get("CsUeCpC"));
  m.set(F_UTILPS,  conf.get("CsUeCpS"));
  m.set(F_PERDPG,  conf.get("CsPeCpG"));
  m.set(F_PERDPC,  conf.get("CsPeCpC"));
  m.set(F_PERDPS,  conf.get("CsPeCpS"));
  m.set(F_UTILEG,  conf.get("CsUeCeG"));
  m.set(F_UTILEC,  conf.get("CsUeCeC"));
  m.set(F_UTILES,  conf.get("CsUeCeS"));
  m.set(F_PERDEG,  conf.get("CsPeCeG"));
  m.set(F_PERDEC,  conf.get("CsPeCeC"));
  m.set(F_PERDES,  conf.get("CsPeCeS"));
  
  m.set_handler (F_DATAC,  mask_datac);
  m.set_handler (F_DATAAP, mask_dataap);
  m.set_handler (F_PERDES, mask_distinti);
  
  tasto = m.run();

  if (tasto == K_ENTER)
  {
    _annoesch   = m.get_int(F_ANNOCH);
    _annoesap   = m.get_int(F_ANNO);
    _dataregch  = m.get     (F_DATAC);
    _codcausch  = m.get     (F_CHIUSURA);
    _dataregap  = m.get     (F_DATAAP);
    _codcausap  = m.get     (F_APERTURA);
    gbilch      = m.get_int (F_BILCHG);
    cbilch      = m.get_int (F_BILCHC);
    sbilch      = m.get_long(F_BILCHS);
    gproper     = m.get_int (F_PROPERG);
    cproper     = m.get_int (F_PROPERC);
    sproper     = m.get_long(F_PROPERS);
    gbilap      = m.get_int (F_BILAPG);
    cbilap      = m.get_int (F_BILAPC);
    sbilap      = m.get_long(F_BILAPS);
    gutilp      = m.get_int (F_UTILPG);
    cutilp      = m.get_int (F_UTILPC);
    sutilp      = m.get_long(F_UTILPS);
    gperdp      = m.get_int (F_PERDPG);
    cperdp      = m.get_int (F_PERDPC);
    sperdp      = m.get_long(F_PERDPS);
    gutile      = m.get_int (F_UTILEG);
    cutile      = m.get_int (F_UTILEC);
    sutile      = m.get_long(F_UTILES);
    gperde      = m.get_int (F_PERDEG);
    cperde      = m.get_int (F_PERDEC);
    sperde      = m.get_long(F_PERDES);         

    _tcbilch.set (gbilch,cbilch,sbilch);
    _tcproper.set(gproper,cproper,sproper);
    _tcbilap.set (gbilap,cbilap,sbilap);
    _tcutilp.set (gutilp,cutilp,sutilp);
    _tcperdp.set (gperdp,cperdp,sperdp);
    _tcutile.set (gutile,cutile,sutile);
    _tcperde.set (gperde,cperde,sperde);

    ultima_registrazione();
    //    anno_ese_precedente();

    (*_cur) = 0L;

    _sld->set_anno_es(_annoesch);
    _sld->set_movprovv(FALSE);
    _sld->set_movap(FALSE);

    costi ();

    _sld->reset();        //Azzera la tabella dei conti dell'oggetto TSaldo_agg
    _pn->destroy_rows();  //Azzero l'oggetto pn.
    ultima_registrazione();
    *_cur = 0l;

    ricavi();
    _sld->reset();

    chiusura_conto_economico();
    _totale_saldo = ZERO;
    _sld->reset();

    _pn->destroy_rows();  //Azzero l'oggetto pn.
    ultima_registrazione();
    *_cur = 0l;

    attivita();
    _sld->reset();

    _pn->destroy_rows();  //Azzero l'oggetto pn.
    ultima_registrazione();
    *_cur = 0l;
    
    passivita();
    _sld->reset();
    chiusura_conto_patrimoniale();

    return TRUE;
  }                              //K_ENTER
  return FALSE;
}

void CG4600_application::compila_testata(int annoes,TDate& datareg,                                                     TString& codcaus)
{
  _pn->lfile().zero(); 
  _pn->lfile().put(MOV_ANNOES,  annoes);     //Viene generato un mov
  _pn->lfile().put(MOV_DATAREG, datareg);    //quando si incontra il
  _pn->lfile().put(MOV_CODCAUS, codcaus);    //primo conto con indbil
  _pn->lfile().put(MOV_NUMREG,  _numreg);
}

void CG4600_application::rmov_proper(int anno,long numrig,TDate& datareg,TRectype& rmov,                                    TConto& tc,real& tot_saldo, bool sezione_opposta)
{
  char sez_rmov = ' ';
  char sezione  = ' ';  
  real totale = tot_saldo;

  rmov.zero();
  rmov.put(RMV_ANNOES,     anno);
  rmov.put(RMV_NUMREG,     _numreg); 
  rmov.put(RMV_NUMRIG,     numrig);
  rmov.put(RMV_DATAREG,    datareg);
  rmov.put(RMV_GRUPPO,     tc.gruppo());
  rmov.put(RMV_CONTO,      tc.conto());
  rmov.put(RMV_SOTTOCONTO, tc.sottoconto());

  if (totale > ZERO)
  {       
    sez_rmov  = 'A';
    sezione   = 'D';
  }
  else
    if (totale < ZERO)
    {
      sez_rmov  = 'D';
      sezione = 'A';
      totale = -totale;
    }
  
  if (sezione_opposta)
  {
    rmov.put(RMV_SEZIONE,    sez_rmov);
    _sld->aggiorna(tc,totale,sez_rmov);//Aggiorno anche i saldi con l'oggetto
    //TSaldo_agg
  }
else
{
  rmov.put(RMV_SEZIONE,    sezione);
  _sld->aggiorna(tc,totale,sezione);//Aggiorno anche i saldi con l'oggetto
  //TSaldo_agg
}
rmov.put(RMV_IMPORTO,    totale);
}

void CG4600_application::costi()
{
  bool    compila_mov = TRUE;
  long    s;
  char    sez_rmov = ' ', sezione = ' ';
  real    tot_saldo;
  long    numrig = 0;
  Saldo&  sale = *_sale;

  _totale_saldo = ZERO;
  tot_saldo     = ZERO;

  TRecnotype items_pcon  = _cur->items();
  
  for (int i = 0; i < items_pcon; i++, ++(*_cur))
  {
    int  indbil = _cur->curr().get_int(PCN_INDBIL);
    int  g      = _cur->curr().get_int(PCN_GRUPPO);
    int  c      = _cur->curr().get_int(PCN_CONTO);
    
    if (indbil == 3)
    {
      if (compila_mov)
      {
        compila_testata(_annoesch,_dataregch,_codcausch); //Reg. 1
        compila_mov = FALSE;
      }
      _saldi->setkey(1);
      _saldi->zero();
      _saldi->put(SLD_ANNOES, _annoesch);
      _saldi->put(SLD_GRUPPO, g);
      _saldi->put(SLD_CONTO,  c);
      
      (*_rec) = _saldi->curr();
      
      int j = 0;
      
      for (_saldi->read(); ; _saldi->next())
      {
        TRectype& rmov = _pn->cg(j);

        _saldo = ZERO;
        
        if (_saldi->curr() > (*_rec) || _saldi->eof()) 
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso conto, indicandola
          // con una sezione opposta al risultato (della somma).
          
          if (j >= 1)
          {
            numrig++;
            rmov_proper(_annoesch,numrig,_dataregch,rmov,_tcproper,tot_saldo,FALSE);
            
            tot_saldo = ZERO;
          }
          break;
        }

        numrig++;
        s               = _saldi->get_long(SLD_SOTTOCONTO);
        //sale.calcola_ultima_immissione(_annoesch,0,g,c,s,indbil);
        sale.ultima_immissione_bilancio(_annoesch,g,c,s,indbil);
        _saldo          = sale.saldo();

        if (_saldo.is_zero()) continue;

        if (_saldo > ZERO)
          sezione = 'D';
        else
          if (_saldo < ZERO)
          {
            sezione = 'A';
            _saldo = -_saldo;
          }

        if (sezione == 'D')    // ---> Tengo una variabile in cui salvo gli
        {                      // importi trovati sui saldi. Quando ho
          sez_rmov   = 'A';    // finito di leggere i sottoconti, oppure
          tot_saldo += _saldo;  // quando ho raggiunto un massimo di 200
          _totale_saldo += _saldo;
        }                      // righe di movimento, genero un' altra    
else                   // riga con importo di sezione opposta   
  if (sezione == 'A')  // alla somma, mandando a zero   
  {                    // il saldo di quel movimento.
    sez_rmov   = 'D';
    tot_saldo -= _saldo;
    _totale_saldo -= _saldo; 
  }
        
        if (j == MAX || _saldi->eof())
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso sottoconto, indicandola
          // con una sezione opposta al risultato (della somma).

          //      numrig++;
          rmov_proper (_annoesch,numrig,_dataregch,rmov,_tcproper,tot_saldo,FALSE);
          
          tot_saldo = ZERO;
        }
        if (!_saldi->eof())
        {

          rmov.zero();  
          rmov.put(RMV_ANNOES,     _annoesch); //Compilo una riga di movimento
          rmov.put(RMV_DATAREG,    _dataregch);  //per ogni sottoconto che leggo
          rmov.put(RMV_GRUPPO,     g);        //sui saldi. Siccome queste
          rmov.put(RMV_CONTO,      c);        //righe servono per mandare a 0
          rmov.put(RMV_SOTTOCONTO, s);        //il saldo dei movimenti, la
          rmov.put(RMV_SEZIONE,    sez_rmov); //sezione sara' opposta a 
          rmov.put(RMV_IMPORTO,    _saldo);    //quella letta sui saldi.
          rmov.put(RMV_NUMREG,     _numreg);
          rmov.put(RMV_NUMRIG,     numrig);
          
          TConto tc(g,c,s); 
          _sld->aggiorna(tc,_saldo,sez_rmov);    //l'oggetto TSaldo_agg
          j++;
        }
        if (_saldi->eof()) break;
      }                       //for saldi
      if (j >= 1)
      {
        _pn->write();
        _sld->registra();
        j = 0;
        _pn->destroy_rows();  //Azzero l'oggetto pn.
      }
    }                        // if (indbil == 3)                   
  }                          // for pcon
}

void CG4600_application::ricavi()
{
  bool    compila_mov = TRUE;
  long    s;
  char    sez_rmov = ' ', sezione = ' ';
  real    tot_saldo;
  long    numrig = 0;
  Saldo&  sale = *_sale;

  tot_saldo = ZERO;

  TRecnotype items_pcon  = _cur->items();
  
  for (int i = 0; i < items_pcon; i++, ++(*_cur))
  {
    int  indbil = _cur->curr().get_int(PCN_INDBIL);
    int  g      = _cur->curr().get_int(PCN_GRUPPO);
    int  c      = _cur->curr().get_int(PCN_CONTO);
    
    if (indbil == 4)
    {
      if (compila_mov)
      {
        compila_testata(_annoesch,_dataregch,_codcausch);  //Reg. 2
        compila_mov = FALSE;
      }
      _saldi->setkey(1);
      _saldi->zero();
      _saldi->put(SLD_ANNOES, _annoesch);
      _saldi->put(SLD_GRUPPO, g);
      _saldi->put(SLD_CONTO,  c);
      
      (*_rec) = _saldi->curr();
      
      int j = 0;

      for (_saldi->read(); ; _saldi->next())
      {
        TRectype& rmov = _pn->cg(j);

        _saldo = ZERO;

        if (_saldi->curr() > (*_rec) || _saldi->eof()) 
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso conto, indicandola
          // con una sezione opposta al risultato (della somma).
          
          if (j >= 1)
          {
            numrig++;
            rmov_proper(_annoesch,numrig,_dataregch,rmov,_tcproper,tot_saldo,FALSE);
            
            tot_saldo = ZERO;
          }
          break;
        }

        numrig++;
        s               = _saldi->get_long(SLD_SOTTOCONTO);
        //sale.calcola_ultima_immissione(_annoesch,0,g,c,s,indbil);
        sale.ultima_immissione_bilancio(_annoesch,g,c,s,indbil);
        _saldo          = sale.saldo();

        if (_saldo.is_zero()) continue;

        if (_saldo > ZERO)
          sezione = 'D';
        else
          if (_saldo < ZERO)
          {
            sezione = 'A';
            _saldo = -_saldo;
          }

        if (sezione == 'D')    // ---> Tengo una variabile in cui salvo gli
        {                      // importi trovati sui saldi. Quando ho
          sez_rmov   = 'A';    // finito di leggere i sottoconti, oppure
          tot_saldo += _saldo;  // quando ho raggiunto un massimo di 200
          _totale_saldo += _saldo;
        }                      // righe di movimento, genero un' altra    
else                   // riga con importo di sezione opposta   
  if (sezione == 'A')  // alla somma, mandando a zero   
  {                    // il saldo di quel movimento.
    sez_rmov   = 'D';
    tot_saldo -= _saldo;
    _totale_saldo -= _saldo; 
  }
        
        if (j == MAX || _saldi->eof())
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso sottoconto, indicandola
          // con una sezione opposta al risultato (della somma).

          //      numrig++;
          rmov_proper (_annoesch,numrig,_dataregch,rmov,_tcproper,tot_saldo,FALSE);
          
          tot_saldo = ZERO;
        }
        if (!_saldi->eof())
        {

          rmov.zero();  
          rmov.put(RMV_ANNOES,     _annoesch); //Compilo una riga di movimento
          rmov.put(RMV_DATAREG,    _dataregch);  //per ogni sottoconto che leggo
          rmov.put(RMV_GRUPPO,     g);        //sui saldi. Siccome queste
          rmov.put(RMV_CONTO,      c);        //righe servono per mandare a 0
          rmov.put(RMV_SOTTOCONTO, s);        //il saldo dei movimenti, la
          rmov.put(RMV_SEZIONE,    sez_rmov); //sezione sara' opposta a 
          rmov.put(RMV_IMPORTO,    _saldo);    //quella letta sui saldi.
          rmov.put(RMV_NUMREG,     _numreg);
          rmov.put(RMV_NUMRIG,     numrig);
          
          TConto tc(g,c,s); 
          _sld->aggiorna(tc,_saldo,sez_rmov);    //l'oggetto TSaldo_agg
          j++;
        }
        if (_saldi->eof()) break;
      }                       //for saldi
      if (j >= 1)
      {
        _pn->write();
        _sld->registra();
        j = 0;
        _pn->destroy_rows();  //Azzero l'oggetto pn.
      }
    }                        // if (indbil == 4)                   
  }                          // for pcon
}

void CG4600_application::chiusura_conto_economico()
{
  if (_totale_saldo > ZERO)
  {
    int j;

    //Compilo la testata per perdite di es. c.economico a Profitti e Perdite
    //Chiusura conto economico
    
    j = 0;
    ultima_registrazione();
    compila_testata(_annoesch,_dataregch,_codcausch);  //Reg. 3   

    TRectype& rmov1 = _pn->cg(j);
    long numrig = 1;
    rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcproper,_totale_saldo,TRUE);
    numrig++;
    j++;
    TRectype& rmov2 = _pn->cg(j);
    rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcperde,_totale_saldo,FALSE);
    
    _pn->write();
    _sld->registra();
    _sld->reset();

    //Compilo la testata per perdite di es. c.patrimon. a Perdita di es. c. econom.
    //Chiusura capitale netto

    _pn->destroy_rows();  //Azzero l'oggetto pn.
    j = 0;
    ultima_registrazione();

    compila_testata(_annoesch,_dataregch,_codcausch);  //Reg. 4
    
    TRectype& rmov3 = _pn->cg(j);
    numrig = 1;
    rmov_proper(_annoesch,numrig,_dataregch,rmov3,_tcperde,_totale_saldo,TRUE);
    numrig++;
    j++;
    TRectype& rmov4 = _pn->cg(j);
    rmov_proper(_annoesch,numrig,_dataregch,rmov4,_tcperdp,_totale_saldo,FALSE);

    _pn->write();
    _sld->registra(); 
    _sld->reset();
    
    //Compilo la testata per Perdita es. c/to patrimoniale a Bilancio di apertura
    //Apertura capitale netto
    
    _sld->set_anno_es(_annoesap);
    _pn->destroy_rows();  //Azzero l'oggetto pn.
    j = 0;
    ultima_registrazione();

    compila_testata(_annoesap,_dataregap,_codcausap);  //Reg. 10
    
    TRectype& rmov5 = _pn->cg(j);
    numrig = 1;
    rmov_proper(_annoesap,numrig,_dataregap,rmov5,_tcbilap,_totale_saldo,TRUE);
    numrig++;
    j++;
    TRectype& rmov6 = _pn->cg(j);
    rmov_proper(_annoesap,numrig,_dataregap,rmov6,_tcperdp,_totale_saldo,FALSE);

    _pn->write();
    _sld->registra();            
    _sld->set_anno_es(_annoesch);
  }
  else
    if (_totale_saldo < ZERO)
    {
      int j;

      //Compilo la testata per Profitti e perdite a Utile di es. c.economico
      //Chiusura conto economico

      _pn->destroy_rows();  //Azzero l'oggetto pn.
      j = 0;
      ultima_registrazione();
      compila_testata(_annoesch,_dataregch,_codcausch);    //Reg. 3

      TRectype& rmov1 = _pn->cg(j);
      long numrig = 1;
      rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcutile,_totale_saldo,FALSE);
      numrig++;
      j++;
      TRectype& rmov2 = _pn->cg(j);
      rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcproper,_totale_saldo,TRUE);

      _pn ->write();
      _sld->registra();
      _sld->reset();
      
      //Compilo la testata per Utile di es. c.economico a Utile di es. c.patrimoniale
      //Chiusura capitale netto

      _pn->destroy_rows();  //Azzero l'oggetto pn.
      j = 0;
      ultima_registrazione();
      compila_testata(_annoesch,_dataregch,_codcausch);   //Reg. 4
      
      TRectype& rmov3 = _pn->cg(j);
      numrig = 1;
      rmov_proper(_annoesch,numrig,_dataregch,rmov3,_tcutilp,_totale_saldo,FALSE);
      numrig++;
      j++;
      TRectype& rmov4 = _pn->cg(j);
      rmov_proper(_annoesch,numrig,_dataregch,rmov4,_tcutile,_totale_saldo,TRUE);

      _pn ->write();
      _sld->registra();
      _sld->reset();  
      
      //Compilo la testata per Bilancio di apertura  a Utile es. c/to patrimoniale
      //Apertura capitale netto
      
      _sld->set_anno_es(_annoesap);
      _pn->destroy_rows();  //Azzero l'oggetto pn.
      j = 0;
      ultima_registrazione();

      compila_testata(_annoesap,_dataregap,_codcausap);  //Reg. 10
      
      TRectype& rmov5 = _pn->cg(j);
      numrig = 1;
      rmov_proper(_annoesap,numrig,_dataregap,rmov5,_tcbilap,_totale_saldo,TRUE);
      numrig++;
      j++;
      TRectype& rmov6 = _pn->cg(j);
      rmov_proper(_annoesap,numrig,_dataregap,rmov6,_tcutilp,_totale_saldo,FALSE);

      _pn->write();
      _sld->registra();            
      _sld->set_anno_es(_annoesch);
      

    }
}

void CG4600_application::chiusura_conto_patrimoniale()
{
  int  j;
  long numrig;

  if (_totale_saldo > ZERO)
  {
    //Compilo la testata per Bilancio di chiusura a Perdita di es. c. patrimoniale
    //Chiusura conto patrimoniale

    _pn->destroy_rows();  //Azzero l'oggetto pn.
    j = 0;
    ultima_registrazione();
    compila_testata(_annoesch,_dataregch,_codcausch);   //Reg. 7
    
    TRectype& rmov1 = _pn->cg(j);
    numrig = 1;
    rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcutilp,_totale_saldo,FALSE);
    numrig++;
    j++;
    TRectype& rmov2 = _pn->cg(j);
    rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcbilch,_totale_saldo,TRUE);

    _pn->write();
    _sld->registra();

  }
else
  if (_totale_saldo < ZERO)
  {
    //Compilo la testata per Utile di es. c.patrimon. a Bilancio di chiusura
    //Chiusura conto patrimoniale

    _pn->destroy_rows();  //Azzero l'oggetto pn.
    j = 0;
    ultima_registrazione();
    compila_testata(_annoesch,_dataregch,_codcausch);    //Reg. 7
    
    TRectype& rmov1 = _pn->cg(j);
    numrig = 1;
    rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcbilch,_totale_saldo,TRUE);
    numrig++;
    j++;
    TRectype& rmov2 = _pn->cg(j);
    rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcperdp,_totale_saldo,FALSE);

    _pn ->write();
    _sld->registra();
  }
}

void CG4600_application::attivita()
{
  bool    compila_mov_ch = TRUE;
  bool    compila_mov_ap = TRUE;
  long    s;
  char    sez_rmov = ' ', sezione = ' ';
  real    tot_saldo;
  long    numrig = 0;
  Saldo&  sale = *_sale;

  tot_saldo = ZERO;

  TRecnotype items_pcon  = _cur->items();
  
  for (int i = 0; i < items_pcon; i++, ++(*_cur))
  {
    _sld->set_anno_es(_annoesch);

    int  indbil = _cur->curr().get_int(PCN_INDBIL);
    int  g      = _cur->curr().get_int(PCN_GRUPPO);
    int  c      = _cur->curr().get_int(PCN_CONTO);
    
    if (indbil == 1)
    {
      if (compila_mov_ch)
      {
        compila_testata(_annoesch,_dataregch,_codcausch); //Reg. 5 Chiusura
        compila_mov_ch = FALSE;
      }
      _saldi->setkey(1);
      _saldi->zero();
      _saldi->put(SLD_ANNOES, _annoesch);
      _saldi->put(SLD_GRUPPO, g);
      _saldi->put(SLD_CONTO,  c);
      
      TRectype rec (_saldi->curr());
      
      int j = 0;
      
      for (_saldi->read(); ; _saldi->next())
      {
        TRectype& rmov = _pn->cg(j);
        
        if (_saldi->curr() > rec || _saldi->eof()) 
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso conto, indicandola
          // con una sezione opposta al risultato (della somma).
          
          if (j >= 1)
          {
            numrig++;
            rmov_proper(_annoesch,numrig,_dataregch,rmov,_tcbilch,tot_saldo,FALSE); //Chiusura
            
            tot_saldo = ZERO;
          }
          break;
        }

        numrig++;
        s               = _saldi->get_long(SLD_SOTTOCONTO);
        //sale.calcola_ultima_immissione(_annoesch,0,g,c,s,indbil);
        sale.ultima_immissione_bilancio(_annoesch,g,c,s,indbil);
        _saldo          = sale.saldo();

        if (_saldo == ZERO) continue;

        if (_saldo > ZERO)
          sezione = 'D';
        else
          if (_saldo < ZERO)
          {
            sezione = 'A';
            _saldo = -_saldo;
          }

        if (sezione == 'D')    // ---> Tengo una variabile in cui salvo gli
        {                      // importi trovati sui saldi. Quando ho
          sez_rmov   = 'A';    // finito di leggere i sottoconti, oppure
          tot_saldo += _saldo;  // quando ho raggiunto un massimo di 200
          _totale_saldo += _saldo;
        }                      // righe di movimento, genero un' altra    
else                   // riga con importo di sezione opposta   
  if (sezione == 'A')  // alla somma, mandando a zero   
  {                    // il saldo di quel movimento.
    sez_rmov   = 'D';
    tot_saldo -= _saldo;
    _totale_saldo -= _saldo; 
  }
        
        if (j == MAX || _saldi->eof())
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso sottoconto, indicandola
          // con una sezione opposta al risultato (della somma).

          //      numrig++;
          rmov_proper (_annoesch,numrig,_dataregch,rmov,_tcbilch,tot_saldo,FALSE); //Chiusura  

          tot_saldo = ZERO;
        }
        if (!_saldi->eof())
        {

          rmov.zero();  
          rmov.put(RMV_ANNOES,     _annoesch); //Compilo una riga di movimento
          rmov.put(RMV_DATAREG,    _dataregch);  //per ogni sottoconto che leggo
          rmov.put(RMV_GRUPPO,     g);        //sui saldi. Siccome queste
          rmov.put(RMV_CONTO,      c);        //righe servono per mandare a 0
          rmov.put(RMV_SOTTOCONTO, s);        //il saldo dei movimenti, la
          rmov.put(RMV_SEZIONE,    sez_rmov); //sezione sara' opposta a 
          rmov.put(RMV_IMPORTO,    _saldo);    //quella letta sui saldi.
          rmov.put(RMV_NUMREG,     _numreg);
          rmov.put(RMV_NUMRIG,     numrig);
          
          TConto tc(g,c,s); 
          _sld->aggiorna(tc,_saldo,sez_rmov);    //l'oggetto TSaldo_agg

          j++;
        }
        if (_saldi->eof()) break;
      }                       //for saldi
      if (j >= 1)
      {
        _pn->write();
        _sld->registra();
        _sld->reset();
        j = 0;
        
        long items_pn = _pn->cg_items();
        _sld->set_anno_es(_annoesap);

        if (compila_mov_ap)
        {
          ultima_registrazione();
          compila_testata(_annoesap,_dataregap,_codcausap); //Reg. 8 Apertura
          compila_mov_ap = FALSE;
        }

        for (int i = 0; i < items_pn; i++)
        {
          char sez_rmov;
          TRectype& rmov = _pn->cg(j);

          char sezione = rmov.get     (RMV_SEZIONE)[0];
          int  gruppo  = rmov.get_int (RMV_GRUPPO);
          int  conto   = rmov.get_int (RMV_CONTO);
          long sottoc  = rmov.get_long(RMV_SOTTOCONTO);
          real importo = rmov.get_real(RMV_IMPORTO);

          if (sezione == 'D')
            sez_rmov = 'A';
          else
            if (sezione == 'A')
              sez_rmov = 'D';

          rmov.put(RMV_ANNOES,  _annoesap);
          rmov.put(RMV_NUMREG,     _numreg);
          rmov.put(RMV_DATAREG, _dataregap);

          if (i == (items_pn - 1))                    //Quando incontro il conto
          {
            rmov.put(RMV_GRUPPO,     _tcbilap.gruppo());
            rmov.put(RMV_CONTO,      _tcbilap.conto());
            rmov.put(RMV_SOTTOCONTO, _tcbilap.sottoconto());                                          //bilancio di chiusura lo
            rmov.put(RMV_SEZIONE,    sez_rmov);        //sostituisco con quello di
            _sld->aggiorna(_tcbilap,importo,sez_rmov); //apertura, non girando l'importo
          }                                           //perche' non l'avevo girato
      else                                        //precedentemente, mentre per gli altri
      {                                           //conti l'importo deve essere girato,
        rmov.put(RMV_SEZIONE, sez_rmov);          //perche' erano gia' stati girati
        TConto tc(gruppo,conto,sottoc);           //precedentemente per fare la chiusura
        _sld->aggiorna(tc,importo,sez_rmov);
      }
          j++;
        }

        _pn->write();
        _sld->registra();
        j = 0;
        _pn->destroy_rows();  //Azzero l'oggetto pn.
      }
    }                        // if (indbil == 1)                   
  }                          // for pcon
}

void CG4600_application::passivita()
{
  bool    compila_mov_ch = TRUE;
  bool    compila_mov_ap = TRUE;
  long    s;
  char    sez_rmov = ' ', sezione = ' ';
  real    tot_saldo;
  long    numrig = 0;
  Saldo&  sale = *_sale;

  tot_saldo = ZERO;

  TRecnotype items_pcon  = _cur->items();
  
  for (int i = 0; i < items_pcon; i++, ++(*_cur))
  {
    _sld->set_anno_es(_annoesch);

    int  indbil = _cur->curr().get_int(PCN_INDBIL);
    int  g      = _cur->curr().get_int(PCN_GRUPPO);
    int  c      = _cur->curr().get_int(PCN_CONTO);
    
    if (indbil == 2)
    {
      if (compila_mov_ch)
      {
        compila_testata(_annoesch,_dataregch,_codcausch); //Reg. 6 Chiusura
        compila_mov_ch = FALSE;
      }
      _saldi->setkey(1);
      _saldi->zero();
      _saldi->put(SLD_ANNOES, _annoesch);
      _saldi->put(SLD_GRUPPO, g);
      _saldi->put(SLD_CONTO,  c);
      
      TRectype rec (_saldi->curr());
      
      int j = 0;
      
      for (_saldi->read(); ; _saldi->next())
      {
        TRectype& rmov = _pn->cg(j);
        
        if (_saldi->curr() > rec || _saldi->eof()) 
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso conto, indicandola
          // con una sezione opposta al risultato (della somma).
          
          if (j >= 1)
          {
            numrig++;
            rmov_proper(_annoesch,numrig,_dataregch,rmov,_tcbilch,tot_saldo,FALSE); //Chiusura
            
            tot_saldo = ZERO;
          }
          break;
        }

        numrig++;
        s               = _saldi->get_long(SLD_SOTTOCONTO);
        //sale.calcola_ultima_immissione(_annoesch,0,g,c,s,indbil);
        sale.ultima_immissione_bilancio(_annoesch,g,c,s,indbil);
        _saldo          = sale.saldo();

        if (_saldo.is_zero()) continue;

        if (_saldo > ZERO)
          sezione = 'D';
        else
          if (_saldo < ZERO)
          {
            sezione = 'A';
            _saldo = -_saldo;
          }

        if (sezione == 'D')    // ---> Tengo una variabile in cui salvo gli
        {                      // importi trovati sui saldi. Quando ho
          sez_rmov   = 'A';    // finito di leggere i sottoconti, oppure
          tot_saldo += _saldo;  // quando ho raggiunto un massimo di 200
          _totale_saldo += _saldo;
        }                      // righe di movimento, genero un' altra    
else                   // riga con importo di sezione opposta   
  if (sezione == 'A')  // alla somma, mandando a zero   
  {                    // il saldo di quel movimento.
    sez_rmov   = 'D';
    tot_saldo -= _saldo;
    _totale_saldo -= _saldo; 
  }
        
        if (j == MAX || _saldi->eof())
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso sottoconto, indicandola
          // con una sezione opposta al risultato (della somma).

          //      numrig++;
          rmov_proper (_annoesch,numrig,_dataregch,rmov,_tcbilch,tot_saldo,FALSE); //Chiusura  

          tot_saldo = ZERO;
        }
        if (!_saldi->eof())
        {

          rmov.zero();  
          rmov.put(RMV_ANNOES,     _annoesch); //Compilo una riga di movimento
          rmov.put(RMV_DATAREG,    _dataregch);  //per ogni sottoconto che leggo
          rmov.put(RMV_GRUPPO,     g);        //sui saldi. Siccome queste
          rmov.put(RMV_CONTO,      c);        //righe servono per mandare a 0
          rmov.put(RMV_SOTTOCONTO, s);        //il saldo dei movimenti, la
          rmov.put(RMV_SEZIONE,    sez_rmov); //sezione sara' opposta a 
          rmov.put(RMV_IMPORTO,    _saldo);    //quella letta sui saldi.
          rmov.put(RMV_NUMREG,     _numreg);
          rmov.put(RMV_NUMRIG,     numrig);
          
          TConto tc(g,c,s); 
          _sld->aggiorna(tc,_saldo,sez_rmov);    //l'oggetto TSaldo_agg

          j++;
        }
        if (_saldi->eof()) break;
      }                       //for saldi
      if (j >= 1)
      {
        _pn->write();
        _sld->registra();
        _sld->reset();
        j = 0;

        long items_pn = _pn->cg_items();
        _sld->set_anno_es(_annoesap);

        if (compila_mov_ap)
        {
          ultima_registrazione();
          compila_testata(_annoesap,_dataregap,_codcausap); //Reg. 9 Apertura
          compila_mov_ap = FALSE;
        }

        for (int i = 0; i < items_pn; i++)
        {
          char sez_rmov;
          TRectype& rmov = _pn->cg(j);

          char sezione = rmov.get     (RMV_SEZIONE)[0];
          int  gruppo  = rmov.get_int (RMV_GRUPPO);
          int  conto   = rmov.get_int (RMV_CONTO);
          long sottoc  = rmov.get_long(RMV_SOTTOCONTO);
          real importo = rmov.get_real(RMV_IMPORTO);

          if (sezione == 'D')
            sez_rmov = 'A';
          else
            if (sezione == 'A')
              sez_rmov = 'D';
          
          rmov.put(RMV_ANNOES,  _annoesap);
          rmov.put(RMV_NUMREG,     _numreg);
          rmov.put(RMV_DATAREG, _dataregap);

          if (i == (items_pn - 1))                    //Quando incontro il conto
          {
            rmov.put(RMV_GRUPPO,     _tcbilap.gruppo());
            rmov.put(RMV_CONTO,      _tcbilap.conto());
            rmov.put(RMV_SOTTOCONTO, _tcbilap.sottoconto());                   //bilancio di chiusura lo
            rmov.put(RMV_SEZIONE, sez_rmov);           //sostituisco con quello di
            _sld->aggiorna(_tcbilap,importo,sez_rmov); //apertura, non girando l'importo
          }                                           //perche' non l'avevo girato
      else                                        //precedentemente, mentre per gli altri
      {                                           //conti l'importo deve essere girato,
        rmov.put(RMV_SEZIONE, sez_rmov);          //perche' erano gia' stati girati
        TConto tc(gruppo,conto,sottoc);           //precedentemente per fare la chiusura
        _sld->aggiorna(tc,importo,sez_rmov);
      }
          j++;
        }

        _pn->write();
        _sld->registra();
        j = 0;
        _pn->destroy_rows();
      }
    }                        // if (indbil == 2)                   
  }                          // for pcon
}

bool CG4600_application::menu(MENU_TAG m)
{
  if (m == BAR_ITEM(1))
    return set(); 
  return FALSE;
}

int /*main */ cg4600 (int argc, char* argv[])
{
  CG4600_application main_app;
  main_app.run(argc, argv, "Apertura/Chiusura Conti");
  return TRUE;
}







