#include <applicat.h>
#include <isam.h>
#include <mask.h>
#include <prefix.h>
#include <progind.h>
#include <relation.h>
#include <tabutil.h>
#include <utility.h>

#include <mov.h>
#include <urldefid.h>

#include "cg5.h"
#include "cg5400.h"

class TRipristina_stampa : public TApplication
{
  TMask* _msk;
  long _default_firm;

  virtual bool create() ;                         
  virtual bool destroy() ;                        
  bool menu(MENU_TAG);
  bool do_restore(long firm, const char * reg, int year, int month, 
                  int day, bool giornale);
  static bool firm_handler(TMask_field& f, KEY key);

public:
  TRipristina_stampa() : _msk(NULL) {}
};

bool TRipristina_stampa::firm_handler(TMask_field& f, KEY key)
{
  if (f.to_check(key))
  {
    const long firm = atol(f.get());

    if (firm < 0)
      return f.error_box("Codice ditta errato");
    else
      if (firm == 0)
        return f.error_box("La ditta e' obbligatoria");
      else
        if (!prefhndl->exist(firm))
          return f.error_box("Gli archivi della ditta %ld non sono stati ancora generati", firm);
        else
        {
          if (main_app().get_firm() != firm)
            main_app().set_firm(firm);
          
          TMask_field& r = f.mask().field(F_REG);  
          r.set_dirty();
          r.on_key(K_TAB);
        }  
  }
  return TRUE;
}

bool TRipristina_stampa::do_restore(long firm, const char * regist, 
                                    int year, int month, int day,
                                    bool giornale)
{
  bool ok = TRUE;
  CHECK(firm > 0, "Non posso ripristinare sui dati comuni");
  CHECKS(regist && *regist && strlen(regist) <= 3, "Registro errato ", regist);
  CHECKD(month > 0 && month < 13, "Mese errato ", month);
  set_firm(firm);

  const char * const fieldname = giornale ? MOV_STAMPATO : MOV_REGST;
  TRelation rel(LF_MOV);
  TLocalisamfile & mov = rel.lfile();
  TTable reg("REG");
  TString16 s; s.format("%04d%s", year, regist);
  
  reg.zero();
  reg.put("CODTAB", s);
  
  
  TDate inizio_anno(1, 1, year);
  if (reg.read(_isequal, _lock) == NOERR)
  {
    TDate dlast(reg.get_date("D3"));

    if (giornale)
    {
      TTable esc("ESC");
      esc.zero();
      esc.put("CODTAB", format("%04d", year));
      if (esc.read() != NOERR)
      {
        set_firm(_default_firm);
        return error_box("Esercizio %s assente", year);
      }
      
      TDate wd(esc.get_date("D0"));
      inizio_anno = wd;  

      // Determina il corretto anno solare dell'esercizio: se il giorno di inizio esercizio
      // e successivo alla data di ripristino allora mi trovo nell'anno solare successivo
      year = wd.year();
      if (wd.month() > month || (wd.month() == month && wd.day() > day))
        year++;
    }                  
    
    const int ld = TDate::last_day(month, year);
    if (day > ld) day = ld;
    TDate d(day, month, year);
    
    TRectype from(mov.curr()); from.zero();
    TRectype to(from);
    TString16 filter;
    
    from.put(MOV_DATAREG, d);
    to.put(MOV_DATAREG, dlast);
    if (!giornale)
      filter.format("%s==\"%s\"", MOV_REG, regist);
    
    TCursor cursor(&rel, filter, 2, &from, &to);
    long last_num = 0L;
    
    cursor = 0L;
    const long nitems = cursor.items();
    
    TProgind p(nitems ? nitems : 1, format("Ripristino stampa del registro %s", (const char *) regist) , TRUE, TRUE, 70);
    
    if (giornale)
    {
      last_num = mov.get_long(MOV_NUMGIO);
      if (last_num > 0) last_num--;
      CHECK(last_num >= 0, "Ultimo numero stampato impossibile"); 
    }
    for (; ok && cursor.pos() < cursor.items(); ++cursor)
    {
      p.addstatus(1);
      mov.read(_isequal, _lock);
      mov.zero(fieldname);     // Azzera flag STAMPATO o REGST
      ok = (mov.rewrite() == NOERR);
      if (!ok)
        error_box("Errore nell'aggiornamento del movimento %ld.\n Errore n. %d",
                  mov.get_long(MOV_NUMREG), mov.status());
    }
    
    --d;
    if (d > inizio_anno)      // Aggiorna data ultima stampa
      reg.put("D3", d);
    else
      reg.zero("D3");
    
    if (giornale)
      reg.put("I6", last_num); // Aggiorna ultima pagina giornale
    ok = (reg.rewrite() == NOERR);
    if (!ok)
      error_box("Errore nell'aggiornamento del registro %s.\n Errore n. %d",
                (const char * ) regist, mov.status());
    
  }
  else
    ok = error_box("Impossibile leggere il registro %s anno %s", (const char *) regist, (const char *) year);

  set_firm(_default_firm);
  return ok;
}

bool TRipristina_stampa::create()
{
  TApplication::create();
  _msk = new TMask("cg5400a") ;
  _msk->set_handler(F_FIRM, firm_handler);
  _default_firm = get_firm();
  dispatch_e_menu(BAR_ITEM(1));
  return TRUE;
}

bool TRipristina_stampa::destroy()
{
  if (_msk != NULL) delete  _msk;
  return TApplication::destroy();
}

bool TRipristina_stampa::menu(MENU_TAG)
{
  while (_msk->run() == K_ENTER)
  {
    const long firm = _msk->get_long(F_FIRM);
    const TString16 reg  = _msk->get(F_REG);
    const bool giornale = _msk->get_int(F_TIPO) == 5;
    const int year = _msk->get_int(giornale ? F_ESER : F_YEAR);
    const int month = _msk->get_int(F_MESE);
    int day = giornale ? _msk->get_int(F_DAY) : 1;
    if (day < 1) day = 1; 
    
    if (prefhndl->exist(firm))
    {
      TString256 mess("Attenzione sara' ripristinata la stampa del registro ");
      mess << reg << "\ndell'" << (giornale ? "esercizio " : "anno ") << year 
        << " della ditta " << firm << " dal " << day << '-' << month << '-' << year;

      if (yesno_box((const char *) mess))
      {
        mess << "\nSi desidera veramente continuare";
        if (yesno_box((const char *) mess))
          do_restore(firm, reg, year, month, day, giornale);
      }
    }
    else error_box("Gli archivi della ditta %d non sono stati ancora generati",firm);
    _msk->reset();
  }
  return FALSE;
}

int cg5400(int argc, char* argv[])
{
  TRipristina_stampa a ;
  a.run(argc, argv, "Ripristino stampa registri");
  return 0;
}