#include <direct.h>

#include <applicat.h>
#include <archives.h>
#include <mask.h>    
#include <progind.h>
#include <tabutil.h>
#include <utility.h>

#include "ve5100a.h"    

#include "velib.h"

class TDeletedoc_app : public TSkeleton_application
{                                     
  TArchive       _arc;      
  TString        _desc, _last_std;
  char           _unit;
  TFilename      _tmp_dir;
  TIsamtempfile  *_tdoc,*_trdoc;
  
protected:

  void backup_delete_doc(int op, int who); // Backup e cancellazione dei documenti da eliminare
  void restore_doc();                      // Ripristino documenti da disco
  void create_tmp_files(bool create=TRUE);
  void delete_tmp_files(bool remove=TRUE);
  virtual bool create();
  virtual bool destroy();
  virtual void main_loop();  

static bool state_handler(TMask& m, KEY k);
  
public:

  TDeletedoc_app() {};  
  ~TDeletedoc_app() {};  
};

bool TDeletedoc_app::state_handler(TMask& m, KEY k)
{
  if (k == K_SHIFT + K_F7)
    m.enable(F_STATUS);
  
  return TRUE;
}

void TDeletedoc_app::backup_delete_doc(int op, int who)
{
  
  TIsamfile doc(LF_DOC);
  TIsamfile rdoc(LF_RIGHEDOC);
  TIsamfile clifo(LF_CLIFO);
  TIsamfile cfven(LF_CFVEN);
  TIsamfile tab(LF_TAB);
  TIsamfile occas(LF_OCCAS);
  TIsamfile movmag(LF_MOVMAG);
  TIsamfile rmovmag(LF_RMOVMAG);
  
  
  doc.open();
  rdoc.open();
  clifo.open();
  cfven.open();
  tab.open();
  occas.open();
  movmag.open();
  rmovmag.open();
  
  int err = doc.lock();
  if (err != NOERR) 
  {
    error_box("Il file documenti non puo' essere bloccato in modo esclusivo."
              " Nessun documento cancellato. Errore %d.",err);
    return;
  }

  TDocumento documento;
  if (op & 0x2)
    create_tmp_files();

  TString_array to_zap; // Array contenente le chiavi dei documenti da eliminare
  TRecnotype total = 0;
  
  doc.zero();                                        
  // Scorre il file dei documenti
  {
    TProgind p(doc.items(), "Ricerca dei documenti ...", TRUE, TRUE);
    for (int scanerr = doc.first(); 
         scanerr == NOERR && !p.iscancelled(); 
         scanerr = doc.next())
    {
      p.addstatus(1);
      documento.read(doc.curr());
      
      bool to_delete = FALSE;
      
      if (who & 0x1)
      {
        if (doc.get(DOC_STATO) == _last_std) 
          to_delete = TRUE;
      }
      if (who & 0x2)
      {
        if (doc.get_bool(DOC_DOCEVASO)) 
          to_delete = TRUE;
      }
  
      if (to_delete) // Se TRUE il puo' essere eliminato!
      {              // Memorizza la chiave 1 del documento in un array
        if (op & 0x1)
        {
          TToken_string id(30);
          id = doc.get(DOC_PROVV);
          id.add(doc.get(DOC_ANNO));
          id.add(doc.get(DOC_CODNUM));
          id.add(doc.get(DOC_NDOC));
          to_zap.add(id);
        }
        if (op & 0x2)
        {
          err = _tdoc->write(doc.curr());
          const int rows = documento.physical_rows();
          // Memorizza le righe del documento sui file temporanei
          for (int x = 1; err == NOERR && x <= rows; x++)
            err = _trdoc->write(documento[x]);   
        }
        else
          err = NOERR;
        total++;
      }       
    }  // end of for
    if (p.iscancelled()) 
      total = 0;
  }

  if (total != 0) 
  {
    if (err==NOERR)           
    {
      bool rt = TRUE;
      if (op & 0x2)
      {
        doc.close();   rdoc.close(); clifo.close();
        cfven.close(); tab.close();  occas.close();
        movmag.close(); rmovmag.close();
        const char * dir = &_tmp_dir[1];
        delete_tmp_files(FALSE); //Close tmp files only
        rt = _arc.backup(dir,_unit,_desc, FALSE);// Backup dei documenti da eliminare, prefix unnecessary
        create_tmp_files(FALSE); // Reopen tmp files.
        doc.open(_excllock); rdoc.open(); clifo.open();
        cfven.open(); tab.open(); occas.open();
        movmag.open(); rmovmag.open();
      }
      if (rt & (op & 0x1)) 
      {
        // Effettiva cancellazione dei documenti
        TString caption("Confermare la cancellazione di ");
        caption.add_plural(total, "documento");
        if (yesno_box(caption))
        {
          TProgind pi(total, caption, FALSE, TRUE, 10);
          for (int i = 0; i < to_zap.items(); i++)
          {          
            TToken_string& id = to_zap.row(i);        
            id.restart();
            const char provv = id.get_char();
            const int  anno  = id.get_int();
            const TString16 codnum = id.get();
            const long numdoc = id.get_int();
            documento.read(provv,anno,codnum,numdoc);
            documento.TMultiple_rectype::remove(doc);
            pi.addstatus(1);
          }   
        }
      }                                          
    }
    else
      error_box("Errore %d scrivendo sui files temporanei."
                " La cancellazione dei documenti chiusi non verra' effettuata.",err);
  }
  if (op & 0x2)
    delete_tmp_files();    // Physical remove of tmp files
  
}

void TDeletedoc_app::restore_doc()
{
  TIsamfile doc(LF_DOC);
  TLocalisamfile rdoc(LF_RIGHEDOC);

  doc.open();
  int err = doc.lock();
  if (err != NOERR)  
  {
    error_box("Il file documenti non puo' essere bloccato in modo esclusivo."
              " Nessuna documento ripristinato. Errore %d.",err);
    return ;
  }
  const char* dir =& _tmp_dir[1]; // Cut out % sign
  if (_arc.restore(dir,_unit,FALSE, FALSE))
  {
    create_tmp_files(FALSE);  // In realta' ci sono gia'
    const TRecnotype items = _tdoc->items() + _trdoc->items();
    TProgind pi(items, "Ripristino documenti archiviati", FALSE, TRUE, 10);

    for (_tdoc->first();_tdoc->good() && err==NOERR;_tdoc->next())
    {
      if ((err=doc.write(_tdoc->curr())) == _isreinsert)
        err=doc.rewrite(_tdoc->curr());
      pi.addstatus(1);
    }
    if (err != NOERR) 
      error_box("Errore %d ripristinando il file DOCUMENTI.",err);  
    else
    {
      for (_trdoc->first();_trdoc->good() && err==NOERR;_trdoc->next())
      {
        if ((err=rdoc.write(_trdoc->curr())) == _isreinsert)
          err=rdoc.rewrite(_trdoc->curr());
        pi.addstatus(1);
      }
      if (err != NOERR)
        error_box("Errore %d ripristinando il file RIGHE DOCUMENTI.",err);  
    }
    delete_tmp_files();  // Removes tmp files!
  } 
  else
    error_box("Errore nel ripristino dei file da dischetto. Nessuna documento ripristinato.");
  doc.close();
}

void TDeletedoc_app::create_tmp_files(bool create)
{
  TFilename tf(_tmp_dir);
  tf.add("f1");
  _tdoc   = new TIsamtempfile(LF_DOC,tf,create);
  tf.rtrim(1); tf << "2";
  _trdoc   = new TIsamtempfile(LF_RIGHEDOC,tf,create);
}                     

void TDeletedoc_app::delete_tmp_files(bool remove)
{
  if (remove)        // Cosi' posso forzare la cancellazione in chiusura
  {
    _tdoc->set_autodel();
    _trdoc->set_autodel();
  }
  delete _tdoc;
  delete _trdoc;
  _tdoc = NULL;
  _trdoc = NULL;
}

bool TDeletedoc_app::create()
{
  _tmp_dir.temp();
  _tmp_dir = _tmp_dir.path();
  _tmp_dir << "VE";
  if (!_tmp_dir.exist()) 
    make_dir(_tmp_dir);
  _tmp_dir.insert("%");  // Add % sign 
  
  TTable std("%STD");
  std.last(); // Reperisce lo stato eliminabile
  _last_std = std.get("CODTAB");

  return TSkeleton_application::create();
}

bool TDeletedoc_app::destroy()
{                
  _tmp_dir=_tmp_dir.sub(1); // Cut out % sign
  if (_tmp_dir.exist()) 
    rmdir(_tmp_dir);
  return TSkeleton_application::destroy();
}

void TDeletedoc_app::main_loop()
{               
  TMask m("ve5100a");
  m.set_handler(state_handler);

  m.set(F_STATUS,_last_std);
  
  while (m.run() != K_QUIT) 
  {                 
    _unit       = m.get(F_UNIT)[0];
    _desc       = m.get(F_DESC);
    const int scelta = m.get_int(F_OPERAZIONE);
    const int cosa = m.get_int(F_DOCUMENTI);
    switch (scelta)
    {
      case 1 : backup_delete_doc(0x1, cosa); break;
      case 2 : backup_delete_doc(0x2, cosa); break;
      case 3 : backup_delete_doc(0x3, cosa); break;
      default: restore_doc(); break;
    }
  }
}


int ve5100(int argc, char* argv[])
{
  TDeletedoc_app a;
  a.run(argc, argv, "Eliminazione documenti");
  return 0;
}