/////////////////////////////////////////////////////////////////////////////
// cglib02.cpp 
// 
// Aggiornamento saldi
//
/////////////////////////////////////////////////////////////////////////////

#include <stdlib.h>

#include <isam.h>
#include <date.h>
#include <saldi.h>
#include <utility.h>

#include "conto.h"
#include "cglib.h"

void TTab_conti::do_agg(TConto* tc, int anno_es, const real& importo,
                        char sezione, bool movap, bool provv, bool somma, const char* key)
{
  real i = somma ? importo : -importo;

  if (movap)
  {
    if (sezione == 'D') tc->saldo() += i;
    else tc->saldo() -= i;
  }
  else
    if (provv)
    {
      if (sezione == 'D') tc->darepro() += i;
      else tc->averepro() += i;
    }
    else
    {
      if (sezione == 'D') tc->dare() += i;
      else tc->avere() += i;
    }

  // rimuovo dalla tabella il conto se dare e avere vanno a zero
  if (tc->dare().is_zero() && tc->avere().is_zero() &&
      tc->darepro().is_zero() && tc->averepro().is_zero() &&
      tc->saldo().is_zero()) remove(key);  
}


void TTab_conti::aggiorna_conto(const TConto& tcon, int anno_es, const real& importo, char sezione, bool movap, bool provv, bool somma)
{
  TString80 key;
  key << format("%4d",  anno_es);
  key << format("%3d",  tcon.gruppo());
  key << format("%3d",  tcon.conto());
  key << format("%6ld", tcon.sottoconto());
  
  TConto* tc = (TConto*) objptr(key);
  if (tc == NULL)
  {
    tc = new TConto(tcon.gruppo(), tcon.conto(), tcon.sottoconto(),
                    tcon.tipo());
    add(key, tc);
    tc->dare() = ZERO;
    tc->avere() = ZERO;
    tc->darepro() = ZERO;
    tc->averepro() = ZERO;
    tc->saldo() = ZERO;
  }
  do_agg(tc, anno_es, importo, sezione, movap, provv, somma, key);
}

void TTab_conti::aggiorna_conto(int gruppo, int conto, long sottoconto,
                                int anno_es, const real& importo, char sezione,
                                bool movap, bool provv, bool somma)
{
  TString80 key;
  key << format("%4d",  anno_es);
  key << format("%3d",  gruppo);
  key << format("%3d",  conto);
  key << format("%6ld", sottoconto);
  
  TConto* tc = (TConto*) objptr(key);
  if (tc == NULL)
  {
    tc = new TConto(gruppo, conto, sottoconto);
    add(key, tc);
  }
  do_agg(tc, anno_es, importo, sezione, movap, provv, somma, key);
}


TSaldo_agg::TSaldo_agg() 
{
  _anno_es    = 0;
  _data_ulmov = "";
  _num_ulmov  = 0l;
  _movap      = FALSE;
  _provv   = FALSE;
  reset();  // pulizia dell'array dei conti
}

void TSaldo_agg::aggiorna(const TConto& tc, const real& importo, char sezione,
                          bool somma)
{
  _tab_conti.aggiorna_conto(tc, _anno_es, importo, sezione, _movap, _provv,
                            somma);
}

void TSaldo_agg::aggiorna(int gruppo, int conto, long sottoconto, const real& importo, char sezione, bool somma)
{
  _tab_conti.aggiorna_conto(gruppo, conto, sottoconto, _anno_es, importo,
                            sezione, _movap, _provv, somma);
}

void TSaldo_agg::reset()
{
  _tab_conti.destroy();
}

///////////////////////////////////////////////////////////////////////////////
// pulizia file saldi
// 
// Scorro il file saldi per l' anno year o per tutti gli anni se year = 0
// e azzero i progressivi.
// 
///////////////////////////////////////////////////////////////////////////////
void TSaldo_agg::clear_saldi(int year)
{
  TLocalisamfile saldi(LF_SALDI);

  set_anno_es(year);
  saldi.zero();
  if (anno_es() != 0)
    saldi.put(SLD_ANNOES, anno_es());

  TRectype last(saldi.curr());

  for (saldi.read(_isgteq, _lock);
       !saldi.eof() && saldi.curr() <= last;
       saldi.next(_lock))
  {
    saldi.put(SLD_FLAGSALINI, "D");
    saldi.zero(SLD_SALDO);
    saldi.zero(SLD_PDAREPRO);
    saldi.zero(SLD_PAVEREPRO);
    saldi.zero(SLD_PDARE);
    saldi.zero(SLD_PAVERE);
    saldi.zero(SLD_NUMULTMOV);
    saldi.zero(SLD_DATAULMOV);
    saldi.rewrite();
  }
  saldi.reread(_unlock);
}

///////////////////////////////////////////////////////////////////////////////
// Aggiornamento file saldi
// 
// Scorro la tabella dei conti interna _tab_conti.
// Per ogni conto cerco il record su saldi, se non c'e' lo creo.
// Se c'e' gia' lo aggiorno nel seguente modo:
// 
///////////////////////////////////////////////////////////////////////////////
void TSaldo_agg::registra()
{
  real s, r;
  TString Flagsalini;
  TDate   data_ulmov;
  long    num_ulmov;
  TLocalisamfile saldi(LF_SALDI);
  int conti = _tab_conti.items();

  _tab_conti.restart();
  for (int i=0; i < conti; i++)
  {
    THash_object * hobj = tconti();
    TConto & tcon = (TConto &)hobj->obj();

    if (!tcon.ok()) continue;
    saldi.zero();
    saldi.put(SLD_ANNOES, atoi(hobj->key().left(4)) );
    saldi.put(SLD_GRUPPO, tcon.gruppo());
    saldi.put(SLD_CONTO,  tcon.conto());
    saldi.put(SLD_SOTTOCONTO, tcon.sottoconto());
    if (saldi.read(_isequal, _lock) == NOERR)
    {
      num_ulmov  = saldi.get_long(SLD_NUMULTMOV);
      data_ulmov = saldi.get_date(SLD_DATAULMOV);

      if (((_num_ulmov != 0L) && (_num_ulmov > num_ulmov)) ||
          ((_data_ulmov.ok()) && (_data_ulmov > data_ulmov)))
      {
        saldi.put(SLD_DATAULMOV, _data_ulmov);
        saldi.put(SLD_NUMULTMOV, _num_ulmov);
      }
      r = tcon.saldo();
      if (r != ZERO)
      {
        s  = saldi.get_real(SLD_SALDO);
        Flagsalini = saldi.get(SLD_FLAGSALINI);
        if (Flagsalini == "A") s = r - s;
        else s = r + s;
        if (s < ZERO)
        {
          Flagsalini = "A"; s = -s;
        }
        else
          Flagsalini = "D";
        saldi.put(SLD_FLAGSALINI, (const char *) Flagsalini);
        saldi.put(SLD_SALDO, s);
      }
      r = saldi.get_real(SLD_PDAREPRO);
      r += tcon.darepro();
      saldi.put(SLD_PDAREPRO,  r);
      r = saldi.get_real(SLD_PAVEREPRO);
      r += tcon.averepro(); 
      saldi.put(SLD_PAVEREPRO, r);
      r = saldi.get_real(SLD_PDARE);
      r += tcon.dare();
      saldi.put(SLD_PDARE,  r);
      r = saldi.get_real(SLD_PAVERE);
      r += tcon.avere(); 
      saldi.put(SLD_PAVERE, r);
      saldi.rewrite();
    }
    else
    {
      saldi.zero();
      saldi.put(SLD_ANNOES, anno_es());
      saldi.put(SLD_GRUPPO, tcon.gruppo());
      saldi.put(SLD_CONTO, tcon.conto());
      saldi.put(SLD_SOTTOCONTO, tcon.sottoconto());
      s = tcon.saldo();
      if (s < ZERO)
      {
        Flagsalini = "A"; s = -s;
      }
      else
        Flagsalini = "D";
      
      saldi.put(SLD_FLAGSALINI, (const char *) Flagsalini);
      saldi.put(SLD_SALDO, s);
      saldi.put(SLD_PDAREPRO,  tcon.darepro());
      saldi.put(SLD_PAVEREPRO, tcon.averepro());
      saldi.put(SLD_PDARE,  tcon.dare());

      saldi.put(SLD_PAVERE, tcon.avere());
      if (_num_ulmov != 0L) saldi.put(SLD_NUMULTMOV, _num_ulmov);
      if (_data_ulmov.ok()) saldi.put(SLD_DATAULMOV, _data_ulmov);
      saldi.write();
    } 
  }
}


