// Apertura nuovo esercizio/nuovo esercizio IVA

#include <relation.h>
#include <tabutil.h>
#include <printapp.h>
#include <mask.h>
#include <utility.h>
#include <config.h>
#include <urldefid.h>

#include <mov.h>
#include <rmov.h>
#include <rmoviva.h>
#include <saldi.h>
#include <causali.h>
#include <nditte.h>

#include "cg4500a.h"
#include "cg4500b.h"

bool mask_dataini   (TMask_field&, KEY);
bool mask_newanno   (TMask_field&, KEY);
bool mask_annoiva   (TMask_field&, KEY);
bool mask_frequenza (TMask_field&, KEY);

class CG4500_application : public TApplication
{
  friend bool mask_dataini   (TMask_field&, KEY);
  friend bool mask_newanno   (TMask_field&, KEY);
  friend bool mask_annoiva   (TMask_field&, KEY);
  friend bool mask_frequenza (TMask_field&);
  
  TTable* _esc, * _reg, * _lia, * _lbu;
  TLocalisamfile* _nditte;
  int     _anno, _newanno, _annoiva;
  TDate   _dataini, _datafin, _datainp, _datafip;
  TString _annop;
  long    _ditta;
  char    _frequenza;

public:
  virtual bool create();
  virtual bool destroy();
  virtual bool menu(MENU_TAG m);

  void  create_files();
  void  destroy_files();
  bool  set();
  bool  setta();
  bool  apertura_es();
  bool  apertura_iva();
  
  CG4500_application() {}
};

TDate InizioEsercizio(int anno)
{
  TTable TabEs ("ESC");
  TString codtab;
  TDate inizio_es;

  TabEs.zero();
  codtab.format ("%04d", anno);
  TabEs.put ("CODTAB", codtab);
  TabEs.read();
  if (TabEs.good())
    inizio_es= TabEs.get_date ("D0");

  return inizio_es;
}

TDate FineEsercizio(int anno)
{
  TTable TabEs ("ESC");
  TString codtab;
  TDate fine_es;

  TabEs.zero();
  codtab.format ("%04d", anno);
  TabEs.put ("CODTAB", codtab);
  TabEs.read();
  if (TabEs.good())
    fine_es= TabEs.get_date ("D1");

  return fine_es;
}

bool mask_newanno (TMask_field& f, KEY k)
{ 
  TTable TabEs ("ESC");
  TString codtab; 

  //  if ( (k == K_TAB) && f.mask().is_running() )
  if ( (k == K_ENTER) && f.to_check(k) )
  {
    int newanno = f.mask().get_int(F_NUOVOANNO);
    int anno    = f.mask().get_int(F_ANNO);
    TabEs.zero();
    codtab.format ("%04d", newanno);
    TabEs.put ("CODTAB", codtab);
    TabEs.read();
    if ( TabEs.good() )
    {
      f.warning_box ("L'anno inserito e' gia' presente nella tabella degli esercizi!");
      return FALSE;
    }
    
    if (newanno != anno + 1)
    {
      f.warning_box ("L'anno del nuovo esercizio deve essere successivo all'anno esercizio precedente");
      return FALSE;
    }  
  }
  return TRUE;
}

bool mask_annoiva (TMask_field& f, KEY k)
{
  if ( (k == K_ENTER) && f.to_check(k) )
    //if ( (k == K_TAB) && f.mask().is_running() )
  {
    int annoiva = f.mask().get_int(F_ANNOIVA);
    TConfig conf(CONFIG_DITTA);
    int annoivap = atoi(conf.get("AnLiIv"));
    if (annoiva != annoivap + 1)
    {
      f.warning_box("Il nuovo anno esercizio IVA deve essere successivo all'anno esercizio IVA precedente");
      return FALSE;
    }    
  }
  return TRUE;
}  

bool mask_dataini (TMask_field& f, KEY k)
{
  if ( (k == K_ENTER) && f.to_check(k) )
  {
    TDate data(f.mask().get(F_DATAINI));
    TDate fine(f.mask().get(F_DATAFINC)); 
    /*
       if ( data.year() != FineEsercizio(anno).year() + 1 )
       {
       warning_box ("L'anno del nuovo esercizio deve essere successivo a quello della fine dell'esercizio precedente");
       return FALSE; 
       }
       */
    if ( data <= fine )
    {
      f.warning_box ("La data di inizio del nuovo esercizio deve essere superiore alla data di fine esercizio precedente");
      return FALSE;
    }
  }
  return TRUE;
}

void CG4500_application::create_files()
{
  _nditte = new TLocalisamfile(LF_NDITTE);
  _esc    = new TTable("ESC");
  _reg    = new TTable("REG");
  _lia    = new TTable("LIA"); 
  _lbu    = new TTable("%LBU");
}

void CG4500_application::destroy_files()
{
  delete _nditte;
  delete _esc;
  delete _reg;
  delete _lia;
  delete _lbu;
}

bool CG4500_application::create()
{
  TApplication::create();
  create_files();
  dispatch_e_menu (BAR_ITEM(1));
  
  return TRUE;
}

bool CG4500_application::destroy()
{
  destroy_files();
  
  return TApplication::destroy();
}

bool CG4500_application::set()
{
  TTable TabEs ("ESC");
  TMask m ("cg4500a");

  KEY tasto;
  
  /*
     if (TabEs.last() == NOERR) 
     { 
     int anno     = TabEs.get_int ("CODTAB"); 
     TDate inizio = TabEs.get_date("D0"); //data inizio es. in corso  
     TDate fine   = TabEs.get_date("D1"); //data fine es. in corso
     
     m.show (F_ANNO);
     m.show (F_DATAINIC);
     m.show (F_DATAFINC);  
     
     m.set(F_ANNO, (long) anno);
     m.set(F_DATAINIC, inizio.string());
     m.set(F_DATAFINC, fine.string());
     }
     else
     {
     m.hide(F_ANNO);
     m.hide(F_DATAINIC);
     m.hide(F_DATAFINC);
     }  
     */

  if (TabEs.last() != NOERR)
  {
    error_box("Non e' ancora stato aperto alcun esercizio!");
    return FALSE;
  }

  int anno     = TabEs.get_int ("CODTAB");
  TDate inizio = TabEs.get_date("D0"); //data inizio es. in corso  
  TDate fine   = TabEs.get_date("D1"); //data fine es. in corso

  m.set(F_ANNO, anno);
  m.set(F_DATAINIC, inizio.string());
  m.set(F_DATAFINC, fine.string());
  m.set(F_NUOVOANNO, anno+1);
  
  m.set_handler (F_NUOVOANNO, mask_newanno);
  m.set_handler (F_DATAINI,   mask_dataini);
  
  tasto = m.run();

  if (tasto == K_ENTER)
  {
    _anno    = m.get_int(F_ANNO);
    _datainp = m.get(F_DATAINIC);
    _datafip = m.get(F_DATAFINC);      
    _newanno = m.get_int(F_NUOVOANNO);   //nuovo anno esercizio
    _dataini = m.get(F_DATAINI);
    _datafin = m.get(F_DATAFIN);
    
    return TRUE;
  }
  return FALSE;
}

bool CG4500_application::setta()
{
  TTable TabLia ("LIA");
  TLocalisamfile nditte (LF_NDITTE);
  TMask m ("cg4500b");
  KEY tasto;

  TConfig conf(CONFIG_DITTA);
  _annop    = conf.get("AnLiIv");
  int aivap = atoi(conf.get("AnLiIv"));
  TString anno ( format("%04d", aivap+1) ); 
  
  TabLia.zero();
  TabLia.put("CODTAB", anno);
  if (TabLia.read() == NOERR)
    m.set(F_FREQUENZA, TabLia.get("S7"));
  else
  {  
    TabLia.zero();
    TabLia.put("CODTAB", _annop);
    if (TabLia.read() == NOERR)
      m.set(F_FREQUENZA, TabLia.get("S7"));
    else
    {      
      nditte.zero();
      nditte.put("CODDITTA", MainApp()->get_firm());
      if (nditte.read() == NOERR)
        m.set(F_FREQUENZA, nditte.get(NDT_FREQVIVA));
    }
  }
  
  m.set(F_ANNOIVA, aivap+1);  

  m.set_handler (F_ANNOIVA, mask_annoiva);

  tasto = m.run();

  if (tasto == K_ENTER)
  {
    _ditta     = m.get_long(F_CODDITTA); 
    _annoiva   = m.get_int(F_ANNOIVA);   
    _frequenza = m.get(F_FREQUENZA)[0];

    return TRUE;
  }
  return FALSE;
}

bool CG4500_application::menu(MENU_TAG m)
{
  switch (m)
  {
  case BAR_ITEM(1):
    apertura_es();
    break;
  case BAR_ITEM(2):
    apertura_iva();
    break;
  }
  //return TApplication::menu(m);
  return TRUE;
}

bool CG4500_application::apertura_es()
{
  TTable   TabReg ("REG");
  TTable   TabEs  ("ESC"); 
  TString  anno   (4);
  TString  annonew(4);
  TDate    data;
  bool ok = FALSE; 

  if (!set())
    return FALSE;

  //viene aggiornata la tabella dei registri. Se esisteva gia' un record relativo al nuovo esercizio, viene cancellato.
  //In ogni caso ne viene creato uno nuovo relativo al nuovo esercizio.

  TabReg.zero();
  annonew = format ("%04d", _newanno);
  TabReg.put ("CODTAB", annonew);
  
  TRectype r (TabReg.curr());
  
  TabReg.read(_isgteq);
  
  for (; !TabReg.eof(); TabReg.next())
  {
    if (TabReg.curr() != r) break;
    
    int tiporeg = TabReg.get_int("I0");
    if (tiporeg == 5)
      TabReg.remove();
  }

  TabReg.zero();
  TRectype nuovo (TabReg.curr());
  anno = format ("%04d", _anno);
  TabReg.put ("CODTAB", anno);
  
  TRectype rec (TabReg.curr());
  
  TabReg.read(_isgteq);
  
  for (; !TabReg.eof(); TabReg.next())
  { 
    if (TabReg.curr() != rec) break;
    
    int tiporeg = TabReg.get_int("I0");
    TString cod_reg = TabReg.get("CODTAB");
    cod_reg = cod_reg.mid(4,3);
    if (tiporeg == 5)
    {
      ok = TRUE;
      nuovo  = TabReg.curr();
      TString16 cod;
      cod << _newanno << cod_reg;
      nuovo.put("CODTAB", cod);
      nuovo.put("D2", data);
      nuovo.put("D3", data);
      nuovo.put("I6", 0L);
      nuovo.put("R1", real(0.0));
      nuovo.put("R2", real(0.0));
      
      TabReg.write(nuovo);
    }   
  }
  if (!ok)
  {
    error_box("Non esiste il registro libro giornale relativo all'es. precedente");
    return FALSE;
  }

  //viene aggiornata la tabella degli esercizi  
  TabEs.zero();
  annonew = format ("%04d", _newanno);
  TabEs.put ("CODTAB", annonew);
  TabEs.put ("D0", _dataini);
  TabEs.put ("D1", _datafin);
  TabEs.write();  
  
  message_box("Apertura nuovo esercizio completata");
  return TRUE;
}

bool CG4500_application::apertura_iva()
{
  TTable TabReg ("REG"); 
  TTable TabLia ("LIA");
  TTable TabLbu ("%LBU");
  TLocalisamfile nditte (LF_NDITTE);
  TDate data;
  TString annoiva (4); 
  bool ok = FALSE;

  if (!setta())
    return FALSE;

  //viene aggiornata la tabella del libro unico. Se esisteva gia' un record relativo al nuovo esercizio IVA, viene cancellato.
  //In ogni caso ne viene creato uno nuovo relativo al nuovo esercizio.

  annoiva = format ("%04d", _annoiva);

  TabLbu.zero();
  TabLbu.put ("CODTAB", annoiva);
  
  TRectype r (TabLbu.curr());
  
  TabLbu.read(_isgteq);
  
  for (; !TabLbu.eof(); TabLbu.next())
  {
    if (TabLbu.curr() != r) break;
    
    TabLbu.remove();
  } 

  TabLbu.zero();
  TRectype nrec (TabLbu.curr());   
  TabLbu.put ("CODTAB", _annop);
  
  TRectype rec (TabLbu.curr());
  
  TabLbu.read(_isgteq);
  
  for (; !TabLbu.eof(); TabLbu.next())
  { 
    if (TabLbu.curr() != rec) break;
    
    TString cod_lib = TabLbu.get("CODTAB");
    cod_lib = cod_lib.mid(4,3);
    
    ok = TRUE;
    nrec = TabLbu.curr();
    TString16 cod;
    cod << _annoiva << cod_lib; 
    nrec.put("CODTAB", cod);
    nrec.put("I0", 0L);
    
    TabLbu.write(nrec);
  }   
  if (!ok)
  {
    error_box("Non esistono i registri del libro unico relativi all'anno iva precedente");
    return FALSE;
  }
  
  //viene aggiornata la tabella dei registri. Se esisteva gia' un record relativo al nuovo esercizio, viene cancellato.
  //In ogni caso ne viene creato uno nuovo relativo al nuovo esercizio.

  TabReg.zero();
  TabReg.put ("CODTAB", annoiva);
  
  TRectype rr (TabReg.curr());
  
  TabReg.read(_isgteq);
  
  for (; !TabReg.eof(); TabReg.next())
  {
    if (TabReg.curr() != rr) break;
    
    int tiporeg = TabReg.get_int("I0");
    if ( (tiporeg == 1)||(tiporeg == 2)||(tiporeg == 3) )
      TabReg.remove();
  }
  
  ok = FALSE;
  TabReg.zero();
  TRectype nuovo (TabReg.curr());   
  TabReg.put ("CODTAB", _annop);
  
  TRectype recc (TabReg.curr());
  
  TabReg.read(_isgteq);
  
  for (; !TabReg.eof(); TabReg.next())
  { 
    if (TabReg.curr() != recc) break;
    
    int tiporeg     = TabReg.get_int("I0");
    TString cod_reg = TabReg.get("CODTAB");
    TDate  data_vid = TabReg.get_date("D0");
    data_vid.addyear();
    cod_reg = cod_reg.mid(4,3);
    if ( (tiporeg == 1)||(tiporeg == 2)||(tiporeg==3) )
    {
      ok = TRUE;
      nuovo  = TabReg.curr();
      TString16 cod;
      cod << _annoiva << cod_reg;  
      nuovo.put("CODTAB", cod);
      nuovo.put("I1", 0L);
      nuovo.put("I2", 0L);
      nuovo.put("I4", 0L);
      nuovo.put("I5", 0L);
      nuovo.put("I6", 0L);
      nuovo.put("S1", "");
      nuovo.put("D0", data_vid);
      nuovo.put("D2", data);
      nuovo.put("D3", data);
      nuovo.put("R1", real(0.0));
      nuovo.put("R2", real(0.0));
      
      TabReg.write(nuovo);
    }   
  }
  if (!ok)
  {
    error_box("Non esistono i registri iva relativi all'anno iva precedente");
    return FALSE;
  }  

  //viene aggiornata la tabella LIA (liquidazione iva annuale)
  TabLia.zero();
  TabLia.put ("CODTAB", annoiva);
  if (TabLia.read() == NOERR)
    TabLia.remove();
  
  ok = FALSE; 
  TabLia.zero();
  TRectype newrec (TabLia.curr());   
  TabLia.put ("CODTAB", _annop);
  
  if (TabLia.read() == NOERR)
  {
    ok = TRUE;
    newrec = TabLia.curr();
    newrec.put("CODTAB", annoiva);
    newrec.put("S7", _frequenza);
    
    TabLia.write(newrec);
  }   
  if (!ok)
  {
    error_box("Non esiste il record relativo all'anno iva precedente sulla tabella liquidazione annuale iva");
    return FALSE;
  }  

  //viene aggiornato l'anno iva sui parametri ditta 
  TConfig conf(CONFIG_DITTA);
  conf.set("AnLiIv", _annoiva);

  //sull'anagrafica ditte viene aggiornata la frequenza versamento
  nditte.zero();
  nditte.put("CODDITTA", _ditta);
  if (nditte.read() == NOERR)
  {
    nditte.put(NDT_FREQVIVA, _frequenza);
    nditte.rewrite();
  }
  
  message_box("Apertura nuovo esercizio IVA completata");
  return TRUE;
}

int cg4500 (int argc, char* argv[])
{
  CG4500_application main_app;
  main_app.run(argc, argv, "");
  return TRUE;
}

