#include "cglib04.h"
#include "cg6802.h"

bool TAnn_mov::create()
{
  TApplication::create();

  _pcon     = new TLocalisamfile (LF_PCON);
  _clifo    = new TLocalisamfile (LF_CLIFO);
  _mov      = new TLocalisamfile (LF_MOV);  
  _rmov     = new TLocalisamfile (LF_RMOV);
  _rmoviva  = new TLocalisamfile (LF_RMOVIVA);

  _rec_mov  = new TRectype (LF_MOV);  
  
  _registra = FALSE;
  
  dispatch_e_menu (BAR_ITEM(1));

  return TRUE;
}

bool TAnn_mov::destroy()
{
  delete _pcon;
  delete _clifo;
  delete _mov;                                
  delete _rmov;
  delete _rmoviva;

  delete _rec_mov;  
  
  return TApplication::destroy();
}                                

void TAnn_mov::apri_temp_file()
{
  TString80 tmpmov = "%";
  tmpmov  << get_firm_dir();
  tmpmov << "\\" << TEMP_MOV;
  TString80 tmprmov = "%";
  tmprmov << get_firm_dir();         
  tmprmov << "\\" << TEMP_RMOV;  
  TString80 tmprmoviva = "%";
  tmprmoviva << get_firm_dir();     
  tmprmoviva << "\\" << TEMP_RMOVIVA;                     
  
  _tmov     = new TIsamtempfile(LF_MOV, tmpmov, 0);
  _trmov    = new TIsamtempfile(LF_RMOV, tmprmov, 0);
   
  _is_exist = FALSE; 
  TString tmp = tmprmoviva.mid(1);
  tmp << ".dbf";
  if (fexist(tmp))
  {
    _tiva     = new TIsamtempfile(LF_RMOVIVA, tmprmoviva, 0);
    _is_exist = TRUE;
  }
}

void TAnn_mov::chiudi_tempfile()
{
  delete _tmov;                  
  delete _trmov;    
  if (_is_exist)
    delete _tiva;
}

bool TAnn_mov::set()
{
  _dittaric = get_firm();
  
  if (!esegui_controlli()) return FALSE;
  
  apri_temp_file();
  
  if (!video())
  {
    if (_registra)  
    {
      setta_parametri_record(" ","C");
      chiudi_tempfile();
/*    
      TString80 tpmov = get_firm_dir();
      tpmov << "\\" << TEMP_MOV;
      TString80 tprmov = get_firm_dir();         
      tprmov << "\\" << TEMP_RMOV;  
      TString80 tprmoviva = get_firm_dir();     
      tprmoviva << "\\" << TEMP_RMOVIVA;                     
      
      pack(TRUE,LF_MOV,tpmov);
      pack(TRUE,LF_RMOV,tprmov);
      pack(TRUE,LF_RMOVIVA,tprmoviva);*/
    }
    return FALSE;
  }
  
  chiudi_tempfile();
  
  return FALSE;
}

bool TAnn_mov::video()
{   
  TMask msk ("cg6802a");
  KEY     tasto;
  
  do
  { 
    tasto = msk.run();
    
    if (tasto != K_ENTER) return FALSE;
    
    if (esiste_testata_mov(msk))
    {
      TMask mask ("cg6802b");
      
      mask.set_handler(F_REGIVA,    codice_registro_hnd);
      mask.set_handler(F_CODCAUS,   codice_causale_hnd);  
      
      setta_campi_maschera(mask);
      
      tasto = mask.run();
      
      switch (tasto)
      {
      case K_ESC :
        break;
        
      case K_QUIT :
        break;       
        
      case K_DEL :
      {
        annulla(mask);
        _registra = TRUE;
      }
        break;
        
      default:
        break;
      }
    }
  }
  while (tasto != K_QUIT);                              //K_ENTER
  
  return TRUE;
}

bool TAnn_mov::esiste_testata_mov(TMask& m)
{
  _numreg = m.get_long(F_NUMREG);
  
  _tmov->setkey(1);
  _tmov->zero();
  _tmov->put(MOV_NUMREG, _numreg);
  
  if (_tmov->read() == NOERR)
    *_rec_mov = _tmov->curr();  
  else
    return error_box("Registrazione richiesta NON PRESENTE tra i movimenti in trasferimento");
  
  return TRUE;
}

void TAnn_mov::setta_campi_maschera(TMask& m)
{  
  TDate   datareg (_rec_mov->get_date(MOV_DATAREG));
  TDate   datadoc (_rec_mov->get_date(MOV_DATADOC));
  TString numdoc    = _rec_mov->get     (MOV_NUMDOC);
  TString regiva    = _rec_mov->get     (MOV_REG);
//  regiva.trim();
  long    protiva   = _rec_mov->get_long(MOV_PROTIVA);
  TString codcaus   = _rec_mov->get     (MOV_CODCAUS);
  
  m.set(F_NUMREG,    _numreg);
  m.set(F_DATAREG,   datareg.string());
  m.set(F_DATADOC,   datadoc.string());
  m.set(F_NUMDOC,    numdoc);
  m.set(F_REGIVA,    regiva);
  m.set(F_PROTIVA,   protiva);
  m.set(F_CODCAUS,   codcaus);

  m.disable(F_NUMREG);
  m.disable(F_DATAREG);
  m.disable(F_DATADOC);
  m.disable(F_NUMDOC);
  m.disable(F_REGIVA);
  m.disable(F_PROTIVA);
  m.disable(F_CODCAUS);
}   

void TAnn_mov::annulla(TMask& m)
{
  TRectype* rec_rmov,* rec_riva;
  rec_rmov = new TRectype (LF_RMOV);

// Cancello la testata del movimento

  long numreg = m.get_long(F_NUMREG);

  _tmov->setkey(1);
  _tmov->zero();
  _tmov->put(MOV_NUMREG, numreg); 
  if (_tmov->read() == NOERR)    
    _tmov->remove();

// Cancello tutte le righe di Primanota  

  _trmov->setkey(1);
  _trmov->zero();
  _trmov->put(RMV_NUMREG, numreg); 
  *rec_rmov = _trmov->curr();
  
  for (_trmov->read(); !_trmov->eof(); _trmov->next())
  {
    if (_trmov->curr() > *rec_rmov) break;
    
    _trmov->remove();
  }
  
  delete rec_rmov;

// Cancello tutte le righe iva
  
  rec_riva = new TRectype (LF_RMOVIVA);

  _tiva->setkey(1);
  _tiva->zero();
  _tiva->put(RMI_NUMREG, numreg); 
  *rec_riva = _tiva->curr();
  
  for (_tiva->read(); !_tiva->eof(); _tiva->next())
  {
    if (_tiva->curr() > *rec_riva) break;
    
    _tiva->remove();
  }
  
  delete rec_riva;  
}

bool TAnn_mov::leggi_trasfer()
{ 
  _trasf = _tras_file.path(_dittaric);
  _trasf << HEADER;
  
  _tras_file.open(_trasf);
  
  if (_tras_file.exist())
  {  
    if (_tras_file.read_control_rec())
      _control_rec = _tras_file.record();
    else
      return error_box("Rilevati gravi errori negli archivi:procedura interrotta");
  } 
  else
    return error_box("Al momento non presenti trasferimenti attivi sulla ditta selezionata");
  
  return TRUE; 
}

bool TAnn_mov::codice_registro_hnd(TMask_field& f, KEY k)
{ 
  TTable reg ("REG");
  TString descr,dep;
  
  if (k == K_TAB)
  {              
    TString codreg = f.get();
    TDate   datareg (f.mask().get(F_DATAREG));
    int     anno   = date2esc(datareg);
    
    reg.zero();
    reg.put("CODTAB", codreg);
    if (reg.read() == NOERR)
    {
      descr = reg.get("S0");
      f.mask().set(F_DESCRREG, descr);
    }
  } 
  
  return TRUE;
}

bool TAnn_mov::codice_causale_hnd(TMask_field& f, KEY k)
{
  TLocalisamfile cau (LF_CAUSALI);
  TString descr;
  
  if (k == K_TAB)
  {         
    TString codcau = f.get();
    
    cau.setkey(1);
    cau.zero();
    cau.put("CODCAUS", codcau);
    if (cau.read() == NOERR)
    {
      descr = cau.get("DESCR");
      f.mask().set(F_DESCRCAU, descr);
    }                                 
  }            

  return TRUE;
}

bool TAnn_mov::esegui_controlli()
{                    
  TConfig conf(CONFIG_DITTA);           
  
  _std = conf.get("FlStTra");

  if (!prefix().exist(_dittaric))
    return error_box("Rilevati GRAVI ERRORI negli archivi: procedura interrotta");

  if (!leggi_trasfer())
    return FALSE;      
  
  if (!controlli())
    return FALSE;
  
  return TRUE;
}

bool TAnn_mov::controlli()
{                
  TString16 chiave,sigla;
  
  chiave = _control_rec.sub(241,256);
  chiave.trim();        
  sigla  = _control_rec.sub(240,241);
  sigla.trim();

  if (_std == "M" && sigla == "Z" && chiave != "")
    return error_box("Variazione NON POSSIBILE: trasferimento movimenti gia' iniziato");           
  
  if (_std == "M" && sigla == "U")
    return error_box("Variazione NON POSSIBILE: trasferimento movimenti gia' iniziato");           
  
  if (_std == "*") 
  {
    warning_box("Trasferimento interamente completato: proseguire per cancellare il file");    
    _tras_file.remove_all();
    setta_parametri_record(""," ");
    return FALSE;
  }

  if (_std == "T")
    return error_box("Variazione NON POSSIBILE: eseguire prima la ricezione delle tabelle");           
  
  return TRUE;
}

void TAnn_mov::leggi_record_controllo()
{
  _tras_file.read_control_rec();
  _control_rec = _tras_file.record();
}

void TAnn_mov::setta_parametri_record(const TString& sigla,const TString& flag)
{ 
  TConfig conf (CONFIG_DITTA);
  
  conf.set("FlStTra", flag);

  leggi_record_controllo();
  _control_rec.overwrite(sigla,240);
    
  const int size = 1024;
    
  _tras_file.write_control_rec(_control_rec, size);
}

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