// Chiusura/Apertura Conti

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

#include "cg4.h"
#include "cg4600.h"
#include "cg2101.h"
#include "cglib.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;
    TLocalisamfile* _mov;
    TCursor*        _cur;
    TSaldo_agg*     _sld;
    Saldo           _sale;
            
    int     _annoes_msk;
    long    _sproper, _numreg;
    TDate   _datareg;
    TString _codcaus, _annoeseprec;
    int     _gproper, _cproper;

public:
    virtual bool create();
    virtual bool destroy();
    virtual bool menu(MENU_TAG m);
    void costi ();
    void ricavi();
    void record_rmov_proper (long, TRectype&, real&);
    void ultima_registrazione();
    void anno_ese_precedente();

    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)
{
  bool ok = TRUE;

  if ( (k == K_ENTER) && f.to_check(k) )
  {
    TTable TabEs ("ESC");
    TTable TabReg("REG"); 
    int anno = 0;
    
    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)
      return f.error_box ("La data di apertura non puo' essere inferiore alla data di inizio esercizio in corso");
    if (f.get() > fine)
      return f.error_box ("La data di apertura non puo' essere superiore alla data di fine esercizio in corso");
    if ( scarico.ok() && (f.get() <= scarico) )
      return f.error_box ("La data di apertura non puo' essere inferiore o uguale alla data di scarico"); 
    
    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();
    TString16 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)
      return f.error_box("La data di apertura non puo' essere inferiore alla data ultima stampa bollato"); 
  }     
  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;
}
/******

TConto conto (chg, chc, chs);
      
      if ( app()->gia_inserito(conto) )
      {
	f.warning_box("Nessun sottoconto puo' essere ripetuto!");
	return FALSE; 
      }
    }
  }
  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);
  _mov   = new TLocalisamfile (LF_MOV);
  _esc   = new TTable ("ESC");
  _reg   = new TTable ("REG");
  _sld   = new TSaldo_agg();

  dispatch_e_menu (BAR_ITEM(1));

  return TRUE;
}

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

  return TApplication::destroy();
}

void CG4600_application::anno_ese_precedente()
{
  TTable tabesc ("ESC");
  TString16 chiave;  chiave << _annoes_msk;
  tabesc.zero();
  tabesc.put("CODTAB", chiave);
  const int err = tabesc.read();
  if (err == NOERR)
  {
    tabesc.prev();
    _annoeseprec = tabesc.get("CODTAB");
  }
  else      
    _annoeseprec = 0;
}

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");
//  TLocalisamfile saldi (LF_SALDI);
  TMask m ("cg4600a");
  KEY     tasto;

  TConfig conf(CONFIG_DITTA);
  
  m.set(F_CHIUSURA, conf.get("CoCaCh"));
  m.set(F_APERTURA, conf.get("CoCaAp"));
  
  TabEs.last();
  int   anno   = TabEs.get_int ("CODTAB"); 
  TDate inizio = TabEs.get_date("D0"); //data inizio es. in corso
  TabEs.prev();
  TDate fine   = TabEs.get_date("D1"); //data fine es. precedente
  m.set(F_ANNO,  anno);
  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)
  {
    _annoes_msk  = m.get_int (F_ANNO);
    _datareg     = m.get     (F_DATAC);
    _codcaus     = m.get     (F_CHIUSURA);
    _gproper     = m.get_int (F_PROPERG);
    _cproper     = m.get_int (F_PROPERC);
    _sproper     = m.get_long(F_PROPERS);     

    ultima_registrazione();
    anno_ese_precedente();

    *_cur = 0l;

    costi ();

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

//    ricavi();
    return TRUE;
  }                              //K_ENTER
  return FALSE;
}

void CG4600_application::record_rmov_proper(long numrig,TRectype& rmov,real& tot_saldo)
{
  char sez_rmov = ' ';

  rmov.zero();
  rmov.put(RMV_ANNOES,     _annoes_msk);
  rmov.put(RMV_NUMREG,     _numreg); 
  rmov.put(RMV_NUMRIG,     numrig);
  rmov.put(RMV_DATAREG,    _datareg);
  rmov.put(RMV_GRUPPO,     _gproper);
  rmov.put(RMV_CONTO,      _cproper);
  rmov.put(RMV_SOTTOCONTO, _sproper);

  if (tot_saldo.sign() > 0)       
    sez_rmov  = 'A';
  else
    if (tot_saldo.sign() < 0)
    {
      sez_rmov  = 'D';
      tot_saldo = -tot_saldo;
    }
  
  rmov.put(RMV_SEZIONE,    sez_rmov); 
  rmov.put(RMV_IMPORTO,    tot_saldo);
}

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

  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)
      {
        _pn->lfile()->zero(); 
	_pn->lfile()->put(MOV_ANNOES,  _annoes_msk); //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);
	compila_mov = FALSE;                         //=3 (costi).
      }

      _saldi->setkey(1);
      _saldi->zero();
      _saldi->put(SLD_ANNOES, _annoes_msk);
      _saldi->put(SLD_GRUPPO, g);
      _saldi->put(SLD_CONTO,  c);
      
      TRectype rec (_saldi->curr());
      
      int j = 0;
      numrig = 0;
      
      for (_saldi->read(); ; _saldi->next())
      {
	TRectype& rmov = _pn->cg(j);
        numrig++;
	
	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)
	  {
            record_rmov_proper(numrig, rmov, tot_saldo);
	    
	    tot_saldo = 0.00;
//	    j = 0;
//	    _pn->destroy_rows();  //Azzero l'oggetto pn.
	  }
	  break;
	}

	s            = _saldi->get_long(SLD_SOTTOCONTO);
        int annoeseprec = atoi(_annoeseprec);
	_sale.calcola_ultima_immissione(_annoes_msk,annoeseprec                                                       ,g,c,s,indbil);
        real saldo = _sale.saldo();

	if (saldo == 0) continue;

        if (saldo.sign() > 0)
	  sezione = 'D';
        else
          if (saldo.sign() < 0)
	  {
            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
	}                      // 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;   
	  }
            
	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).
	  
          record_rmov_proper (numrig, rmov, tot_saldo);
	  
//	  _pn->write();
	  tot_saldo = 0.00;
//	  j = 0;
//	  _pn->destroy_rows();  //Azzero l'oggetto pn.
	}
        if (!_saldi->eof())
        {

        rmov.zero();	
	rmov.put(RMV_ANNOES,     _annoes_msk); //Compilo una riga di movimento
	rmov.put(RMV_DATAREG,    _datareg);  //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->set_anno_es(_annoes_msk);       //Aggiorno anche i saldi con 
	_sld->aggiorna(tc,saldo,sezione);    //l'oggetto TSaldo_agg
	j++;
        }
        if (_saldi->eof()) break;
      }                       //for saldi
      if (j >= 1)
      {
	_pn->write();
	_sld->registra();
        j = 0;
      }
    }                        // if (indbil == 3)                   
  }                          // for pcon
/************************
  _pn->destroy_rows();  //Azzero l'oggetto pn.
  ultima_registrazione();
  _pn->lfile()->zero();    
  _pn->lfile()->put(MOV_ANNOES,  _annoes_msk); //Compilo la testata per 
  _pn->lfile()->put(MOV_DATAREG, _datareg);    //perdite di es. c.economico
  _pn->lfile()->put(MOV_CODCAUS, _codcaus);    //a Profitti e Perdite
  _pn->lfile()->put(MOV_NUMREG,  _numreg);

  TRectype& rmov = _pn->cg(j);
  long numrig = 1;
  record_rmov_proper(numrig,rmov); 
  	  
******/    
}

void CG4600_application::ricavi()
{
  bool    compila_mov = TRUE;
  long    s;
  char    sez_rmov = ' ';
  real    tot_saldo;
  long    numrig = 0;

  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)
      {
        _pn->lfile()->zero(); 
	_pn->lfile()->put(MOV_ANNOES,  _annoes_msk); //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);
	compila_mov = FALSE;                         //=4 (ricavi).
      }

      _saldi->setkey(1);
      _saldi->zero();
      _saldi->put(SLD_ANNOES, _annoes_msk);
      _saldi->put(SLD_GRUPPO, g);
      _saldi->put(SLD_CONTO,  c);
      
      TRectype rec (_saldi->curr());
      
      int j = 0;
      numrig = 0;
      
      for (_saldi->read(); ; _saldi->next())
      {
	TRectype& rmov = _pn->cg(j);
        numrig++;
	
	if (_saldi->curr() > rec || _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).
	  
	  if (j >= 1)
	  {
            record_rmov_proper (numrig, rmov, tot_saldo);
	    
	    if (tot_saldo.sign() > 0)       
	      sez_rmov  = 'A';
	    else
	      if (tot_saldo.sign() < 0)
	      {
		sez_rmov  = 'D';
		tot_saldo = tot_saldo * (-1.00);
	      }
	    
	    rmov.put(RMV_SEZIONE,    sez_rmov); 
	    rmov.put(RMV_IMPORTO,    tot_saldo);
	    
	    tot_saldo = 0.00;
//	    j = 0;
//	    _pn->destroy_rows();  //Azzero l'oggetto pn.
	  }
	  break;
	}

	s            = _saldi->get_long(SLD_SOTTOCONTO);
	real saldo   = _saldi->get_real(SLD_SALDO);
	char sezione = _saldi->get(SLD_FLAGSALINI)[0]; 
	    
	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
	}                      // 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;   
	  }
            
	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).
	  
          record_rmov_proper (numrig, rmov, tot_saldo);
	  
	  if (tot_saldo.sign() > 0)       
	    sez_rmov  = 'A';
	  else
	    if (tot_saldo.sign() < 0)
	    {
	      sez_rmov  = 'D';
	      tot_saldo = tot_saldo * (-1.00);
	    }
	  
	  rmov.put(RMV_SEZIONE,    sez_rmov); 
	  rmov.put(RMV_IMPORTO,    tot_saldo);
	  
	  _pn->write();
	  tot_saldo = 0.00;
//	  j = 0;
//	  _pn->destroy_rows();  //Azzero l'oggetto pn.
	}
        if (!_saldi->eof())
        {

        rmov.zero();	
	rmov.put(RMV_ANNOES,     _annoes_msk); //Compilo una riga di movimento
	rmov.put(RMV_DATAREG,    _datareg);  //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->set_anno_es(_annoes_msk);       //Aggiorno anche i saldi con 
	_sld->aggiorna(tc,saldo,sezione);    //l'oggetto TSaldo_agg
	j++;
        }
        if (_saldi->eof()) break;
      }                       //for saldi
      if (j >= 1)
      {
	_pn->write();
	_sld->registra();
        j = 0;
      }
    }                        // if (indbil == 4)                   
  }                          // for pcon
}

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


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