// cg5200.cpp  - Visualizzazione saldi

#include <applicat.h>
#include <msksheet.h> 
#include <relapp.h>
#include <brwapp.h>
#include <tabutil.h>
#include <config.h>
#include <utility.h>
#include <urldefid.h>
#include <cglib.h>
#include <saldi.h>
#include <clifo.h>
#include <pconti.h>
#include "cg5200.h"

HIDDEN const char* REAL_PICTURE = "###.###.###.###";

class TRiga_array : public TArray
{
 public:
   bool add_riga(const TRectype& rec_saldi); 
};

bool TRiga_array::add_riga(const TRectype& rec_saldi) 
{
 bool found = FALSE;
 int annoes, annoesr;
 char flag, flagr;
 TDate udata, udatar;
 long  unum, unumr;
 real pdaresca,paveresca,pdare,pavere,saldoini,pdarepro,paverepro;
 real pdarescar,paverescar,pdarer,paverer,saldoinir,pdarepror,paverepror;

 for (int i = 0; i < items(); i++)
 {
  TRectype& r = (TRectype&)(*this)[i];
  annoes    = r.get_int(SLD_ANNOES);
  annoesr   = rec_saldi.get_int(SLD_ANNOES);
  if ( annoes == annoesr ) 
  {
   pdaresca  = r.get_real(SLD_PDARESCA);
   paveresca = r.get_real(SLD_PAVERESCA);
   flag      = r.get_char(SLD_FLAGSALINI);
   pdare     = r.get_real(SLD_PDARE);
   pavere    = r.get_real(SLD_PAVERE);
   saldoini  = r.get_real(SLD_SALDO);
   pdarepro  = r.get_real(SLD_PDAREPRO);
   paverepro = r.get_real(SLD_PAVEREPRO);
   udata     = r.get(SLD_DATAULMOV);
   unum      = r.get_long(SLD_NUMULTMOV);     
   pdarescar = rec_saldi.get_real(SLD_PDARESCA);
   pdarescar += pdaresca;
   paverescar = rec_saldi.get_real(SLD_PAVERESCA);
   paverescar+= paveresca;
   flagr     = rec_saldi.get_char(SLD_FLAGSALINI);
   pdarer    = rec_saldi.get_real(SLD_PDARE);
   pdarer   += pdare;
   paverer   = rec_saldi.get_real(SLD_PAVERE);
   paverer  += pavere;
   saldoinir = rec_saldi.get_real(SLD_SALDO);
   udatar    = rec_saldi.get(SLD_DATAULMOV);
   unumr     = rec_saldi.get_long(SLD_NUMULTMOV);
   udatar    = fnc_max(udatar,udata);
   unumr     = (unum > unumr) ? unum : unumr;
   if (flagr == 'D')
      saldoinir += saldoini;
   else if (flagr == 'A')
           saldoinir -= saldoini;    
   pdarepror  = rec_saldi.get_real(SLD_PDAREPRO);
   pdarepror  += pdarepro;
   paverepror = rec_saldi.get_real(SLD_PAVEREPRO);
   paverepror += paverepro;
   found = TRUE;
   r.put(SLD_ANNOES, annoes);
   r.put(SLD_PDARESCA, pdarescar);
   r.put(SLD_PAVERESCA,paverescar);
   r.put(SLD_PDARE, pdarer);
   r.put(SLD_PAVERE,paverer);
   r.put(SLD_SALDO, saldoinir);
   r.put(SLD_PDAREPRO, pdarepror);
   r.put(SLD_PAVEREPRO,paverepro);
   r.put(SLD_DATAULMOV, udatar);
   r.put(SLD_NUMULTMOV, unumr);
  }
 }
 if (!found)
 {
   TRectype* r = new TRectype(rec_saldi);//ci copia anche i valori di rec_saldi
   add(r);
 }
 return found;
}

bool gruppo_handler (TMask_field& f, KEY k);
bool sottoc_handler (TMask_field& f, KEY k);

class CG5200_application : public TBrowse_application
{
  friend bool gruppo_handler (TMask_field& f, KEY k);
  friend bool sottoc_handler (TMask_field& f, KEY k);
   
  TMask*          _msk;
  TLocalisamfile* _pcon,* _clifo;
  TCursor       * _cur;
  TRelation     * _rel,* _rel1;
  TRiga_array   _riga;
  int _items, _anno, _g, _c;
  long _s;
  bool _saldo_conto, _saldo_gruppo, _saldo_sottoc;
  
protected:
  virtual bool user_create();
  virtual bool user_destroy();
  virtual TRelation*   get_relation() const { return _rel; }
  virtual TMask*       get_mask(int mode)   { return _msk; }
  virtual bool         changing_mask(int mode) {return FALSE; }
  virtual int read(TMask& m);

public:
  void add_r(int,int,real&,real&,real&,char,real&,real&,
             real&,real&,TDate&,long,real&,real&,real&);
  void compilasheet();
  bool fai_filtro();
  TMask* main_mask() const {return _msk;}
  TSheet_field& ss() const { return (TSheet_field&)_msk->field(F_SHEET_SALDI);}

  CG5200_application() {}
};

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

bool CG5200_application::fai_filtro()
{
  TSaldo sld; 
  int annop = 0;
  char tipo;
   
  _saldo_gruppo = _saldo_conto = _saldo_sottoc = FALSE;
  TMask* m = app()->main_mask();
  tipo  = m->get(F_TIPOCF)[0];
  _anno = m->get_int(F_ANNO);
  _g = m->get_int(F_GRUPPO);
  _c = m->get_int(F_CONTO);
  if (tipo == ' ')
     _s = m->get_long(F_SOTTOCONTO);
  else if (tipo == 'C')
     _s = m->get_long(F_SOTTOC_CLIENTE);
       else _s = m->get_long(F_SOTTOC_FORN);
  if (_c == 0)
     _saldo_gruppo = TRUE;
  else if (_s == 0l)
          _saldo_conto = TRUE;
       else _saldo_sottoc = TRUE;   
    
  TLocalisamfile& saldi = _rel1->lfile();
  TRectype from (saldi.curr());
  TRectype to   (saldi.curr());
  from.zero();
  to.zero();
    
  if (_anno != 0)
     annop = sld.EsePre(_anno);

  if (annop != 0)
     from.put(SLD_ANNOES,annop);
  else if (_anno != 0)
          from.put(SLD_ANNOES,_anno);       
       else from.put(SLD_ANNOES,0);
  from.put(SLD_GRUPPO,_g);
  if (_c != 0)
     from.put(SLD_CONTO, _c);
  if (_s != 0l)   
     from.put(SLD_SOTTOCONTO, _s);
  
  if (_anno != 0)
     to.put(SLD_ANNOES,_anno);
  else to.put(SLD_ANNOES, 9999);    
  to.put(SLD_GRUPPO,_g);
  if (_c != 0)
    to.put(SLD_CONTO,_c);
  if (_s != 0l)   
    to.put(SLD_SOTTOCONTO,_s);
    
  if ( _saldo_gruppo || _saldo_conto )
     _cur->setkey(1);
  
  if (_saldo_sottoc)
     _cur->setkey(2);
         
  _cur->setregion(from,to);
  
  return TRUE;   
}

bool gruppo_handler(TMask_field& f, KEY key)
{
  if ( key == K_TAB && f.mask().is_running() ) 
  {
    const TMask& m    = f.mask();
    const int gruppo  = m.get_int(F_GRUPPO);
    const int conto   = m.get_int(F_CONTO);
    const long sottoc = m.get_long(F_SOTTOCONTO);
    TLocalisamfile& pconti = app()->get_relation()->lfile();

    if (gruppo == 0)
    {
      if (conto != 0 || sottoc != 0)
        return f.warning_box("Codice conto impossibile!");
      else
        return f.error_box("E' obbligatorio l'inserimento del gruppo");
    }
    if (conto > 0 && sottoc == 0) // conto => ricerca gruppo
    {
      pconti.zero() ;
      pconti.put(PCN_GRUPPO, gruppo) ;
      pconti.setkey(1) ;
      pconti.read(_isequal, _nolock );
      if (pconti.bad())
        return f.warning_box ("Non esiste il gruppo relativo a questo conto");
    }
    if (sottoc > 0) // sottoconto => ricerca conto
    {
      pconti.zero() ;
      pconti.put(PCN_GRUPPO, gruppo) ;
      pconti.put(PCN_CONTO, conto) ;
      pconti.setkey(1) ;
      pconti.read(_isequal, _nolock );
      if (pconti.bad())
        return f.warning_box ("Non esiste il conto relativo a questo sottoconto");
      else
      {
        TString tmcf = pconti.get(PCN_TMCF);
        if (tmcf.not_empty())
          return f.warning_box ("Non puoi inserire un sottoconto di un conto relativo ad un cliente/fornitore");
      }
    }
  }
  return TRUE;
}


bool sottoc_handler(TMask_field& f, KEY key)
{
  if (key == K_TAB)
  {
    const short id  = f.dlg();
    TLocalisamfile clifo (LF_CLIFO);
    int gruppo = f.mask().get_int(F_GRUPPO);
    if (gruppo == 0) return TRUE;
    int conto = f.mask().get_int(F_CONTO);
    long sottoconto = f.mask().get_long(id);
    if (sottoconto != 0 && conto == 0) return f.error_box("Manca il CONTO");
    if (id == F_SOTTOC_CLIENTE || id == F_SOTTOC_FORN)
    {
      char tmcf = f.mask().get(F_TIPOCF)[0];
      clifo.zero() ;
      clifo.put(CLI_TIPOCF,tmcf);
      clifo.put(CLI_CODCF,sottoconto);
      clifo.setkey(1) ;
      clifo.read(_isequal, _nolock );
      if (clifo.bad())
         return f.warning_box ("Registrazione assente");
    }
    f.mask().stop_run(K_AUTO_ENTER);
  }
  return TRUE;
}

bool CG5200_application::user_create()
{
  _msk  = new TMask("cg5200a");
  _msk->set_handler(F_GRUPPO, gruppo_handler);
  _msk->set_handler(F_SOTTOCONTO, sottoc_handler);
  _msk->set_handler(F_SOTTOC_CLIENTE, sottoc_handler);
  _msk->set_handler(F_SOTTOC_FORN, sottoc_handler);
  _pcon  = new TLocalisamfile(LF_PCON);
  _clifo = new TLocalisamfile(LF_CLIFO);
  _rel   = new TRelation(LF_PCON);
  _rel1  = new TRelation(LF_SALDI);
  _cur   = new TCursor(_rel1, "", 2);
  set_search_field(F_GRUPPO);
  TSheet_field& cs = ss();
  
  return TRUE;
}

bool CG5200_application::user_destroy()
{
  delete _msk;
  delete _pcon;
  delete _clifo;
  delete _rel;
  delete _rel1;
  delete _cur;
  
  return TRUE;
}

int CG5200_application::read(TMask& m)
{
  m.autoload(_rel);
  fai_filtro();
  compilasheet();
  ss().force_update();

  return NOERR;
}

void CG5200_application::add_r(int numrig,int a,real& pds,real& pas,real& sc,char f,real& si,real& pd,
                               real& pa,real& s,TDate& d,long n,real& pdp,real& pap,real& sp)
{
  TSheet_field& cs = ss();
  TString dep (18);
  if (sc > ZERO)
     dep << sc.string(REAL_PICTURE) << " D";
  else if (sc < ZERO)
  {
    sc = -sc;
    dep << sc.string(REAL_PICTURE) << " A";
  }
  TToken_string& riga = cs.row(numrig);
  riga.add(a, 0);
  riga.add(pds.string(),1);
  riga.add(pas.string(),2);
  riga.add(dep,3);
  dep = "";
  if (si != ZERO)
     dep << si.string(REAL_PICTURE) << " " << f;
  riga.add(dep,4);
  riga.add(pd.string(),5); 
  riga.add(pa.string(),6);
  dep = "";
  if (s > ZERO)
     dep << s.string(REAL_PICTURE) << " D";
  else if (s < ZERO)
  {
    s = -s;
    dep << s.string(REAL_PICTURE) << " A";
  }
  riga.add(dep,7);
  riga.add(d.string(),8);
  riga.add(n,9);
  riga.add(pdp.string(),10);
  riga.add(pap.string(),11);
  dep = "";
  if (sp > ZERO)
     dep << sp.string(REAL_PICTURE) << " D";
  else if (sp < ZERO) 
  {
   sp = -sp;
   dep << sp.string(REAL_PICTURE) << " A"; 
  }
  riga.add(dep,12); 
}

void CG5200_application::compilasheet()
{
  char flagsal   = ' ';
  real saldo = ZERO;
  real saldosca = ZERO; 
  real saldopro = ZERO;
  real saldo_gc = ZERO;
  real saldoini_gc     = ZERO;
  real saldosca_gc     = ZERO;
  real saldopro_gc     = ZERO;
  real prg_dare_gc     = ZERO;
  real prg_avere_gc    = ZERO;
  real prg_daresca_gc  = ZERO;
  real prg_averesca_gc = ZERO;
  real prg_darepro_gc  = ZERO;
  real prg_averepro_gc = ZERO;
  real saldoini  = ZERO; 
  real pdare     = ZERO;
  real pavere    = ZERO;
  real pdaresca  = ZERO;
  real paveresca = ZERO;
  real pdarepro  = ZERO;
  real paverepro = ZERO;
  int gruppo, conto, anno;
  long sottoconto;
  long ultimo_num = 0l; 
  TDate ultima_data = 0;
  
  ss().reset();
  _riga.destroy();
  
  TRecnotype items = _cur->items();
  *_cur = 0l;

  for (int i = 0; i < items; i++,++(*_cur))
  {
    anno   = _cur->curr().get_int(SLD_ANNOES);
    gruppo = _cur->curr().get_int(SLD_GRUPPO);
    conto  = _cur->curr().get_int(SLD_CONTO);
    sottoconto = _cur->curr().get_long(SLD_SOTTOCONTO);
    
    if (gruppo != _g) continue;
    
    if (_saldo_conto && conto != _c) continue;
    
    if (_saldo_conto || _saldo_gruppo)
       _riga.add_riga(_cur->curr());
    
    if (_saldo_sottoc)
    {
     flagsal   = _cur->curr().get_char(SLD_FLAGSALINI);
     saldoini  = _cur->curr().get_real(SLD_SALDO); 
     pdare     = _cur->curr().get_real(SLD_PDARE);
     pavere    = _cur->curr().get_real(SLD_PAVERE);
     pdaresca  = _cur->curr().get_real(SLD_PDARESCA);
     paveresca = _cur->curr().get_real(SLD_PAVERESCA);
     pdarepro  = _cur->curr().get_real(SLD_PDAREPRO);
     paverepro = _cur->curr().get_real(SLD_PAVEREPRO);
     ultima_data = _cur->curr().get(SLD_DATAULMOV);
     ultimo_num  = _cur->curr().get_long(SLD_NUMULTMOV); 
     if (flagsal == 'D')
        saldo = pdare + saldoini - pavere;
     else
        saldo = pdare - saldoini - pavere;
     saldosca = pdaresca - paveresca;
     saldopro = pdarepro - paverepro;
     
     add_r(i,anno,pdaresca,paveresca,saldosca,flagsal,saldoini,pdare,pavere,saldo,ultima_data,ultimo_num,pdarepro,paverepro,saldopro);   
    }
  }
  if (_saldo_gruppo || _saldo_conto)
  {
    for (int j = 0; j < _riga.items(); j++)
    {
      TRectype& riga = (TRectype&)_riga[j];
      anno = riga.get_int(SLD_ANNOES);
      pdaresca  = riga.get_real(SLD_PDARESCA);
      paveresca = riga.get_real(SLD_PAVERESCA);
      saldosca  = pdaresca - paveresca;
      saldoini  = riga.get_real(SLD_SALDO);
      pdare  = riga.get_real(SLD_PDARE);
      pavere = riga.get_real(SLD_PAVERE);
      saldo = pdare - pavere + saldoini; 
      if (saldoini > ZERO)
         flagsal = 'D';
      else if (saldoini < ZERO)
      {
        flagsal = 'A';
        saldoini = -saldoini;
      }
      pdarepro  = riga.get_real(SLD_PDAREPRO);
      paverepro = riga.get_real(SLD_PAVEREPRO);
      saldopro  = pdarepro - paverepro;
      ultima_data = riga.get(SLD_DATAULMOV);
      ultimo_num  = riga.get_long(SLD_NUMULTMOV);
      add_r(j,anno,pdaresca,paveresca,saldosca,flagsal,saldoini,pdare,pavere,saldo,ultima_data,ultimo_num,pdarepro,paverepro,saldopro);   
    } 
    _riga.destroy();
  }   
}     

int cg5200(int argc, char* argv[])
{
  CG5200_application a;
  a.run(argc, argv, "Visualizzazione saldi");
  return 0;
}