// quadb_b1.cpp
#include <relapp.h>
#include <urldefid.h>
#include <tabutil.h>
#include <config.h>
#include "774200.h"
#include "77lib.h"   
#include "quadrob.h"
#include "quadrob1.h"
#include "77qb.h"
#include "77qb1.h"

#define CODDITTA77	181
#define	ANNODIC77	182

class TQuadriBB1_application : public TRelation_application
{
    static bool codditta77_handler (TMask_field& m, KEY k);
    static bool PrimoNprogLibero   (TMask& m, const long codditta, const long coddip);
    static bool CodDipHandler      (TMask_field& m, KEY k);
    static bool NprogExitHandler   (TMask_field& m, KEY k);
    static bool QBTotRedImpHandler (TMask_field& f, KEY k);
    static bool QBAmmRopeHandler   (TMask_field& f, KEY k);
    static bool QBTotIndennHandler (TMask_field& f, KEY k);
    const char*   _maskname;
    int           _num;
    int			_pos_quadro;  // posizione nell'array dei quadri. Usato in set_comp
    TString16     _quadro;
    TRiporti      _rip;
    TRelation*    _rel;
    TMask*        _msk[2];
    bool          _registra;
    int			_anno_dic;
    int              _mode;    
    bool			_MaskConAnnoDic, _MaskConCodditta;
    bool			MaskConAnnoDic() const;
    bool			MaskConCodditta() const { return _MaskConCodditta; }
    bool			QuadroB()  const { return _num == LF_QUAB;  }
    bool			QuadroB1() const { return _num == LF_QUAB1; }
    bool 			CheckImporti(const TMask& m);            
    bool 			EsisteGiaCodDip(const TMask& m);
    bool 			EsisteGiaRecordDip(const TMask& m);
    long			_codditta;              
    void 			init_mask(TMask&);  

  protected:
    virtual bool user_create();
    virtual bool user_destroy();                  
//    virtual int  read(TMask& m);
    virtual int  rewrite(const TMask& m);
    virtual int  write  (const TMask& m);  
    virtual bool remove();                     
    virtual void on_config_change();
    virtual TMask* get_mask(int);
    virtual bool changing_mask(int);           
    TMask*  load_mask(int n);
    virtual TRelation* get_relation() const { return _rel; }  
    virtual void init_query_mode(TMask&);
    virtual void init_query_insert_mode(TMask&);  
    virtual void init_insert_mode(TMask&);
    virtual void init_modify_mode(TMask&);

  public:                                                                     
    TQuadriBB1_application(const char* name, const int num, const char* quadro);
};

TQuadriBB1_application::TQuadriBB1_application(const char* name, const int num, const char* quadro)
: _maskname(name), _num(num), _mode(0),
  _MaskConCodditta(FALSE), _MaskConAnnoDic(FALSE),
  _rel(NULL), _quadro(quadro) 
{
  memset(_msk, 0, sizeof(_msk));  
  switch (_num)
  {
    case LF_QUAB:
      _pos_quadro = B;
      break;
    case LF_QUAB1:
      _pos_quadro = B1;
      break;
  }
}

TQuadriBB1_application& app() { return (TQuadriBB1_application&)main_app(); }

bool TQuadriBB1_application::changing_mask(int mode)
{
  if (mode == MODE_QUERY)
    return _mode != MODE_QUERY;
  else
    return TRUE;
}
        
TMask* TQuadriBB1_application::get_mask(int mode)
{
  const int m = (mode == MODE_QUERY) ? 0 : 1;
  _mode = mode;
  return load_mask(m);
}

TMask* TQuadriBB1_application::load_mask(int n)
{
  if (_msk[n] != NULL) 
    return _msk[n]; 
    
  TFilename name("77qb"); 
  
  if (n == 0) 
  { 
    switch (_num) 
    {
      case LF_QUAB:       
        name << 'a';  
        break; 
      case LF_QUAB1:      
        name << "1a";  
        break;
      default:
        break;
    }
  }
  else 
  {
    switch (_num)
    {
      case LF_QUAB:       
        name << 'b';
        break;
      case LF_QUAB1:      
        name << "1b";
        break;
      default:
        break;
    }
  }  
  
  TMask* m = new TMask(name);
  m->set_handler(CODDITTA77,   codditta77_handler);  
  if (QuadroB())
    m->set_handler(QBF_CODDIP,   CodDipHandler);    
  else
    m->set_handler(QB1F_CODDIP,  CodDipHandler);    
  m->set_handler(QuadroB() ? QBF_NPROG : QB1F_NPROG,   NprogExitHandler);    

  switch (n)
  {                                   
    case 0:
      break;
    case 1:                                 
      if (m)
        if (QuadroB())
        {  
          m->set_handler(QBF_TOTIMP, QBTotRedImpHandler);
          m->set_handler(QBF_ROPE,   QBAmmRopeHandler);
          m->set_handler(QBF_AMMNETTO,  QBTotIndennHandler);
          m->set_handler(QBF_AMMNETTO2, QBTotIndennHandler);    
          m->set_handler(QBF_CONTLAV,   QBTotIndennHandler);    
          m->set_handler(QBF_TFR7494,   QBTotIndennHandler);    
          m->set_handler(QBF_INDEN7494, QBTotIndennHandler);            
          set_search_field(QBF_QUAB_CODDIP);
        }
        else                           
          set_search_field(QB1F_ANADIP_CODDIP);  
      break;
    default:
      break;  
  }        
  m->disable(DLG_FINDREC);
  
  return _msk[n] = m;
}

bool TQuadriBB1_application::MaskConAnnoDic() const
{
  return  _MaskConAnnoDic;
}

void TQuadriBB1_application::on_config_change()
{
  TConfig conf(CONFIG_STUDIO);
  _anno_dic = (int)conf.get_long(ANNO_SEL, NULL, -1, TDate(TODAY).year());
}
                                    
bool TQuadriBB1_application::user_create()
{           
  _registra = FALSE;
  _rel = new TRelation(_num);
  _codditta = get_firm_770();
  return TRUE;
}

bool TQuadriBB1_application::user_destroy()
{  
  if (_quadro != "")
    if (_registra)
      _rip.set(_quadro);
  if (_msk[1] != NULL) delete _msk[1];
  if (_msk[0] != NULL) delete _msk[0];
  delete _rel;
  return TRUE;
}                         

// Q.B. Controlla che ci sia diverso da ZERO il tot.red.imp.
bool TQuadriBB1_application::CheckImporti(const TMask& m)
{
  real TotRedImp(m.get(QBF_TOTIMP));  
  return TotRedImp != ZERO;
}

// Controlla se esiste gia' un record con lo stesso cod.dip.
bool TQuadriBB1_application::EsisteGiaCodDip(const TMask& m)
{
  TLocalisamfile q(_num);
  const long codip = m.get_long(QuadroB()? QBF_CODDIP : QB1F_CODDIP);
  q.zero();
  q.put(QB_CODDITTA, _codditta);   
  q.put(QB_CODDIP,   codip);

  TRectype dep(q.curr());
  q.read(_isgteq);
  return q.curr() == dep;
}

// Controlla se esiste gia' una chiave completa
bool TQuadriBB1_application::EsisteGiaRecordDip(const TMask& m)
{
  TLocalisamfile q(_num);
  const long codip = m.get_long(QuadroB()? QBF_CODDIP : QB1F_CODDIP);
  const long nprog = m.get_long(QuadroB()? QBF_NPROG  : QB1F_NPROG);
  q.zero();
  q.put(QB_CODDITTA, _codditta);   
  q.put(QB_CODDIP,   codip);               
  q.put(QB_NPROG,    nprog);
  TRectype dep(q.curr());
  return q.read() == NOERR;
}

int TQuadriBB1_application::rewrite(const TMask& m)
{
  m.autosave(_rel);
  const int err = _rel->rewrite();      
  _registra = err == NOERR;
  return err;
}
/*
int TQuadriBB1_application::read(TMask& m)
{
  int err;
  TLocalisamfile q(_num);
  const long codip = m.get_long(QuadroB()? QBF_CODDIP : QB1F_CODDIP);
  const long nprog = m.get_long(QuadroB()? QBF_NPROG  : QB1F_NPROG);
  q.zero();
  q.put(QB_CODDITTA, _codditta);   
  q.put(QB_CODDIP,   codip);               
  q.put(QB_NPROG,    nprog);
  err = q.read();
  err = _rel->read();
  return err;
}  */

int TQuadriBB1_application::write(const TMask& m)
{
  m.autosave(_rel);
  if (QuadroB1())
    if (EsisteGiaRecordDip(m))
      return warning_box("E' già presente un record per questo dipendente");
  const int err = _rel->write();
  _registra = err == NOERR;
  return err;
}

bool TQuadriBB1_application::remove()
{
  _registra = TRUE;
  return TRelation_application::remove();
}

void TQuadriBB1_application::init_mask(TMask& m)
{
  if (QuadroB())
  {
    const long codditta = m.get_long(QBF_CODDITTA);
    const long codip    = m.get_long(QBF_CODDIP);
    if (codip==0L)
      return;
    if (is_erede(codditta,codip))
    {
      m.disable(-GROUP_ALL);   // Disabilita tutti i campi
      m.enable(-GROUP_EREDE);  // Abilita solo quelli giusti
    }
    else
    {
      m.enable(-GROUP_ALL);   
      if (is_deceduto(codditta,codip) || is_dipendente(codditta,codip))
        m.disable(-GROUP_DIPDEC);
      else
        m.enable(-GROUP_DIPDEC);
    }
  }
}

void TQuadriBB1_application::init_modify_mode(TMask& m)
{
  init_mask(m);
}

void TQuadriBB1_application::init_insert_mode(TMask& m)
{
  init_mask(m);
}

void TQuadriBB1_application::init_query_mode(TMask& m)
{                   
  m.set(ANNODIC77, _anno_dic); 
}

void TQuadriBB1_application::init_query_insert_mode(TMask& m)
{}

bool TQuadriBB1_application::codditta77_handler(TMask_field& f, KEY k)
{
  TString16 codditta; codditta << app()._codditta;
  TMask& m = f.mask();
  if (codditta != "0")        
  {
    m.set(CODDITTA77, codditta);
    m.field(CODDITTA77).check();
  }
  return TRUE;
}


///////////////////////////////////////////////////////////
// 2 modi :
//  RUN,773,-1,771230m,89,"Prospetto del Quadro E1","E1"    [771230i.uml]
// oppure
//  773 -1 menu_st "Stampe dichiarazioni" [prassi.mnu]
// QUADRO N:
// 773,-2,77qn,72,"Quadro N","N"
///////////////////////////////////////////////////////////
int quadriB_B1(int argc, char* argv[])
{
  TFilename mask;
  int num = 0;
  if (argc > 1) 
    mask = argv[2];
  num    = atoi(argv[3]);
  const char* title  = argv[4];             
  const char* quadro = argv[5];
  TQuadriBB1_application a(mask, num, quadro);
  a.run(argc, argv, title ? title : "Test Relation Application");
  return 0;
}

//
// CodDipHandler
// 
//   1 - Controlla che il codice dipendente esista
//   2 - Propone il primo progressivo disponibile per quel codice
//
bool TQuadriBB1_application::CodDipHandler(TMask_field& f, KEY k)
{
  TMask& m = f.mask();             
  if (!m.is_running()) return TRUE;  
//  if (k == K_TAB && ricerca(m))
  if (k == K_TAB)
  {                                           
    const long codip = atol(f.get());
    if (codip==0L) 
      return TRUE;

    if (!esiste_dipendente(app()._codditta, codip))
      return f.warning_box("Dipendente inesistente");

    PrimoNprogLibero(m, app()._codditta, codip);
  }       
  return TRUE;
}

bool TQuadriBB1_application::NprogExitHandler(TMask_field& f, KEY k)
{
  TMask& m = f.mask();
  if (!m.is_running()) return TRUE;
  
  if (k == K_TAB)
  {
    TString nprog(f.get());
    if (nprog.not_empty())
    {
      const int ID_CODDIP = app().QuadroB()? QBF_CODDIP : QB1F_CODDIP;
// Controlla che esista il dipendente 
      const long codip = m.get_long(ID_CODDIP);
      const long codditta = app()._codditta;

      if (codip==0L) 
        return TRUE;

      if (!esiste_dipendente(codditta, codip))
        return f.warning_box("Dipendente inesistente");

// Nel B1 e nel B (per gli eredi) può esserci un solo record per dipendente
      if (app().QuadroB1() || (app().QuadroB() && is_erede(codditta,codip)) )
        if (app().EsisteGiaCodDip(m) && !app().EsisteGiaRecordDip(m))  
          return warning_box("Esiste già una riga per questo dipendente");    

      m.stop_run(K_AUTO_ENTER);
    }
  }
  return TRUE;
}

bool TQuadriBB1_application::PrimoNprogLibero(TMask& m, const long codditta, const long codip)
{
// Propone il primo numero disponibile
  if (codip != 0L)
  {
    long nprog = 0L;              
    const int id_nprog = app().QuadroB() ? QBF_NPROG : QB1F_NPROG;
    const bool erede = is_erede(codditta,codip);
    bool EsisteGiaDip = FALSE;
    TLocalisamfile qb(app()._num);
    qb.zero();
    qb.put(QB_CODDITTA, codditta);
    qb.put(QB_CODDIP,   codip);
    TRectype dep(qb.curr());
    for (qb.read(_isgteq); !qb.eof(); qb.next())
    {
      if (qb.curr() > dep) break;
      EsisteGiaDip = TRUE;
      nprog = qb.get_long(QB_NPROG);
    }

// Nel B se e' un erede si puo' solo andare in modifica
// Nel B1 è consentito un solo record per dipendente
    if ( (nprog == 0) || (app().QuadroB1() && !EsisteGiaDip) ||
                         (app().QuadroB() && !erede) )
      nprog++;

    TString16 nprog_str; nprog_str << nprog;
    m.set(id_nprog, nprog_str);
  }
  return TRUE;                   
}                         

///////////////////////////////////////////////////////////////////////////////////
// QUADRO B
///////////////////////////////////////////////////////////////////////////////////
bool TQuadriBB1_application::QBTotRedImpHandler(TMask_field& f, KEY k)             
{
  TMask& m = f.mask();
  if (k == K_ENTER && !ricerca(m))
  {
    const long codditta = m.get_long(QBF_CODDITTA);
    const long codip    = m.get_long(QBF_CODDIP);
    if (!is_erede(codditta,codip))
    {
      real totimp(f.get());
      if (totimp == ZERO)
        return f.warning_box("Il totale reddito imponibile non può essere nullo");
    }
  }
  return TRUE;
}

bool TQuadriBB1_application::QBAmmRopeHandler(TMask_field& f, KEY k)             
{
  TMask& m = f.mask();  
  if (k == K_ENTER && !ricerca(m))
  {
    TMask& m = f.mask();
    const long codditta = m.get_long(QBF_CODDITTA);
    const long codip    = m.get_long(QBF_CODDIP);
    if (!is_erede(codditta,codip))
    {
      real totimp(m.get(QBF_TOTIMP));
      real rope(f.get());            
      if (rope > totimp)
        return f.warning_box("Il totale ritenute non può essere maggiore del totale reddito imponibile");
    }
  }
  return TRUE;
}

// 23.5.96 Calcola totale indennità
bool TQuadriBB1_application::QBTotIndennHandler(TMask_field& f, KEY k)             
{
  if (k == K_TAB)
  {
    const bool ricalcola = f.focusdirty();
    if (ricalcola)
    {
      TMask& m = f.mask();                             
      real c20 = m.get_real(QBF_AMMNETTO);
      real c24 = m.get_real(QBF_AMMNETTO2);
      real c25 = m.get_real(QBF_CONTLAV);
      real c26 = m.get_real(QBF_TFR7494);
      real c27 = m.get_real(QBF_INDEN7494);
      
      real c28 = c20 + c24 - c25 + c26 + c27;
      TString c28s(c28.string());
      m.set(QBF_TIND7494, c28s);
    }
  }
  return TRUE;
}