// cg5200.cpp  - Visualizzazione saldi

#include <brwapp.h>
#include <config.h>
#include <msksheet.h> 
#include <relapp.h>
#include <tabutil.h>
#include <utility.h>
#include <urldefid.h>

#include <saldi.h>
#include <clifo.h>
#include <pconti.h>

#include "cglib.h"
#include "cg5200.h"

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 (udata > udatar)
        unumr = unum;
      if (flagr == flag)
        saldoinir += saldoini;
      else saldoinir -= saldoini;
      if (saldoinir < ZERO) // saldoinir e' piu' piccolo di saldoini => vince il flag di saldoini
      {
        flagr = flag;
        saldoinir = -saldoinir;
      }      
      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_FLAGSALINI,flagr);
      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;
}

class TSaldibrowse_application : public TBrowse_application
{
  
  TMask*          _msk;
  TLocalisamfile* _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);
  virtual void init_query_mode(TMask&);
  virtual void init_modify_mode(TMask&); 

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

  TSaldibrowse_application() {}
};

HIDDEN TSaldibrowse_application& app() { return (TSaldibrowse_application&) main_app(); }

void TSaldibrowse_application::init_query_mode(TMask& m)
{
  m.disable(DLG_FINDREC);
}

void TSaldibrowse_application::init_modify_mode(TMask& m)
{
  m.disable(DLG_FINDREC);
}

bool TSaldibrowse_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 == '\0')
    _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 TSaldibrowse_application::sottoc_handler(TMask_field& f, KEY key)
{
  if ( key == K_TAB)
  {
    const int  gruppo = f.mask().get_int(F_GRUPPO);
    const int  conto  = f.mask().get_int(F_CONTO);
    if (gruppo == 0 || conto == 0) return TRUE;

    const short id  = f.dlg();
    const long sottoconto = atol(f.get());
    TLocalisamfile& pconti = app().get_relation()->lfile();

    /*  
       if (!f.focusdirty() && gruppo == 0 && conto == 0) return TRUE;
       
       if (sottoconto != 0 && conto == 0) 
       {
       f.warning_box("Manca il CONTO");
       f.mask().stop_run(K_ESC);
       return FALSE;
       }
       if (conto != 0 && gruppo == 0)
       {
       f.warning_box("Manca il GRUPPO");
       f.mask().stop_run(K_ESC);
       return FALSE;
       }  
       */    
    if (id == F_SOTTOCONTO)
    {
      pconti.zero();
      pconti.put(PCN_GRUPPO, gruppo) ;
      pconti.put(PCN_CONTO, conto);
      pconti.put(PCN_SOTTOCONTO, sottoconto);
      pconti.setkey(1);
      pconti.read(_isequal, _nolock);
      if (pconti.good())
      {
        TString ds = pconti.get(PCN_DESCR);
        f.mask().set(F_DESCR_CONTO, ds);
        f.mask().set(F_DESCR_CLIENTE, ds);
        f.mask().set(F_DESCR_FORN, ds);
        f.mask().stop_run(K_AUTO_ENTER);
      }   
      else return f.warning_box("Registrazione assente");              
    } 
    else
    {
      const char tipo = id == F_SOTTOC_CLIENTE ? 'C' : 'F';
      TLocalisamfile clifo (LF_CLIFO);       
      if (sottoconto != 0)
      {
        clifo.zero();
        clifo.put(CLI_TIPOCF,tipo); 
        clifo.put(CLI_CODCF, sottoconto) ;
        clifo.setkey(1);
        if (clifo.read(_isequal, _nolock) == NOERR)
        {
          TString80 rs = clifo.get(CLI_RAGSOC);
          char tipoa = clifo.get_char("TIPOAPER");

          if (tipoa == 'F')
          {
            TString80 cognome, nome;
            cognome = rs.mid(0,30);
            nome    = rs.mid(30,20);
            cognome.trim(); nome.trim();
            
            rs = cognome;
            rs << " " << nome;
          }
          f.mask().set(F_DESCR_CLIENTE, rs);
          f.mask().set(F_DESCR_FORN, rs);
          f.mask().stop_run(K_AUTO_ENTER);
        }
        else return f.warning_box("Registrazione assente");              
      }
      else
        if (gruppo != 0 && conto != 0)
        {
          pconti.zero();
          pconti.put(PCN_GRUPPO, gruppo) ;
          pconti.put(PCN_CONTO, conto);
          pconti.setkey(1);
          pconti.read(_isequal, _nolock);
          if (pconti.good())
          {
            TString ds = pconti.get(PCN_DESCR);
            f.mask().set(F_DESCR_CLIENTE, ds);
            f.mask().set(F_DESCR_FORN, ds);
            f.mask().set(F_DESCR_CONTO, ds);
          }
          f.mask().stop_run(K_AUTO_ENTER);
        }
    }
  }
  return TRUE;
}

bool TSaldibrowse_application::user_create()
{
  _msk  = new TMask("cg5200a");
  _msk->set_handler(F_SOTTOCONTO, sottoc_handler);
  _msk->set_handler(F_SOTTOC_CLIENTE, sottoc_handler);
  _msk->set_handler(F_SOTTOC_FORN, sottoc_handler);
  disable_all();
  _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);
  
  return TRUE;
}

void TSaldibrowse_application::disable_all()
{
  ss().disable();  
}

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

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

  return NOERR;
}

void TSaldibrowse_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();
  char segno = ' ';
  
  TToken_string& riga = cs.row(numrig);
  /*
     TString dep (18);
     if (sc > ZERO)
     dep << sc.string(REAL_PICTURE) << " D";
     else if (sc < ZERO)
     {
     sc = -sc;
     dep << sc.string(REAL_PICTURE) << " A";
     }
     */
  riga.add(a, 0);
  riga.add(si.string(),1);
  if (si != ZERO)   
    riga.add(f,2);   
  riga.add(pd.string(),3); 
  riga.add(pa.string(),4); 
  if (s > ZERO)
    segno = 'D';
  else if (s < ZERO)
  {
    s = -s;
    segno = 'A'; 
  }            
  riga.add(s.string(),5);
  riga.add(segno,6);
  segno = ' ';
  if (sc > ZERO)
    segno = 'D';
  else if (sc < ZERO)
  {
    sc = -sc;
    segno = 'A';
  }     
  riga.add(pds.string(),7);
  riga.add(pas.string(),8);
  riga.add(sc.string(),9);
  riga.add(segno,10);
  /*
     dep = "";
     if (si != ZERO)
     dep << si.string(REAL_PICTURE) << " " << f;
     dep = "";
     if (s > ZERO)
     dep << s.string(REAL_PICTURE) << " D";
     else if (s < ZERO)
     {
     s = -s;
     dep << s.string(REAL_PICTURE) << " A";
     }
     */
  riga.add(d.string(),11);
  riga.add(n,12);
  riga.add(pdp.string(),13);
  riga.add(pap.string(),14);
  /*
     dep = "";
     if (sp > ZERO)
     dep << sp.string(REAL_PICTURE) << " D";
     else if (sp < ZERO) 
     {
     sp = -sp;
     dep << sp.string(REAL_PICTURE) << " A"; 
     }
     */ 
  segno = ' ';
  if (sp > ZERO)
    segno = 'D';
  else if (sp < ZERO)
  {
    sp = -sp;
    segno = 'A';
  }        
  riga.add(sp.string(),15);
  riga.add(segno,16); 
}

void TSaldibrowse_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 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 = saldo + pdaresca - paveresca;  //in realta' non e' proprio il saldo degli scaricati ma quello complessivo
      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;
      flagsal   = riga.get_char(SLD_FLAGSALINI);
      saldoini  = riga.get_real(SLD_SALDO);
      pdare  = riga.get_real(SLD_PDARE);
      pavere = riga.get_real(SLD_PAVERE);
      saldo = pdare - pavere + saldoini;
      saldosca = saldo + pdaresca - paveresca; 
      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[])
{
  TSaldibrowse_application a;
  a.run(argc, argv, "Visualizzazione saldi");
  return 0;
}