// cglib01.cpp
// calcolo dei saldi

#include <applicat.h>
#include <date.h>
#include <real.h>
#include <lffiles.h>
#include <isam.h>
#include <utility.h>
#include <config.h>
#include <rmov.h>
#include <mov.h>
#include <saldi.h> 
#include <pconti.h> 
#include <clifo.h> 

#include "cglib.h"

const MAXSTR = 128;
static char __tmp [MAXSTR];
static TFixed_string tmp (__tmp, MAXSTR);

TClifo_list::TClifo_list(int g, int c, char tipocf)
{
  TLocalisamfile cf(LF_CLIFO);
  destroy();
  cf.setkey(3);
  cf.zero();
  cf.put(CLI_TIPOCF,tipocf);
  cf.put(CLI_GRUPPO,g);
  cf.put(CLI_CONTO,c);
  TRectype rec(cf.curr());
  cf.read(_isgteq);
  for ( ;!cf.eof();cf.next())
  {
    if (cf.curr() > rec)  break;
    TRectype r(cf.curr());
    add(r);
  }
}

Saldo::Saldo()
{
  _saldo_iniziale = ZERO;
  _prg_dare       = ZERO;
  _prg_avere      = ZERO;  
  _saldo          = ZERO;
  _indbil         = 0;
  _saldi = new TLocalisamfile(LF_SALDI);
  _mov   = new TLocalisamfile(LF_MOV);  
  _rmov  = new TLocalisamfile(LF_RMOV);  
  _clifo = new TLocalisamfile(LF_CLIFO);
  _rec   = new TRectype(LF_SALDI);
}

Saldo::~Saldo()
{
  delete _saldi;
  delete _mov;
  delete _rmov;
  delete _clifo;
  delete _rec;
}

real Saldo::saldofin_esprec(int annoes, int g, int c, long s) 
{
  real saldo,pdare,pavere,pdaresca,paveresca;
  char flag;
  TLocalisamfile& saldi = *_saldi;
  TRecnotype numrec = saldi.recno();       
  TRectype app = ricerca_progr_prec(annoes-1, g, c, s);
  
  flag         = app.get(SLD_FLAGSALINI)[0];
  saldo        = app.get_real(SLD_SALDO);
  pdare        = app.get_real(SLD_PDARE);
  pavere       = app.get_real(SLD_PAVERE); 
  pdaresca     = app.get_real(SLD_PDARESCA);
  paveresca    = app.get_real(SLD_PAVERESCA); 
  
  saldi.readat(numrec);
  
  if (flag == 'D')
    return saldo+pdaresca-paveresca+pdare-pavere;
  else 
    return pdaresca-saldo-paveresca+pdare-pavere;   
} 

real Saldo::calcola_saldo_iniziale(int annoes,int g,int c,long s,int indbil)
{
  real saldoini, pdaresca, paveresca;
  char flag;
  TLocalisamfile& saldi = *_saldi;
 
  saldi.zero();
  saldi.put(SLD_GRUPPO,g);
  if (c != 0)
     saldi.put(SLD_CONTO,c);
  if (s != 0) 
     saldi.put(SLD_SOTTOCONTO,s);
  saldi.put(SLD_ANNOES,annoes);
  
  saldi.read();  

  if (saldi.bad())
     saldi.zero();

  flag      = saldi.get(SLD_FLAGSALINI)[0];
  saldoini  = saldi.get_real(SLD_SALDO);
  pdaresca  = saldi.get_real(SLD_PDARESCA);
  paveresca = saldi.get_real(SLD_PAVERESCA); 
  
  if (saldoini == 0.00) //e il conto e' patrimoniale o d'ordine
     if ( (indbil == 1)||(indbil == 2)||(indbil == 5) )
        saldoini = saldofin_esprec(annoes, g, c, s);
      
  if (flag == 'D')
     return saldoini+pdaresca-paveresca;
  else //if (flag == 'A')
     return pdaresca-saldoini-paveresca;
}

// La funzione seguente calcola il saldo per data limite o all'ultima immissione es.in /
// corso o precedente, a seconda del valore dei suoi parametri al momento della chiamata
bool Saldo::calcola(int annoes, int annoesprec, int g, int c, long s,
                    const TDate& data_inf, const TDate& data_sup,
		            int indbil, bool controllo_competenza, const TDate& inizio_es,
             const TDate& fine_es, const TDate& fine_es_prec,bool stp_prov)
{
  if (data_sup.ok())
  { 
     if (!calcola_data_limite(annoes, g, c, s, data_inf, data_sup, indbil, 
         controllo_competenza, inizio_es, fine_es, fine_es_prec,stp_prov))
        return FALSE;
  }    
  else 
    if (!calcola_ultima_immissione(annoes, annoesprec, g, c, s, indbil))
       return FALSE;
 
  return TRUE;
}

const char* Saldo::causale_chiusura_es()
{
  TConfig conf(CONFIG_DITTA);
  tmp = conf.get("CoCaCh");

  return __tmp;
}

const char* Saldo::causale_apertura_es()
{
  TConfig conf(CONFIG_DITTA);
  tmp = conf.get("CoCaAp");

  return __tmp;
}

bool Saldo::causale_mov(long nr, const TDate& inizio_es, const TDate& data_sup,                        TString& provv)
{
  TString codcaus;
  TDate   datareg;
  TLocalisamfile& mov = *_mov;

  mov.zero();
  mov.put (MOV_NUMREG,nr);

  if (mov.read() == NOERR)
  {
    codcaus = mov.get(MOV_CODCAUS);
    datareg = mov.get_date(MOV_DATAREG);
    provv   = mov.get(MOV_PROVVIS);
    if (codcaus == causale_chiusura_es())
       return TRUE;

    if (codcaus == causale_apertura_es())
       if ( (datareg < inizio_es) || (datareg > data_sup) )
       return TRUE;
  }
  return FALSE;      
}

bool Saldo::calcola_data_limite(int annoes, int g, int c, long s, const TDate& data_inf, const TDate& data_sup, int indbil, bool controllo_competenza, const TDate& inizio_es, const TDate& fine_es, const TDate& fine_es_prec,bool stp_prov)
{
  TString sezione, gcs_corr, gcs_prec="", provv = "";
  real    importo, dep = 0.00;
  int     gruppo, conto, annoe;
  long    sottoconto, num_reg;
  TLocalisamfile& rmov = *_rmov;
 
  TDate data_rmv;
  bool esito = FALSE;

  rmov.setkey(2);
  rmov.zero();
  rmov.put(RMV_GRUPPO,g);
  if (c != 0)
     rmov.put(RMV_CONTO,c);
  if (s != 0)
     rmov.put(RMV_SOTTOCONTO,s);
  TRectype rec(rmov.curr());

  rmov.read(_isgteq);     
  for ( ; !rmov.eof(); rmov.next())
  {
    if (rmov.curr() != rec) break;
    
    annoe      = rmov.get_int(RMV_ANNOES);
    gruppo     = rmov.get_int(RMV_GRUPPO);
    conto      = rmov.get_int(RMV_CONTO);
    sottoconto = rmov.get_long(RMV_SOTTOCONTO);
    data_rmv   = rmov.get_date(RMV_DATAREG);
    num_reg    = rmov.get_long(RMV_NUMREG);

    //se la causale del movimento e' uguale a quella di chiusura, il movimento non va considerato
    if (causale_mov(num_reg,inizio_es,data_sup,provv)) 
       break; 

    if ((!stp_prov) && (provv.trim().not_empty())) //se non e' richiesta stampa
       continue;                                    //mov. provvisori li scarto
                                                   
    gcs_corr   = format ("%3d%3d%6ld", gruppo, conto, sottoconto);  

    if (gcs_corr != gcs_prec)  
    {
      gcs_prec = gcs_corr;
      dep += calcola_saldo_iniziale(annoe,gruppo,conto,sottoconto,indbil);
    }

    //controllo sulle date   
    if (annoe != annoes)
      if (annoe != annoes-1)
	 continue;
          
    if (controllo_competenza)    
       if ( (annoe == annoes -1) && (data_sup != fine_es) )
	      continue;
       else
          if ( (data_rmv <= fine_es) && (data_rmv <= fine_es_prec) ||
               (data_rmv > fine_es) )
             continue;     

    if ( (data_rmv < data_inf) || (data_rmv > data_sup) )
       continue;

    sezione    = rmov.get(RMV_SEZIONE);
    importo    = rmov.get_real(RMV_IMPORTO);

    if (importo.is_zero())
       continue;
    
    esito = TRUE;    
    
    if (sezione == "D")  dep += importo;
    else dep -= importo;

  }
  _saldo = dep;
  return esito;  
}

bool Saldo::calcola_ultima_immissione(int annoes, int annoesprec, int g, int c,
long s, int indbil)
{
  //Si considerano i saldi e non piu' i movimenti
  char sezione; 
  int  gruppo, conto, annoe;
  long sottoconto;
  TLocalisamfile& saldi = *_saldi;
  bool esito = TRUE;     
  
  _saldo_iniziale = ZERO;
  _prg_dare       = ZERO;
  _prg_avere      = ZERO;
  _saldo	  = ZERO;

  saldi.zero();
  
  if (annoes != 0) saldi.put(SLD_ANNOES,annoes);
  if (g != 0)      saldi.put(SLD_GRUPPO,g);
  if (c != 0)      saldi.put(SLD_CONTO,c);
  if (s != 0)      saldi.put(SLD_SOTTOCONTO,s);
     
  if (saldi.read() == NOERR)
  {
    annoe           = saldi.get_int(SLD_ANNOES);
    gruppo          = saldi.get_int(SLD_GRUPPO);
    conto           = saldi.get_int(SLD_CONTO);
    sottoconto      = saldi.get_long(SLD_SOTTOCONTO);
    _saldo_iniziale = saldi.get_real(SLD_SALDO);
    _prg_dare       = saldi.get_real(SLD_PDARE);
    _prg_avere      = saldi.get_real(SLD_PAVERE);
    sezione         = saldi.get_char(SLD_FLAGSALINI);

    if (sezione == 'A') _saldo_iniziale = -_saldo_iniziale;
    
    if (annoesprec == 0) //all'ultima immissione es.in corso
    {
//      if (indbil == 3 || indbil == 4)
//	  return esito; 
     
      if (indbil == 1 || indbil == 2 || indbil == 5)      
        if (_saldo_iniziale == ZERO)
	      _saldo_iniziale += saldofin_esprec(annoes,gruppo,conto,sottoconto);   

      // i tre valori precedenti vengono utilizzati per la stampa bilancio 
      // di verifica      
      _saldo = _saldo_iniziale + _prg_dare - _prg_avere;
    }
    else //all'ultima immissione es.precedente
    {  
      TRecnotype numrec = saldi.recno();       
      TRectype app = ricerca_progr_prec(annoe-1, gruppo, conto, sottoconto);
      annoe        = app.get_int (SLD_ANNOES);
      _prg_dare    = app.get_real(SLD_PDARE);
      _prg_avere   = app.get_real(SLD_PAVERE);
#ifdef DBG
  TString16 pd, pa;
  pa = _prg_avere.string();
  pd = _prg_dare.string();
  warning_box ("pdare=%s pavere=%s", (const char*)pd, (const char *)pa);
#endif
      saldi.readat(numrec);
      _saldo     = _prg_dare - _prg_avere;  
    }
  }
  return esito;
}  

TRectype& Saldo::ricerca_progr_prec (int annoesprec, int g, int c, long s)
{
  TLocalisamfile& saldi = *_saldi;

  saldi.zero();
//  static TRectype rec(saldi.curr());

  if (annoesprec != 0) saldi.put(SLD_ANNOES,annoesprec);
  if (g != 0) 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();

  *_rec = saldi.curr();
  return *_rec;
}

//calcolo dei progressivi attuali  
bool Saldo::prg_attuali(int annoes,TConto& conto,int indbil,real& prgdare,real& prgavere)
{
  real saldoini, pdare, pavere, pdaresca, paveresca;
  char flagsalini;
  int g  = conto.gruppo();
  int c  = conto.conto();
  long s = conto.sottoconto();
  TLocalisamfile& saldi = *_saldi;
 
  saldi.zero();
  saldi.put(SLD_GRUPPO,g);
  if (conto.conto() != 0)
     saldi.put(SLD_CONTO,c);
  if (conto.sottoconto() != 0) 
     saldi.put(SLD_SOTTOCONTO,s);
  saldi.put(SLD_ANNOES,annoes);
  
  if (saldi.read() == NOERR)
  {
    flagsalini = saldi.get(SLD_FLAGSALINI)[0];
    saldoini   = saldi.get_real(SLD_SALDO);

    if ( (indbil == 1) || (indbil == 2) || (indbil == 5) )
       if (saldoini == 0)
       {
	 saldoini = saldofin_esprec(annoes,conto.gruppo(),conto.conto(),conto.sottoconto());
	 if (saldoini > 0.00)
	    flagsalini = 'D';
         else flagsalini = 'A';
       }	    
    pdare      = saldi.get_real(SLD_PDARE);
    pavere     = saldi.get_real(SLD_PAVERE);
    pdaresca   = saldi.get_real(SLD_PDARESCA);
    paveresca  = saldi.get_real(SLD_PAVERESCA);
    if (flagsalini == 'D')
    {
      prgdare  = saldoini + pdare + pdaresca;
      prgavere = pavere + paveresca; 
    }
    else
    {
      prgdare  = pdare + pdaresca;
      prgavere = saldoini + pavere + paveresca;  
    }
  }
  return TRUE;
}

bool Saldo::prg_mov_eliminati(int annoes,TConto& conto,int indbil,real& prgdare,real& prgavere)
{
  real saldoini, pdaresca, paveresca;
  char flagsalini;
  TLocalisamfile& saldi = *_saldi;
 
  saldi.zero();
  saldi.put(SLD_GRUPPO,conto.gruppo());
  if (conto.conto() != 0)
     saldi.put(SLD_CONTO,conto.conto());
  if (conto.sottoconto() != 0) 
     saldi.put(SLD_SOTTOCONTO,conto.sottoconto());
  saldi.put(SLD_ANNOES,annoes);
  
  if (saldi.read() == NOERR)
  {
    flagsalini = saldi.get(SLD_FLAGSALINI)[0];
    saldoini   = saldi.get_real(SLD_SALDO);

    if ( (indbil == 1) || (indbil == 2) || (indbil == 5) )
       if (saldoini == 0)
       {
	 saldoini = saldofin_esprec(annoes,conto.gruppo(),conto.conto(),conto.sottoconto());
	 if (saldoini > 0.00)
	    flagsalini = 'D';
         else flagsalini = 'A';
       }	    
    pdaresca   = saldi.get_real(SLD_PDARESCA);
    paveresca  = saldi.get_real(SLD_PAVERESCA);
    if (flagsalini == 'D')
    {
      prgdare  = saldoini + pdaresca;
      prgavere = paveresca; 
    }
    else
    {
      prgdare  = pdaresca;
      prgavere = saldoini + paveresca;  
    }
  }
  return TRUE;
}

TLocalisamfile * get_descr_cf (TLocalisamfile * pconti,
			       TLocalisamfile * clifo, int g, int c, long s)
{
  pconti->zero();
  pconti->put (PCN_GRUPPO, g);
  pconti->put (PCN_CONTO , c);
  pconti->put (PCN_SOTTOCONTO, s);

  pconti->read();

  if (pconti->good())
    return pconti;

  TString tipocf = pconti->get(PCN_TMCF);
  long    codcf  = s;

  clifo->zero();
  clifo->put(CLI_CODCF, codcf);
  clifo->put(CLI_TIPOCF, tipocf);

  clifo->read();

  if (clifo->good())
    return clifo;

  return NULL;
}