// cg4400.cpp
// Stampa tabella registri
#include "cg4.h"
#include "cg4400.h"
#include "cg4400a.h"

TFixed_string   TMP (__tmp, MAXSTR);

HIDDEN CG4400_application * app() { return (CG4400_application*) MainApp(); }

bool filter_func (const TRelation * r)
{
  TLocalisamfile * mov = r->lfile(LF_MOV);
  TString codreg = mov->get(MOV_REG);
  long    annoes = mov->get_long(MOV_ANNOES);
  
  if (codreg != app()->_codreg || annoes != app()->_annoes) 
    return FALSE;           
  
  if (app()->_stampa_tutti_i_registri)
    if ( (app()->_tipo_reg != 1) && (app()->_tipo_reg != 2) )  
      return FALSE;        

  return TRUE;
}

HIDDEN int compare_rows(const TObject** o1, const TObject** o2)
{
  TRiga* r1 = (TRiga*)*o1;
  TRiga* r2 = (TRiga*)*o2;
  
  return (strcmp((const char*)r1->_codiva, (const char*)r2->_codiva));
}

HIDDEN int compare(const TObject** o1, const TObject** o2)
{
  TRigaiva* r1 = (TRigaiva*)*o1;
  TRigaiva* r2 = (TRigaiva*)*o2;
  TString16 campo1; campo1.format("%d%4s", r1->_tipodet, (const char*)r1->_codiva); 
  TString16 campo2; campo2.format("%d%4s", r2->_tipodet, (const char*)r2->_codiva); 
  return (strcmp(campo1, campo2));
}

/*
   bool CG4400_application::libro_giornale_iva_unico()
   {
   TConfig conf(CONFIG_DITTA);

   return conf.get("StLgiU") == "X";
   }
   */

bool mask_select (TMask_field& f, KEY k)
{
  long j, cnt, chk; int i;
  TString from = f.mask().get(DA_CODICE);
  TString to   = f.mask().get(A_CODICE);
  TBit_array selected = app()->_selected;
  
  // build sheet
  if (k == K_SPACE)
  { 
    app()->_ditte->destroy(); chk = 0l;
    for (i = 0; i < app()->_nomiditte.items(); i++)
    {
      if (app()->_selected[i]) continue;
      TToken_string d = (const char*)((TToken_string&)app()->_nomiditte[i]);
      TString cod     = d.get(0);
      app()->_ditte->add(d);
      
      if (!from.empty() || !to.empty())
      {
        if (from.empty()) from = "0";
        if (to.empty()) to = "999999999";
        if (atol(cod) >= atol(from) && atol(cod) <= atol(to))
          app()->_ditte->check(chk++);
      }
    }
    // seleziona e aggiungi alle gia' selezionate 
    if (app()->_ditte->run() == K_ENTER)
    {
      cnt = 0;
      for (j = 0l; j < app()->_n_ditte; j++)
      {
        if (app()->_selected[j]) continue;
        if (app()->_ditte->checked(cnt++))
          selected.set(j);
      }
      app()->_selected |= selected;
      selected.reset();
    }
    long numd = app()->_selected.ones();
    f.mask().set(F_SELECT,numd);
  }
  return TRUE;
}       

bool mask_verifica (TMask_field& f, KEY k)
{
  int i;

  if (k == K_SPACE)
  {
    app()->_ditte->destroy();
    for (i = 0; i < app()->_nomiditte.items(); i++)
    {
      TToken_string d = (const char*)((TToken_string&)app()->_nomiditte[i]);
      app()->_ditte->add(d);
      if (app()->_selected[i]) app()->_ditte->check(i);
    }
    app()->_ditte->disable_check();
    app()->_ditte->run();
    app()->_ditte->enable_check(); 
  }
  return TRUE;
}

bool mask_annulla (TMask_field& f, KEY k)
{
  if (k == K_SPACE)
  {
    app()->_selected.reset();
    f.mask().set(F_SELECT, "0");
  }
  return TRUE;
}

bool mask_mese (TMask_field& f, KEY k)
{
  if (k == K_ENTER) 
  {
    int mese  = f.mask().get_int(MESE);
    int umese = f.mask().get_int(ULTIMO_MESE);

    if (mese != umese+1)
    { 
      f.warning_box ("Le stampe devono essere richieste mese per mese! I mesi successivi a %s non sono ancora stati stampati.", itom(umese));    
      return FALSE;
    }
  }
  return TRUE;
}

bool mask_cod (TMask_field& f, KEY k)
{ 
  TTable TabLbu ("%LBU");
  TString codtab; 
  int anno;
  
  if ( (k == K_TAB) && f.mask().is_running() )  
  {
    TString codlib = f.mask().get(CODICE_LIB_UN);
    anno = f.mask().get_int(ANNO);
    
    TabLbu.zero();
    codtab.format ("%04d%-3s", anno, (const char*)codlib);
    TabLbu.put ("CODTAB", codtab);
    TabLbu.read();
    if ( TabLbu.good() )
    {
      f.mask().set(MESE,TabLbu.get_long("I0")+1);
      f.mask().set(ULTIMO_MESE,TabLbu.get_long("I0"));
      f.mask().set(ULTIMA_PAGINA,TabLbu.get("I1"));
    }
  }
  return TRUE;
}

bool mask_fino_a_mese (TMask_field& f, KEY k)
{ 
  if ( (k == K_TAB) && f.mask().is_running() )  
  {
    TTable TabReg ("REG");
    TString16 codtab;
    int giorni_del_mese;
    TString codreg = f.mask().get(CODICE_LIBRO);
    int tipo       = f.mask().get_int(TIPO_STAMPA);
    int anno       = f.mask().get_int(ANNO);
    
    if ( (tipo == 1) || (tipo == 4) ) 
    { 
      int fino_a_mese = f.mask().get_int(FINO_A_MESE);
      if (fino_a_mese == 12)
        giorni_del_mese = 31;
      else
      {
        TDate primo = format("01/%02d/%4d", fino_a_mese+1, anno);
        --primo;
        giorni_del_mese = primo.day();
      }
      TDate datasup = format("%02d/%02d/%4d",giorni_del_mese,fino_a_mese,anno);      if (codreg != "") 
      {
        TabReg.zero();
        codtab << anno << codreg;
        TabReg.put ("CODTAB", codtab);
        TabReg.read();
        if ( TabReg.good() )
        {
          TDate data = TabReg.get_date("D3");
          if (datasup < data)
          {
            TString16 datas = format("02d/%4d", data.month(), data.year());
            f.warning_box ("La data specificata non deve essere inferiore al %s (ultima data di stampa specificata sul registro)", (const char*)datas);    
            return FALSE;
          }
        }
      }
      if (tipo == 4)
      {
        TabReg.zero();
        TabReg.put ("CODTAB", anno);
        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) //libro giornale
          {    
            TDate data = TabReg.get_date("D3");
            if (datasup > data)
            {
              TString16 datas = format("02d/%4d", data.month(), data.year());
              f.warning_box ("La data specificata non deve essere superiore al %s (ultima data di stampa del libro giornale)", (const char*)datas);    
              return FALSE;
            }
          }
        }
      } 
    }
  }
  return TRUE;
}

//da una SHEET non e' possibile mandare messaggi nella maschera!!!
HIDDEN bool my_handler (TMask_field& f, KEY k)
{
  if (k == K_TAB) 
  {
    TMask& m = f.mask();
    int stampa_su   = m.get_int(TIPO_STAMPA);
    if ( (stampa_su == 1) || (stampa_su == 4) ) 
    {  
      m.hide (CODICE_LIB_UN);
      m.hide (CODICE_LIBRO_PROVA);
      m.hide (MESE);
      m.hide (ULTIMO_MESE);
      m.hide (ULTIMA_PAGINA);
      m.hide (CODICE_LIBRO_IVA);
      m.hide (DATA_STAMPA);
      m.hide (DA_DATA);
      m.hide (A_DATA);
      m.show (CODICE_LIBRO);
      m.show (TIPO_RIEPILOGATIVO);
      m.show (FINO_A_MESE);
    }
    if (stampa_su == 2)
    {
      m.show (CODICE_LIB_UN);
      m.hide (CODICE_LIBRO_PROVA);
      m.show (MESE);
      m.show (ULTIMO_MESE);
      m.show (ULTIMA_PAGINA);
      m.show (CODICE_LIBRO_IVA);
      m.hide (DATA_STAMPA);
      m.hide (DA_DATA);
      m.hide (A_DATA);
      m.hide (CODICE_LIBRO);
      m.hide (TIPO_RIEPILOGATIVO);
      m.hide (FINO_A_MESE);       
    } 
    if (stampa_su == 3)
    {
      m.hide (CODICE_LIB_UN);
      m.hide (MESE);
      m.hide (ULTIMO_MESE);
      m.hide (ULTIMA_PAGINA);
      m.hide (CODICE_LIBRO_IVA);
      m.hide (CODICE_LIBRO);
      m.show (CODICE_LIBRO_PROVA);
      m.show (DATA_STAMPA);
      m.show (DA_DATA);
      m.show (A_DATA);
      m.hide (TIPO_RIEPILOGATIVO);
      m.hide (FINO_A_MESE);       
    } 
  }
  return TRUE;
} 

const char * CG4400_application::descr_doc(const char * tipo)
{
  TTable  tab_tpd("%TPD");
  TString codtab = format ("%-2s", tipo);
  
  tab_tpd.zero();
  
  tab_tpd.put("CODTAB", codtab);
  if (tab_tpd.read()==NOERR)
    TMP = tab_tpd.get("S0");
  else
    TMP = "";

  return __tmp;
} 

const char * CG4400_application::descr_iva(const char * cod)
{
  TTable  tab_iva("%IVA");
  TString codtab = format ("%-4s", cod);
  
  tab_iva.zero();
  
  tab_iva.put("CODTAB", codtab);
  if (tab_iva.read()==NOERR)
    TMP = tab_iva.get("S0");
  else
    TMP = "";

  return __tmp;
} 

const char * CG4400_application::desc_attivita(const char * codatt)
{
  TTable attiv ("%AIS");

  attiv.zero();
  attiv.put("CODTAB", codatt);
  if (attiv.read()==NOERR)
    TMP = attiv.get("S0");
  else
    TMP = "";
  return __tmp;
}

const char * CG4400_application::ricerca_cf(char tipocf, long codcf)
{
  _clifo->zero();
  _clifo->put(CLI_TIPOCF, tipocf);
  _clifo->put(CLI_CODCF, codcf);
  if (_clifo->read() == NOERR)
    TMP = _clifo->get(CLI_RAGSOC);
  else
    TMP = "";
  return __tmp;
}

const char * CG4400_application::ricerca_occ(const char * occ)
{
  TLocalisamfile occas (LF_OCCAS);

  occas.zero();
  occas.put(OCC_CFPI, occ);
  
  if (occas.read() == NOERR)
    TMP = occas.get(OCC_RAGSOC);
  else
    TMP = "";
  return __tmp;
}

void CG4400_application::user_create()
{
  _nditte   = new TLocalisamfile(LF_NDITTE);
  _ditte    = new TArray_sheet(-1, -1, 0, 0, "Selezione Ditte",
                               "@1|Cod.@5|Ragione Sociale@50");
  _n_ditte = 0l;
  for (_nditte->first(); !_nditte->eof(); _nditte->next())
  {
    TString cod  = _nditte->get("CODDITTA");
    _n_ditte++;
    TToken_string* d = new TToken_string(" ");
    d->add(cod);
    d->add(_nditte->get("RAGSOC"));
    _nomiditte.add(d);
  }
  _tab    = new TLocalisamfile(LF_TAB);
  _tabcom = new TLocalisamfile(LF_TABCOM);
  _tabreg = new TTable("REG");
  _clifo  = new TLocalisamfile(LF_CLIFO);
  _occas  = new TLocalisamfile(LF_OCCAS);
  _rel    = new TRelation (LF_MOV);
  _rel->add(LF_CAUSALI,"CODCAUS=CODCAUS",1,LF_MOV);
  _rel->add(LF_RMOVIVA,"NUMREG=NUMREG",1,LF_MOV);
  _cur = new TCursor(_rel, "", 1);
  _cur->set_filterfunction(filter_func);

  add_cursor(_cur);
  add_file(LF_MOV);
  add_file(LF_RMOVIVA);
}

void CG4400_application::user_destroy()
{
  delete _ditte;
  delete _nditte;
  delete _tab;
  delete _tabcom;
  delete _cur;
  delete _rel;
  delete _clifo;
}


void CG4400_application::calcola_progressivi(real& r0, real& r1, const char* codiva, const int tipocr) 
{
  TTable  pim ("PIM");  
  TString chiave;
  int i, num=0;
  
  if (_tipo_stampa == 1)
    num = _datareg.month();
  if ( (_tipo_stampa == 2) || (_tipo_stampa == 4) )  
    num = _fino_a_mese;
  
  if (_frequiva == 'T')
    for (i=3; i<num+3; i+=3)
    {
      chiave = "";
      chiave << _annoes << _codatt << _codreg << i << tipocr << codiva;
      pim.put("CODTAB", chiave);
      if (pim.read()==NOERR)
      {
        r0 += pim.get_real("R0");
        r1 += pim.get_real("R1");
      }
    }
  else //frequenza mensile
    for (i=1; i<=num; i++)
    {
      chiave = "";
      chiave << _annoes << _codatt << _codreg << i << tipocr <<codiva;
      pim.put("CODTAB", chiave);
      if (pim.read()==NOERR)
      {
        r0 += pim.get_real("R0");
        r1 += pim.get_real("R1");
      }
    }       
}

int CG4400_application::riga_rmoviva()
{ 
  TString  codiva;
  real     impo, impos, impop, imposp;
  int      tipodet, tipocr;    

  _cur->save_status();
  bool ok = _cur->is_first_match(LF_RMOVIVA);
  int nrec = 0;
  
  while (ok)
  {
    nrec++;
    TRectype iva (_cur->file(LF_RMOVIVA)->curr());
    tipodet = iva.get_int (RMI_TIPODET);
    tipocr  = iva.get_int (RMI_TIPOCR); 
    impo    = iva.get_real(RMI_IMPONIBILE);
    impos   = iva.get_real(RMI_IMPOSTA);
    codiva  = iva.get(RMI_CODIVA);
    
    impop = imposp = 0.00;
    _riga_rmi.add_riga(impo,impos,codiva,tipodet,impop,imposp);
    
    if (_tipo_reg == 2) //registro acquisti
    {
      if (_tipo_stampa != 3)  //stampa definitiva
        calcola_progressivi(impop,imposp,codiva,tipocr);
      _iva_array.add_riga(impo,impos,codiva,tipodet,impop,imposp);
    }
    
    impop = imposp = 0.00;
    if (_tipo_stampa != 3)
      calcola_progressivi(impop,imposp,codiva,tipocr); 
    
    _tot_iva_array.add_riga(impo,impos,codiva,impop,imposp);
    
    ok = _cur->next_match(LF_RMOVIVA);
  }
  _cur->restore_status();
  
  return nrec;   
}

int CG4400_application::setta_riga(int r, const TRigaiva& riga, real& tot1, 
                                   real& tot2, real& tot3, real& tot4)
{
  set_row(r, "%3s", (const char*)riga._codiva);
  TString descr = descr_iva(riga._codiva); 
  set_row(r, "@5g%s",(const char*)descr); 
  set_row(r, "@25g%r", &riga._imponibile);
  set_row(r, "@41g%r", &riga._imposta);
  if (_tipo_stampa != 3)
  {
    set_row(r, "@81g%r", &riga._imponibilep);
    set_row(r++, "@98g%r", &riga._impostap); 
  }
  else r++;
  tot1 += riga._imponibile;
  tot2 += riga._imposta;
  tot3 += riga._imponibilep;
  tot4 += riga._impostap;
  
  return r;
}

bool CG4400_application::controlla_liquidazione()
{
  TTable lim ("LIM");
  TTable pim ("PIM");
  TString mesi_ric, mesi_cal;
  TString chiave;
  int i;
  
  if (lim.empty()) 
    return yesno_box("Non esiste la tabella liquidazione iva mensile! Vuoi ugualmente continuare la stampa?");
  if (pim.empty())
    return yesno_box("Non esiste la tabella progressivi iva mensile! Vuoi ugualmente continuare la stampa?");

  if (_frequiva == 'T') //nella tabella LIM ho solo i mesi 3, 6, 9, 12
  {
    for (i=3; i<=_fino_a_mese+3; i+=3)
    {
      chiave = "";
      chiave << _annoes << i;
      lim.put("CODTAB", chiave);
      if (lim.read() == NOERR)
      {
        bool calcolato = lim.get_bool("B0"); 
        if (!calcolato)
          
          // return yesno_box("La liquidazione relativa al mese di %s deve essere ricalcolata. Vuoi ugualmente continuare la stampa?", itom(i) );         
          mesi_ric << itom(i) << "\n\r";
      }
      else 
        //  return yesno_box("La liquidazione relativa al mese di %s non e' stata calcolata. Vuoi ugualmente continuare la stampa?", itom(i) );
        mesi_cal << itom(i) << "\n\r";  
    }
  }                
  if (_frequiva == 'M')
  {
    for (i=1; i<=_fino_a_mese; i++);
  {
    chiave = "";
    chiave << _annoes << i;
    lim.put("CODTAB", chiave);
    if (lim.read() == NOERR)
    {
      bool calcolato = lim.get_bool("B0"); 
      if (!calcolato)
        // return yesno_box("La liquidazione relativa al mese di %s deve essere ricalcolata. Vuoi ugualmente continuare la stampa?", itom(i) );
        mesi_ric << itom(i) << "\n\r";         
    }
    else 
      // return yesno_box("La liquidazione relativa al mese di %s non e' stata calcolata. Vuoi ugualmente continuare la stampa?", itom(i) );  
      mesi_cal << itom(i) << "\n\r";       
  } 
  }
  if (mesi_ric.not_empty())
  {
    warning_box ("Deve essere ricalcolata la liquidazione relativa ai mesi di:\n %s ", (const char *)mesi_ric);
    return yesno_box("Vuoi ugualmente continuare la stampa?");
  }

  if (mesi_cal.not_empty())
  {
    warning_box ("La liquidazione relativa al mese di %s non e' stata calcolata", (const char *)mesi_cal);
    return yesno_box("Vuoi ugualmente continuare la stampa?");
  }       
  return TRUE;   
}

/*controlla che i movimenti con data di registrazione compresa tra l'anno precednte e l'ultima data stampata siano tutti gia' stati stampati*/ 
bool CG4400_application::controlla_mov()
{
  TLocalisamfile mov (LF_MOV);
  bool stampato, ok = TRUE;
  long numreg; 
  TString codreg;
  
  mov.zero();
  TRectype a (mov.curr());
  TDate data = format("01/01/%4d", _annoes - 1);
  mov.put(MOV_DATAREG, data); 
  a.put  (MOV_DATAREG, _data_da);
  mov.read(_isgteq);
  while (mov.curr() < a && !mov.eof())
  {
    stampato = mov.get_bool(MOV_STAMPATO);
    numreg   = mov.get_long(MOV_NUMREG);
    if (!_stampa_tutti_i_registri)
      codreg = mov.get(MOV_REG);
    else codreg = "";
    if (codreg == _codreg)
      if (!stampato)
      {
        warning_box("Il movimento con numero di registrazione %ld non e' ancora stato stampato in forma definitiva!", numreg);
        ok = FALSE;
      }
    mov.next();
  }       
  return ok;
}

void CG4400_application::set_page_tot_reg()
{
  TString riga(_stampa_width);
  int r=1, rr=0, row=0;
  real tot_imponib, tot_imposta, tot_imponibp, tot_impostap;
  
  riga.fill('-');
  set_row(r, "%s", (const char *) riga);
  r++;
  set_row(r, "Legenda Tipo Operazione:  1=operazione intracomunitaria  2=AF art.34 comma 3");  
  set_row(r, "@78g3=operazione intracomunitaria e AF art.34 comma 3");
  r++;
  set_row(++r, "Tipo documento@30gTotale documento");
  r+=2; 
  for (int j = 0; j < _doc_array.items(); j++)
  {
    TTipodoc& doc = (TTipodoc&)_doc_array[j];
    rr = r+j;
    set_row(rr, "%2s",      (const char*) doc._tipodoc);
    set_row(rr, "@3g%.25s", (const char*) doc._descrdoc);
    set_row(rr, "@29g%r",   &doc._totdoc); 
  }
  _doc_array.destroy();
  
  rr++;
  set_row(++rr, "@26g---------- P E R I O D O ----------");
  if (_tipo_stampa != 3)
    set_row(rr,"@82g------ P R O G R E S S I V I ------");
  rr++;
  set_row(rr, "Cod.");
  if (_tipo_reg == 2)
  {
    set_row(rr, "@36gA C Q U I S T I");
    if (_tipo_stampa != 3)
      set_row(rr, "@92gA C Q U I S T I");
  }
  if (_tipo_reg == 1)
  {
    set_row(rr, "@37gV E N D I T E");
    if (_tipo_stampa != 3)
      set_row(rr, "@93gV E N D I T E");
  }      
  rr++;
  set_row(rr, "iva Descrizione@30gImponibile@49gImposta");
  if (_tipo_stampa != 3)
    set_row(rr++, "@86gImponibile@106gImposta");
  else rr++;
  rr++;

  tot_imponib = tot_imposta = tot_imponibp = tot_impostap = 0.00;

  _tot_iva_array.sort(compare_rows);

  for (int k = 0; k < _tot_iva_array.items(); k++)
  {
    TRiga& riga = (TRiga&)_tot_iva_array[k];
    row = rr+k;
    set_row(row, "%3s",    (const char*)riga._codiva);
    TString descr = descr_iva(riga._codiva); 
    set_row(row, "@5g%s",  (const char*)descr); 
    set_row(row, "@25g%r", &riga._imponibile);
    set_row(row, "@41g%r", &riga._imposta);
    if (_tipo_stampa != 3)
    {
      set_row(row, "@81g%r", &riga._imponibilep);
      set_row(row, "@98g%r", &riga._impostap); 
    }  
    tot_imponib  += riga._imponibile;
    tot_imposta  += riga._imposta;
    tot_imponibp += riga._imponibilep;
    tot_impostap += riga._impostap;
  }  
  _tot_iva_array.destroy();
  
  row++;
  set_row(++row, "TOTALE@25g%r@41g%r", &tot_imponib, &tot_imposta);
  if (_tipo_stampa != 3)
    set_row(row, "@81g%r@98g%r", &tot_imponibp, &tot_impostap);
  //la stampa "tipi di indetraibilita'" viene fatta solo per gli acquisti 
  if (_tipo_reg == 2)
  {
    row+=2;
    int tdetprec = -1;
    int rw = row;
    tot_imponib = tot_imposta = tot_imponibp = tot_impostap = 0.00;
    
    _iva_array.sort(compare);

    for (int s = 0; s < _iva_array.items(); s++)
    {
      TRigaiva& riga = (TRigaiva&)_iva_array[s];
      switch (riga._tipodet)
      {
      case 1: if (riga._tipodet != tdetprec)
      {    
        set_row(rw++, "----- Indetraibile su op.es. -----");
        set_row(rw, "Cod.");
        rw++;
        set_row(rw, "iva Descrizione@30gImponibile@49gImposta");
        if (_tipo_stampa != 3)
          set_row(rw++, "@86gImponibile@106gImposta"); 
        else rw++;
        rw++;
      }
              rw = setta_riga(rw, riga, tot_imponib, tot_imposta, tot_imponibp, tot_impostap);
              tdetprec = riga._tipodet;
              break;
            case 3: if (tdetprec == 1)
            {
              set_row(++rw, "TOTALE@25g%r@41g%r", &tot_imponib, &tot_imposta);
              if (_tipo_stampa != 3)
                set_row(rw, "@81g%r@98g%r", &tot_imponibp, &tot_impostap);
              tot_imponib = tot_imposta = tot_imponibp = tot_impostap = 0.00;
              rw+=2;
            }
              if (riga._tipodet != tdetprec)
              { 
                set_row(rw++, "----- Passaggi interni -----");
                set_row(rw, "Cod.");
                rw++;
                set_row(rw, "iva Descrizione@30gImponibile@49gImposta");
                if (_tipo_stampa != 3)
                  set_row(rw++, "@86gImponibile@106gImposta");
                else rw++;    
                rw++;
              }
              rw = setta_riga(rw, riga, tot_imponib, tot_imposta, tot_imponibp, tot_impostap);
              tdetprec = riga._tipodet;
              break;
            case 9: if ( (tdetprec == 1) || (tdetprec == 3) )
            {
              set_row(++rw, "TOTALE@25g%r@41g%r", &tot_imponib, &tot_imposta);
              if (_tipo_stampa != 3)
                set_row(rw, "@81g%r@98g%r", &tot_imponibp, &tot_impostap); 
              tot_imponib = tot_imposta = tot_imponibp = tot_impostap = 0.00;
              rw+=2;
            }
              if (riga._tipodet != tdetprec)
              {  
                set_row(rw++, "----- N.D. 9 - acquisti indeducibili per ART.19 -----");
                set_row(rw, "Cod.");
                rw++;
                set_row(rw, "iva Descrizione@30gImponibile@49gImposta");
                if (_tipo_stampa != 3)
                  set_row(rw++, "@86gImponibile@106gImposta");
                else rw++; 
                rw++;
              }
              rw = setta_riga(rw, riga, tot_imponib, tot_imposta, tot_imponibp, tot_impostap);
              tdetprec = riga._tipodet; 
              break;
            default: break;                         
            }
    }
    if (tdetprec == 9)
    {
      set_row(++rw, "TOTALE@25g%r@41g%r", &tot_imponib, &tot_imposta);
      if (_tipo_stampa != 3)
        set_row(rw, "@81g%r@98g%r", &tot_imponibp, &tot_impostap);
    }
    _iva_array.destroy();
  } 
}

bool CG4400_application::preprocess_print(int file, int counter)
{ 
  if (file == LF_MOV)
  {       
    _iva_array.destroy();
    _riga_rmi.destroy();
    _tot_iva_array.destroy();
    _doc_array.destroy();
    _dataregp = "";
    _mov_empty = TRUE;   
    set_print_zero();
  }
  return TRUE;
} 

bool CG4400_application::compila_reg()
{       
  TTable tab_reg ("REG");
  
  tab_reg.zero();
  tab_reg.put("CODTAB", _codtab);
  
  if (tab_reg.read() == NOERR)
  {
    _tipo_reg        = tab_reg.get_int("I0");
    //  _pagine_stampate = tab_reg.get_int("I1");
    //  _pagine_numerate = tab_reg.get_int("I2");
    //_stampa_ok       = tab_reg.get_int("I7");
    //_nprog_da        = tab_reg.get_long ("I6");
    //_tot_dare        = tab_reg.get_real ("R1")
    //_tot_avere       = tab_reg.get_real ("R2");
    _data_da         = tab_reg.get_date ("D3"); 
    //_stampa_intesta  = tab_reg.get_bool ("B9");
    _codatt          = tab_reg.get("S8");
    _attivita        = desc_attivita(_codatt);
    _desc_lib        = tab_reg.get ("S0");
    
    return TRUE;
  }
  return FALSE;
}

bool CG4400_application::preprocess_page(int file, int counter)
{ 
  if (file == LF_MOV)
  {
    int rr = 0;
    TString ragsoc;
    TString tipo_op = ""; 
    TLocalisamfile* mov  = _cur->file(LF_MOV);
    TLocalisamfile* caus = _cur->file(LF_CAUSALI);

    _datareg = mov->get_date(MOV_DATAREG);
    
    if (_data_da.string() != "" && _data_a.string() != "")
      if ( (_datareg < _data_da || _datareg > _data_a) || (!_datareg.ok()) )
        return FALSE;           
    
    _mov_empty = FALSE;

    if ( (_tipo_stampa == 1) || (_tipo_stampa == 4) )
      if ( (_datareg.month() != _dataregp.month()) && (_dataregp.ok()) )
        printer().formfeed();
    
    _dataregp = _datareg;

    TDate   datadoc  = mov->get_date(MOV_DATADOC);
    long    numreg   = mov->get_long(MOV_NUMREG);
    long    protiva  = mov->get_long(MOV_PROTIVA);
    real    totdoc   = mov->get_real(MOV_TOTDOC);
    TString numdoc   = mov->get(MOV_NUMDOC);
    char    tipocf   = mov->get(MOV_TIPO)[0];
    TString ocfpi    = mov->get(MOV_OCFPI);
    long    codcf    = mov->get_long(MOV_CODCF);
    bool    stampato = mov->get_bool(MOV_STAMPATO);
    bool    intra    = caus->get_bool(CAU_INTRACOM);
    bool    autof    = caus->get_bool(CAU_AUTOFATT);
    TString descrcau = caus->get(CAU_DESCR);   
    
    if ( intra && autof)
      tipo_op = "3";
    else if (intra) 
      tipo_op = "1";
    else if (autof)
      tipo_op = "2";
    
    if ( (tipocf == 'C') || (tipocf == 'F') )
    {
      if (ocfpi.trim().empty())
        ragsoc = ricerca_cf(tipocf, codcf);
      else
        ragsoc = ricerca_occ(ocfpi);
    }
    else ragsoc = descrcau;
    
    _tipodoc   = mov->get(MOV_TIPODOC);
    _descr_doc = descr_doc(_tipodoc);
    TString app = datadoc.string(2, '/');
    
    _doc_array.add_riga(_tipodoc,_descr_doc,totdoc); 

    //setto le righe di stampa
    _r = 1;
    set_row(_r, "%s",       (const char*) _datareg.string(2, '/'));
    set_row(_r, "@9g%5d",   protiva);
    set_row(_r, "@15g%s",   (const char*) app);
    set_row(_r, "@24g%s",   (const char*) numdoc);
    set_row(_r, "@32g%6d",  codcf);
    set_row(_r, "@39g%.28s",(const char*) ragsoc);
    set_row(_r, "@68g%s",   (const char*) tipo_op);
    set_row(_r, "@70g%2s",  (const char*) _tipodoc);
    set_row(_r, "@72g%r",   &totdoc);
    
    int nrec = riga_rmoviva();
    if (nrec > 0)
    {
      for (int j = 0; j < _riga_rmi.items(); j++)
      {
        TRigaiva& riga = (TRigaiva&)_riga_rmi[j];
        rr = _r+j;
        set_row(rr, "@87g%r",   &riga._imponibile);
        set_row(rr, "@102g%4s",(const char*)riga._codiva);
        if (_tipo_reg == 2)
          set_row(rr, "@107g%d",  riga._tipodet);
        set_row(rr, "@108g%r",  &riga._imposta);
      } 
      _riga_rmi.destroy();
    }
    int tipocr = _cur->file(LF_RMOVIVA)->get_int(RMI_TIPOCR);
    set_row(_r, "@124g%d",  tipocr);
    if (_tipo_stampa == 3) //stampa di prova
    {
      set_row(_r, "@125g%6d", numreg);
      if (stampato)
        set_row(_r, "@131g*");
    }
  }
  return TRUE;
}

print_action CG4400_application::postprocess_print(int file, int counter)
{
  if (file == LF_MOV)
  {
    if (_stampa_tutti_i_registri)
    {
      _tabreg->next();
      TString codtab = _tabreg->get("CODTAB");
      int anno = atoi(codtab.mid(0,4)); 
      if ( (_tabreg->eof()) || (anno != _annoes) ) 
        return NEXT_PAGE;
      else
      {
        _tipo_reg      = _tabreg->get_int("I0");
        _desc_lib      = _tabreg->get("S0");
        _data_da       = _tabreg->get_date("D3");
        _codreg        = codtab.mid(4,3);
        if (!_mov_empty ) 
          printer().formfeed();
        _cur->set_filterfunction(NULL);
        _cur->set_filterfunction(filter_func);
        _mov_empty = TRUE;   
        return REPEAT_PAGE;
      }
    }
  }  
  
  if (file == LF_RMOVIVA)
    if (!counter)
    {
      bool FINITO = FALSE;
      TRecnotype pos   = _cur->pos();
      long       items = _cur->items();
      
      FINITO = (pos == items-1);
      
      if ( FINITO )  
      {
        set_page_tot_reg();
        return REPEAT_PAGE;
      }
      else if ( (_tipo_stampa == 1) || (_tipo_stampa == 4) )
      {
        TLocalisamfile* mov = _cur->file(LF_MOV);
        TDate dataregp = mov->get_date(MOV_DATAREG);        

        _cur->save_status();
        ++(*_cur);
        TDate datareg = mov->get_date(MOV_DATAREG);
        --(*_cur);
        _cur->restore_status();
        if (datareg.month() != dataregp.month())
        {
          set_page_tot_reg();
          return REPEAT_PAGE; 
        }
      }  
    }

  return NEXT_PAGE;   
}

bool CG4400_application::set_print(int n)
{
  TMask m("cg4400a");
  int giorni_del_mese; 
  
  if (set_ditte(m))
    if (_selected.ones() > 0l)
    {
      _tipo_stampa = m.get_int(TIPO_STAMPA);
      _annoes      = m.get_int(ANNO);
      if (_tipo_stampa == 2)  //stampa su libro unico di studio
        _codreg = m.get(CODICE_LIBRO_IVA);
      else if (_tipo_stampa == 3) //stampa di prova
        _codreg = m.get(CODICE_LIBRO_PROVA);        
      else _codreg = m.get(CODICE_LIBRO);        
      if (_codreg.trim().empty())
      {
        _tabreg->first();
        _codtab = _tabreg->get("CODTAB");
        _codreg = _codtab.mid(4,3);
        _stampa_tutti_i_registri = TRUE;
      }
      else
        _stampa_tutti_i_registri = FALSE;

      //Se stampa di prova l'utente indica data_da e data_a
      if (_tipo_stampa == 3)                            
      {
        _data_stampa = m.get(DATA_STAMPA);
        _data_da     = m.get(DA_DATA);
        _data_a      = m.get(A_DATA);
        if (!_data_da.ok())
          _data_da = format("01/01/%4d", _annoes);
        if (!_data_a.ok())
          _data_a = format("31/12/%4d", _annoes);
        printer().setdate(_data_stampa);
      }
      // senno' data_da e' letta dal registro
      else   //stampe definitive
      {
        if ( (_tipo_stampa == 1) || (_tipo_stampa == 4) )
          _fino_a_mese = m.get_int(FINO_A_MESE);
        else 
          _fino_a_mese = m.get_int(MESE);   
        if (_fino_a_mese == 12)
          giorni_del_mese = 31;
        else
        {
          TDate primo = format("01/%02d/%4d", _fino_a_mese+1, _annoes);
          --primo;
          giorni_del_mese = primo.day();
        }
        _data_a=format("%02d/%02d/%4d",giorni_del_mese,_fino_a_mese,_annoes);
        // NB data_da viene letta nella preprocess_page
      }
      _codtab = format("%4d%-3s",_annoes, (const char *)_codreg);
      compila_reg(); 
      //if ( (_tipo_stampa == 1) || (_tipo_stampa == 4) )
      
      stampa_registri_IVA();
    }
else warning_box("Nessuna ditta selezionata!"); 
  return FALSE;
}

void CG4400_application::stampa_registri_IVA() 
{
  long l;
  long firm = TApplication::get_firm();
  bool ok = FALSE;

  for (l = 0l, _nditte->first(); !_nditte->eof(); l++, _nditte->next())
  {
    if (_selected[l])
    {
      TApplication::set_firm(_nditte->get_long("CODDITTA"));
      _frequiva = _nditte->get("FREQVIVA")[0];
      if (_tipo_stampa != 3) //stampa definitiva
        ok = controlla_liquidazione() && controlla_mov();
      if (ok) print();
    }
  }
  TApplication::set_firm(firm);
}

bool CG4400_application::set_ditte(TMask& m)
{
  _selected.reset();
  
  m.field(F_SELECT).set("0");
  m.field(DA_CODICE).set("");
  m.field(A_CODICE).set("");
  m.field(TIPO_STAMPA).set("1");
  
  m.set_handler (TIPO_STAMPA, my_handler);
  m.set_handler (MESE,        mask_mese);
  m.set_handler (FINO_A_MESE, mask_fino_a_mese);
  m.set_handler (CODICE_LIB_UN, mask_cod);
  m.set_handler (DLG_SELECT, mask_select);
  m.set_handler (F_ANNULLA,  mask_annulla);
  m.set_handler (F_VERIFICA, mask_verifica); 
  
  KEY tasto;     

  _stampa_width = 132;
  set_real_picture("###.###.###.###");

  tasto = m.run();

  //  m.first_focus(tasto);
  
  return tasto == K_ENTER;
}

int CG4400_application::stampa_intestazione_ditta()
{
  TDati_ditta tditta(get_firm(), _stampa_width);
  int r=1;
  TString riga(tditta.prima_riga());

  set_header (r, "%s", (const char *) riga);
  r++;

  riga = tditta.seconda_riga();

  set_header (r, "%s", (const char*) riga);
  r++;
  
  return r;
}

void CG4400_application::preprocess_header()
{
  int r=1;
  TString cor, nd1, nd2; 
  TString riga(_stampa_width);
  TString data;   
  
  if (_tipo_stampa != 3) //cioe' si tratta di una stampa definitiva
  { 
    if ( (_tipo_stampa == 1) || (_tipo_stampa == 4) )
      data.format("%s %s %d", (const char*)"mese di", itom(_datareg.month()), 
                  _datareg.year());
    else data.format("%s %s %d", (const char*)"mese di", itom(_fino_a_mese), _annoes);                
  }
else 
  data = _data_da.string();

  reset_header();

  r = stampa_intestazione_ditta();

  set_header(r, "Registro IVA: %s %s   %s    Attivita\' %s %s",
             (const char *) _codreg, (const char *) _desc_lib, 
             (const char *) data, (const char *) _codatt,
             (const char *) _attivita);
  r++;

  riga.fill('-'); 
  set_header(r, riga);
  r++;
  if (_tipo_reg == 1)  //registro vendite
  {
    cor = "R";
    nd1 = "";
    nd2 = "";
  }  
  if (_tipo_reg == 2)
  { 
    cor = "C";
    nd1 = "N";
    nd2 = "D";
  }
  if (_tipo_stampa == 3) //stampa di prova
  {
    set_header(r,"@10gNum.@19gDocumento@68gT Tipo@103gCod %s@121g@124gT@128gNum",  (const char*) nd1);
    r++;
    set_header(r, "Data reg. prot.@17gData@25gNumero Codice Ragione sociale/descrizione@68gO Doc.@76gTotale doc.@91gImponibile  Iva %s@112gImposta@124g%s@128gReg", (const char*) nd2, (const char*) cor);
    r++;
  }
  else
  {
    set_header(r,"@10gNum.@19gDocumento@68gT Tipo@103gCod %s@121g@124gT", (const char*) nd1);
    r++;
    set_header(r, "Data reg. prot.@17gData@25gNumero Codice Ragione sociale/descrizione@68gO Doc.@76gTotale doc.@91gImponibile  Iva %s@112gImposta@124g%s", 
               (const char*) nd2, (const char*) cor);
    r++;
  } 
  riga.fill('-'); 
  set_header(r, riga);
}

int cg4400 (int argc, char * argv[])
{
  CG4400_application a;
  a.run(argc, argv, "Stampa registri IVA");
  return 0;
}