#include <tabapp.h>  
#include <tabutil.h>
#include <prefix.h>    
#include <nditte.h>

#include "..\ba\batbind.h"
#include "cglib04.h"

class Tabinv_application : public Tab_application
{
private:
  TMask*         _msk;     
  TString        _tabname;
  TTransfer_file _tras_file;
  
  TString _trasf,_control_rec;                   
  long    _ditta_tab, _ditta_tras, _ditta_orig;  
  bool    _disable,_ditte_uguali,_salta_hnd,_messaggio;
  
public:
  virtual bool user_create();
  virtual bool user_destroy();
  virtual void init_query_mode(TMask&);
  virtual void init_modify_mode(TMask&);
  virtual void init_insert_mode(TMask&);
  virtual int  write(const TMask& m);
  virtual int  rewrite(const TMask& m);
  virtual bool check_autorization() const 
  {return FALSE;}

  void leggi_trasfer();
  char cerca_stato(long codditta);
  
  static bool controlli_hnd (TMask_field& f, KEY k);
  
  static bool nascosto_handler(TMask& m, KEY k);    
  static bool stato_invio     (TMask_field& f, KEY k);
  
  static bool ditta_handler (TMask_field& f, KEY k); 
  static bool almeno_un_flag(TMask_field& f, KEY k);
  static bool clifo_comune  (TMask_field& f, KEY k);
  static bool pcon_comune   (TMask_field& f, KEY k);    
  static bool prima_nota    (TMask_field& f, KEY k);    
  static bool iva           (TMask_field& f, KEY k);    
  static bool saldaconto    (TMask_field& f, KEY k);        
  static bool data_invio    (TMask_field& f, KEY k);
  static bool sigla_file    (TMask_field& f, KEY k);    
  static bool chiave_file   (TMask_field& f, KEY k);

  static bool nome_id       (TMask_field& f, KEY k);      
  
  void   setta_chiave       (TMask& m);

  Tabinv_application() {}
  virtual ~Tabinv_application() {}
};

HIDDEN inline Tabinv_application& app() {return (Tabinv_application&) main_app();}

char Tabinv_application::cerca_stato(long ditta)
{
  TTable ind ("%IND");
  TString16 dep;
  char    stato = '\0';
  
  dep.format("%05ld", ditta);
  
  ind.zero();
  ind.put("CODTAB", dep);
  if (ind.read() == NOERR)
    stato = ind.get_char("S6");
  
  return stato;  
}

bool Tabinv_application::nascosto_handler(TMask& m, KEY k)
{
  if (k == K_SHIFT+K_F12)
  { 
    if (app()._tabname == "%IND")
    {             
      app()._disable = FALSE;
      
      m.enable(F_NUMULINV);
      m.enable(F_DATAULIN);
      m.enable(F_STATO);

      if ( (app()._ditta_tab == app()._ditta_tras) && m.mode() != MODE_INS)   
      {
        m.enable(F_USELAB);
        m.enable(F_CHIAVE);
      }
    }
    else
      if (app()._tabname == "%INS")
      {
        m.enable(F_DITTAINV);
        app()._salta_hnd = TRUE;
      }
  }
  
  return TRUE;
}

bool Tabinv_application::stato_invio(TMask_field& f, KEY k)
{
  if ( (k == K_ENTER || k == K_TAB) && f.mask().mode() != MODE_QUERY )
  {                                
    if ( k == K_ENTER)
    {                  
      TString stato = f.get();
      int num = f.mask().get_int(F_NUMULINV);
      TString sigla = f.mask().get(F_USELAB);
      
      if (num == 0 && stato != "")
        return error_box(TR("Numero ultimo invio NON INDICATO: impossibile indicare lo stato ultimo invio"));  
    
      if ( (stato == "F" && sigla == "") || (stato == "D" && sigla != "") )
        return error_box(TR("La sigla ultimo file elaborato deve essere indicata se lo stato ultimo invio e' uguale a F"));    
    }
    
    if (k == K_TAB && app()._messaggio)
    { 
      long codditta = f.mask().get_long(F_DITTAINV);
      
      char stato = app().cerca_stato(codditta);
      
      if (stato != '\0' && app()._disable)
      {
        app()._messaggio = FALSE; 
        return message_box(TR("Rilevato STATO DI RIPARTENZA: prima concludere il trasferimento"));    
      }
    }
  }
  
  return TRUE;
}

bool Tabinv_application::ditta_handler(TMask_field& f, KEY k)
{
  if (k == K_TAB && f.mask().mode() == MODE_QUERY)
  { 
    long codditta = f.mask().get_long(F_DITTAINV);
    
    if (codditta != 0)
    {
      if (!prefix().exist(codditta))
      {
        f.error_box(TR("La ditta selezionata non e' abilitata per la contabilita' "));
        return FALSE;
      }
    }  
  }   
  if (k == K_TAB && f.focusdirty())
  {
    TLocalisamfile ditte (LF_NDITTE);
  
    long ditta = f.mask().get_long(F_DITTAINV);
  
    ditte.setkey(1);
    ditte.zero();
    ditte.put(NDT_CODDITTA, ditta);
    if (ditte.read() == NOERR)
    {
      TString ragsoc = ditte.get(NDT_RAGSOC);
      f.mask().set(F_RAGSOC, ragsoc);
      prefix().set_codditta(ditta);
    }  
    else
      f.mask().set(F_RAGSOC, "");

    app()._ditta_tab = f.mask().get_long(F_DITTAINV);
    
    if (app()._ditta_tab == app()._ditta_tras) 
    { 
      TTable ind ("%IND");
      TString16 dep;
  
      dep.format("%05ld", app()._ditta_tab);
    
      ind.zero();
      ind.put("CODTAB", dep);
      if (ind.read() == NOERR)
      {                
        TString uselab = app()._tras_file.ult_file();
        TString chiave = app()._tras_file.key();
                                                       
        f.mask().set(F_USELAB, uselab);
        f.mask().set(F_CHIAVE, chiave);
      }
      else
      {
        f.mask().set(F_USELAB, "");
        f.mask().set(F_CHIAVE, "");
      }
      app()._ditte_uguali = TRUE;
    }                      
    else 
    {
      app()._ditte_uguali = FALSE;
      f.mask().set(F_USELAB, "");
      f.mask().set(F_CHIAVE, "");
    }  
  }   
  return TRUE;
}

bool Tabinv_application::almeno_un_flag(TMask_field& f, KEY k)
{
  if (k == K_ENTER && f.mask().mode() != MODE_QUERY) 
  {          
    bool cau   = f.mask().get_bool(F_CAUSALI);
    bool clifo = f.mask().get_bool(F_CLIFO);
    bool pcon  = f.mask().get_bool(F_PCON);
    bool pn    = f.mask().get_bool(F_MOV);
    bool iva   = f.mask().get_bool(F_IVA);
    bool fat   = f.mask().get_bool(F_FATT);
    
    if (!cau && !clifo && !pcon && !pn && !iva && !fat)
      return error_box(TR("E' necessario indicare almeno una sigla file da trasferire"));            
    
    long ditta = f.mask().get_long(F_DITTAINV);
    
    app().set_firm(ditta);            
    
    TConfig conf (CONFIG_DITTA);

    TString pcon_cau = conf.get("PcTcCm","cg");
    
    bool causali = f.mask().get_bool(F_CAUSALI);    
    
    if (causali && pcon_cau != "")
      return error_box(TR("Tabella causali in comune: impossibile trasferirla"));
  }
  
  return TRUE;
}

bool Tabinv_application::clifo_comune(TMask_field& f, KEY k)
{
  if (k == K_ENTER && f.mask().mode() != MODE_QUERY)
  {
    long ditta = f.mask().get_long(F_DITTAINV);
    
    app().set_firm(ditta);            
    
    TConfig conf (CONFIG_DITTA);

    TString ana_com  = conf.get("AnCfCm","cg");
    
    bool clifo = f.mask().get_bool(F_CLIFO);
    
    if (clifo && ana_com != "")
      return error_box(TR("Anagrafica clienti / fornitori in comune: impossibile trasferirla"));
  }
  
  return TRUE;
}

bool Tabinv_application::pcon_comune(TMask_field& f, KEY k)
{
  if (k == K_ENTER && f.mask().mode() != MODE_QUERY)
  {
    long ditta = f.mask().get_long(F_DITTAINV);
    
    app().set_firm(ditta);            
    
    TConfig conf (CONFIG_DITTA);
    
    TString pcon_cau = conf.get("PcTcCm","cg");
    
    bool pcon = f.mask().get_bool(F_PCON);
    
    if (pcon && pcon_cau != "")
      return error_box(TR("Anagrafica Piano dei conti in comune: impossibile trasferirla"));
  }
  
  return TRUE;
}

bool Tabinv_application::prima_nota(TMask_field& f, KEY k)
{
  if (k == K_SPACE && f.mask().mode() != MODE_QUERY)
  {
    bool pn = f.mask().get_bool(F_MOV);

    if (!pn && f.mask().get_bool(F_IVA) )    
    {
      f.mask().set(F_MOV, "X");
      return f.error_box(TR("Se si vuole inviare l' iva e' obbligatorio inviare anche la primanota"));            
    }
    if (!pn && f.mask().get_bool(F_FATT) )  
    {
      f.mask().set(F_MOV, "X");
      return f.error_box(TR("Se si vuole inviare il saldaconto e' obbligatorio inviare anche la primanota"));            
    }
  }

  return TRUE;
}

bool Tabinv_application::iva(TMask_field& f, KEY k)
{
  if (k == K_SPACE && f.mask().mode() != MODE_QUERY)
  {
    bool iva = f.mask().get_bool(F_IVA);
    bool sc  = f.mask().get_bool(F_FATT);

    if (iva)
      f.mask().set(F_MOV, "X");
  }

  return TRUE;
}

bool Tabinv_application::saldaconto(TMask_field& f, KEY k)
{
  if (k == K_SPACE && f.mask().mode() != MODE_QUERY)
  {
    bool iva = f.mask().get_bool(F_IVA);
    bool sc  = f.mask().get_bool(F_FATT);

    if (sc)
      f.mask().set(F_MOV, "X");
  }

  return TRUE;
}

bool Tabinv_application::data_invio    (TMask_field& f, KEY k)
{
  if (k == K_ENTER && f.mask().mode() != MODE_QUERY)
  {
    int   num = f.mask().get_int(F_NUMULINV);
    TDate data (f.get());
    
    if (num != 0 && !data.ok())
      return error_box(TR("Se indicato il numero deve essere indicata anche la data di invio"));
    
    if (num == 0 && data.ok())
      return error_box(TR("Se non indicato il numero non puo' essere indicata la data di invio"));
  }
  
  return TRUE;
}

bool Tabinv_application::sigla_file(TMask_field& f, KEY k)
{
  if (k == K_ENTER && f.mask().mode() != MODE_QUERY)
  {
    int     num   = f.mask().get_int(F_NUMULINV);
    TString sigla = f.get();
    
    if (num == 0 && sigla != "")
      return error_box(TR("Numero ultimo invio NON INDICATO: impossibile indicare la sigla ultimo file elaborato"));

    
  }
  
  return TRUE;
}

bool Tabinv_application::chiave_file(TMask_field& f, KEY k)
{
  if (k == K_ENTER && f.mask().mode() != MODE_QUERY)
  {
    TString sigla  = f.mask().get(F_USELAB);
    TString chiave = f.get();
    
    if (sigla == "" && chiave != "")
      return error_box(TR("Sigla ultimo file elaborato NON INDICATA: impossibile indicare la chiave ultimo record elaborato"));
    
    TString stato = f.mask().get(F_STATO);
    
    if (stato != "F" && chiave == "" && sigla != "")
      return error_box(TR("La chiave ultimo record elaborato deve essere indicata obbligatoriamente"));  
  }
  
  return TRUE;
}

void Tabinv_application::setta_chiave(TMask& m)
{
  m.set(F_CODICE, "INS");
  m.field(F_CODICE).check();
}

bool Tabinv_application::nome_id(TMask_field& f, KEY k)
{
  if (k == K_TAB)
  {
    TLocalisamfile ditte (LF_NDITTE);
  
    long ditta = f.mask().get_long(F_DITTAINV);
    if (ditta != 0)
    {
      if (!prefix().exist(ditta))
      {
        f.error_box(TR("La ditta selezionata non e' abilitata per la contabilita' "));
        return FALSE;
      }
    }    
  
    ditte.setkey(1);
    ditte.zero();
    ditte.put(NDT_CODDITTA, ditta);
    if (ditte.read() == NOERR)
    {
      TString ragsoc = ditte.get(NDT_RAGSOC);
      f.mask().set(F_RAGSOC, ragsoc);
    }
    else
      f.mask().set(F_RAGSOC, "");
    
    TTable ind ("%IND");
    TString16 dep;
  
    if (ditta != 0)
    {
      dep.format("%05ld", ditta);
    
      ind.zero();
      ind.put("CODTAB", dep);
      if (ind.read() == NOERR)
      {
        TString stato = ind.get     ("S6");
        int     num   = ind.get_int ("I0");
        TDate   data  = ind.get_date("D0");
      
        f.mask().set(F_STATO,    stato);
        f.mask().set(F_NUMULINV, num);
        f.mask().set(F_DATAULIN, data.string());
      }                     
      else
      {
        f.mask().set(F_STATO,    "");
        f.mask().set(F_NUMULINV, "");
        f.mask().set(F_DATAULIN, "");    
        f.error_box(TR("Codice ditta NON PRESENTE in tabella trasferimenti"));
      }
    }
    else
    {
      f.mask().set(F_STATO,    "");
      f.mask().set(F_NUMULINV, "");
      f.mask().set(F_DATAULIN, "");    
    }
    
    app()._ditta_tab = f.mask().get_long(F_DITTAINV);
  
    if (app()._ditta_tab == app()._ditta_tras)
    {
      TString uselab = app()._tras_file.ult_file();
      TString chiave = app()._tras_file.key();
    
      f.mask().set(F_USELAB, uselab);
      f.mask().set(F_CHIAVE, chiave);
      app()._ditte_uguali = TRUE;
    }                      
    else 
    {
      app()._ditte_uguali = FALSE;
      f.mask().set(F_USELAB, "");
      f.mask().set(F_CHIAVE, "");
    } 
  }
  if (k == K_TAB && !app()._salta_hnd && f.mask().mode() != MODE_QUERY)
  { 
    long codditta = f.mask().get_long(F_DITTAINV);
    
    if (codditta != 0)  
      return message_box(TR("Rilevato STATO DI RIPARTENZA: prima concludere il trasferimento"));
  }
        
  return TRUE;
}

//void Tabinv_application::esegui_controlli(TMask& m)
bool Tabinv_application::controlli_hnd(TMask_field& f, KEY k)
{                                                            
  if (k == K_TAB && !f.mask().field(F_NUMULINV).enabled()) 
  {
    int   num  = f.mask().get_int(F_NUMULINV);
    TDate data (f.mask().get(F_DATAULIN));
    
    if (num != 0 && !data.ok())
      return error_box(TR("Se indicato il numero deve essere indicata anche la data di invio"));
    
    if (num == 0 && data.ok())
      return error_box(TR("Se non indicato il numero non puo' essere indicata la data di invio"));

    TString sigla = f.mask().get(F_USELAB);
    
    if (num == 0 && sigla != "")
      return error_box(TR("Numero ultimo invio NON INDICATO: impossibile indicare la sigla ultimo file elaborato"));
    
    TString stato = f.mask().get(F_STATO);
    
    if (stato != "F" && sigla != "")
      return error_box(TR("La sigla ultimo file elaborato puo' essere indicata solo se lo stato ultimo invio e' F"));  

    TString chiave = f.mask().get(F_CHIAVE);
    
    if (sigla == "" && chiave != "")
      return error_box(TR("Sigla ultimo file elaborato NON INDICATA: impossibile indicare la chiave ultimo record elaborato"));
    
    if (stato != "F" && chiave == "" && sigla != "")
      return error_box(TR("La chiave ultimo record elaborato deve essere indicata obbligatoriamente"));  
  }
  return TRUE;
}

void Tabinv_application::leggi_trasfer()
{                           
  _trasf = ""; 
  _trasf = firm2dir(0);
  _trasf << HEADER;
  
  _tras_file.open(_trasf);
  
  if (_tras_file.exist())
  {  
    if (_tras_file.read_control_rec())  
    {
      _control_rec = _tras_file.record();
      _ditta_tras  = _tras_file.ditta();
    }
    else
      _ditta_tras = 0;
  } 
  else
    _ditta_tras = 0;
}

void Tabinv_application::init_query_mode(TMask& m)
{
  leggi_trasfer();
  _disable = TRUE;
  _messaggio = TRUE;    

  if (_tabname == "%INS")
  {              
    setta_chiave(m);        
    m.send_key(K_AUTO_ENTER,0);  
    
    m.disable(F_DITTAINV);
  }  
  
  m.disable(F_NUMULINV);
  m.disable(F_DATAULIN);
  m.disable(F_STATO);
  m.disable(F_USELAB);
  m.disable(F_CHIAVE);
}

void Tabinv_application::init_modify_mode(TMask& m)
{  
  if (_tabname == "%IND")  
  {
    leggi_trasfer();

    long ditta = m.get_long(F_DITTAINV);
    
    if (ditta == _ditta_tras) 
    { 
      TString uselab = _tras_file.ult_file();
      TString chiave = _tras_file.key();
                                                       
      m.set(F_USELAB, uselab);
      m.set(F_CHIAVE, chiave);
    }
    else
    {
      m.set(F_USELAB, "");
      m.set(F_CHIAVE, "");
    }   

    char stato = app().cerca_stato(ditta);    
    
    if (stato == '\0')
    {
      m.enable(F_CAUSALI);
      m.enable(F_CLIFO);
      m.enable(F_PCON);
      m.enable(F_MOV);
      m.enable(F_IVA);
      m.enable(F_FATT);
      m.enable(F_BOLLATO);    
    }
    else
    {
      m.disable(F_CAUSALI);
      m.disable(F_CLIFO);
      m.disable(F_PCON);
      m.disable(F_MOV);
      m.disable(F_IVA);
      m.disable(F_FATT);
      m.disable(F_BOLLATO);
    }
  }
  if (_tabname == "%INS")
  {                 
    setta_chiave(m);        
  
    m.disable(F_DITTAINV);
    
    long ditta = m.get_long(F_DITTAINV);
    if (ditta == 0)
      m.enable(F_NOMEID);
    else
      m.disable(F_NOMEID);
  }
  
  m.disable(F_NUMULINV);
  m.disable(F_DATAULIN);
  m.disable(F_STATO);
  m.disable(F_USELAB);
  m.disable(F_CHIAVE);  
}

void Tabinv_application::init_insert_mode(TMask& m)
{  
  if (_tabname == "%IND")
    leggi_trasfer();
  
  if (_tabname == "%INS")
    m.disable(F_DITTAINV);
  
  m.disable(F_NUMULINV);
  m.disable(F_DATAULIN);
  m.disable(F_STATO);
  m.disable(F_USELAB);
  m.disable(F_CHIAVE);  
}

int Tabinv_application::write(const TMask& m)
{                                            
  if (_tabname == "%IND")
  {  
    if (m.mode() != MODE_INS)
    {
      TString str;
    
      TString std = m.get(F_STATO);
      
      TConfig conf (CONFIG_DITTA);
      conf.set("FlStInv", std);
    
      int     num    = m.get_int(F_NUMULINV);
      TString data   = m.get    (F_DATAULIN);
      TString sigla  = m.get    (F_USELAB);        
      TString chiave = m.get    (F_CHIAVE);
    
      if (sigla == "")
        sigla = " ";
    
      if (_tras_file.read_control_rec())  
      {                               
        if (_ditte_uguali)
        {
          _control_rec = _tras_file.record();
          str.format("%03d", num);
          _control_rec.overwrite(str,75);
          str = riconverti(data,TRUE);
          _control_rec.overwrite(str,78);
          _control_rec.overwrite(sigla,240);
          str.format("%-60s", (const char*) chiave);
          _control_rec.overwrite(str,241);
        
          _tras_file.write_control_rec(_control_rec,1024);
        }
      }
    }
  }      
  
  return Tab_application::write(m);
}

int Tabinv_application::rewrite(const TMask& m)
{    
  if (_tabname == "%IND")
  {  
    if (m.mode() != MODE_INS)
    {
      TString str;
    
      TString std = m.get(F_STATO);
    
      TConfig conf (CONFIG_DITTA);
      conf.set("FlStInv", std);
    
      int     num    = m.get_int(F_NUMULINV);
      TString data   = m.get    (F_DATAULIN);
      TString sigla  = m.get    (F_USELAB);        
      TString chiave = m.get    (F_CHIAVE);
    
      if (sigla == "")
        sigla = " ";
    
      if (_tras_file.read_control_rec())  
      {  
        if (_ditte_uguali)
        {
          _control_rec = _tras_file.record();
          str.format("%03d", num);
          _control_rec.overwrite(str,75);
          str = riconverti(data,TRUE);
          _control_rec.overwrite(str,78);
          _control_rec.overwrite(sigla,240);
          str.format("%-60s", (const char*) chiave);
          _control_rec.overwrite(str,241);
        
          _tras_file.write_control_rec(_control_rec,1024);
        }
      }
    }
  }    
  
  return Tab_application::rewrite(m);  
}

bool Tabinv_application::user_create()
{ 
  Tab_application::user_create();

  _msk     = get_mask();
  _tabname = get_tabname(); 
  _ditta_orig = -1;
  if (_tabname == "%IND") 
  {                    
    _ditta_orig = prefix().get_codditta();
    _msk->set_handler(nascosto_handler);
    _msk->set_handler(F_STATO,    stato_invio);                 
    _msk->set_handler(F_DITTAINV, ditta_handler);
    _msk->set_handler(F_CAUSALI,  almeno_un_flag);
    _msk->set_handler(F_CLIFO,    clifo_comune);
    _msk->set_handler(F_PCON,     pcon_comune);
    _msk->set_handler(F_MOV,      prima_nota);
    _msk->set_handler(F_IVA,      iva);
    _msk->set_handler(F_FATT,     saldaconto);
    _msk->set_handler(F_DATAULIN, data_invio);
    _msk->set_handler(F_USELAB,   sigla_file);
    _msk->set_handler(F_CHIAVE,   chiave_file);
    _msk->set_handler(F_GHOST_FIELD, controlli_hnd);
    //_msk->disable(F_FATT);     
  }                               
  
  if (_tabname == "%INS")
  {             
    _msk->set_handler(nascosto_handler);  
    _msk->set_handler(F_DITTAINV, nome_id);  
    _salta_hnd = FALSE;
  }
  
  return TRUE;
}

bool Tabinv_application::user_destroy()
{ 
  Tab_application::user_destroy();
  if (_ditta_orig > -1) prefix().set_codditta(_ditta_orig);
  return TRUE;
}

cg6500(int argc, char* argv[])
{
  Tabinv_application* a = new Tabinv_application;
  
  a->run(argc,argv, TR("Tabelle"));
  delete a;
  return 0;
}