#include <applicat.h>
#include <automask.h>
#include <progind.h>
#include <recarray.h>
#include <relation.h>
#include <utility.h>

#include "777.h"
#include "777lib.h"
#include "777200a.h"

#include "777200.h"
#include "../fe/felib.h"

#include <anagr.h>
#include <anafis.h>
#include <anagiu.h>
#include <attiv.h>
#include <comuni.h>
#include <nditte.h>
#include "base.h"
#include "quadroc.h"

///////////////////////////////////////////////////////////
// Utilities
///////////////////////////////////////////////////////////

// Forma un numero di telefono composto di sole cifre da prefisso+numero
const TString& get_telephone(const TRectype& rec, const char* pref, const char* numf)
{
  TString& num = get_tmp_string();
  num << rec.get(pref) << rec.get(numf);
  char* dst = num.get_buffer();
  for (const char* src = dst; *src; src++)
  {
    if (*src >= '0' && *src <= '9')
    {
      if (src > dst)
        *dst = *src;
      dst++;
    }
  }
  *dst = '\0';
  return num;
}

///////////////////////////////////////////////////////////
// TTracciatoCU
///////////////////////////////////////////////////////////

#define CU_DEFAULT_NAME "MODCUR16"

class TTracciatoCU : public TTracciato770
{
public:
  TTracciatoCU(char tipo);
};

TTracciatoCU::TTracciatoCU(char tipo)
{
  if (strchr("ABCDHZ", tipo) == NULL)
    NFCHECK("Tipo record non valido: %c", tipo);
  set_tipo(tipo);
  
  add_field("Tipo record", AN, 1, 1);                     // 1
  
  if (tipo == 'A')
  {
    add_filler(2, 14);                                       // 2 
    add_field("Codice fornitura",              AN,  16,  5); // 3
    add_field("Tipo fornitore",                NU,  21,  2); // 4
    add_field("Codice fiscale del fornitore",  CF,  23, 16);
  } else
  if (tipo == 'B')
  {
    add_field("Codice fiscale sostituto",             CF,  2, 16); // 2 
    add_field("Progressivo modulo",                   NU, 18,  8);
    add_filler( 26, 1);
    add_filler( 27, 8);
    add_filler( 35, 25);
    add_field("Spazio a disposizione",                AN, 60, 14); // 7
    add_field("CF del produttore del software",       CF, 74, 16); 
    add_filler( 90, 1);
    
    // Tipo di dichiarazione
    add_field("Annullamento",                         CB, 91,  1); // 10
    add_field("Sostituzione",                         CB, 92,  1); 

    // Dati del sostituto
    add_field("Cognome",                              AN, 93, 24); // 12
    add_field("Nome",                                 AN,117, 20);
    add_field("Denominazione (Alternativo a 12 e 13)",AN,137, 60);
    add_field("Indirizzo E-mail",                     AN,197,100);
    add_field("Telefono o Cellulare",                 AN,297, 12);
    add_field("FAX",                                  AN,309, 12); // 17

    add_field("Codice fiscale del rappresentante",    CF,321,16);  // 18
    add_field("Codice carica del rappresentante",     NU,337, 2);
    add_field("Cognome",                              AN,339,24);
    add_field("Nome",                                 AN,363,20);
    add_field("Codice fiscale del dichiarante",       CN,383,11);

    add_field("Numero comunicaz. lavoro dipendente",  NU, 394, 8); // 23
    add_field("Numero comunicaz. lavoro autonomo",    NU, 402, 8);
    add_field("Casella quadro CT",                    CB, 410, 1);  
    add_field("Firma del dichiarante",                CB, 411, 1);

    add_field("Codice fiscale intermediario",         CF, 412,16); // 27
    add_field("Impegno a trasmettere la dichiaraz.",  NU, 428, 1);
    add_field("Data dell'impegno",                    DT, 429, 8);
    add_field("Firma dell'intermediario",             CB, 437, 1);  
  } else
  if (tipo == 'D')
  {
    add_field("Codice fiscale del sostituto",         CF,  2, 16);    // 2
    add_field("Progressivo modulo",                   NU, 18,  8);    // 3
    add_field("Codice fiscale percipiente",           CF, 26, 16);    // 4
    add_field("Progressivo certificazione",           NU, 42,  5);    // 5
    add_field("Identificativo dell'invio",            NU, 47, 17);    // 6
    add_field("Progressivo singola C.U.",             NU, 64,  6);    // 7
    add_filler(70, 14);
    add_field("Tipo Operazione",                      AN, 84,  1, 9); // 9
    add_filler(85, 4);
    add_field("Conferma singola certificazione",      CB, 89,  1);    // 11
  } else
  if (tipo == 'H')
  {
    add_field("Codice fiscale del sostituto",         CF,  2, 16); // 2
    add_field("Progressivo modulo",                   NU, 18,  8); // 3
    add_field("Codice fiscale percipiente",           CF, 26, 16); // 4
    add_field("Progressivo certificazione",           NU, 42,  5); // 5
  } else
  if (tipo == 'Z')
  {
    add_filler(2, 14);                                  
    add_field("Numero record di tipo 'B'", NU, 16, 9); // 3
    add_field("Numero record di tipo 'C'", NU, 25, 9);
    add_field("Numero record di tipo 'D'", NU, 34, 9);
    add_field("Numero record di tipo 'G'", NU, 43, 9); // 6
    add_field("Numero record di tipo 'H'", NU, 52, 9); 
  }
}

///////////////////////////////////////////////////////////
// TTracciatiCU
///////////////////////////////////////////////////////////

class TTracciatiCU : public TObject
{
  TArray _trc;
public:
  const TTracciato770& tracciato(char tipo);
} _trcCU;

const TTracciato770& TTracciatiCU::tracciato(char tipo)
{
  CHECK(tipo >= 'A' && tipo <= 'Z', "Tipo record non valido");
  const int pos = tipo - 'A';
  TTracciatoCU* trc = (TTracciatoCU*)_trc.objptr(pos);
  if (trc == NULL)
  {
    trc = new TTracciatoCU(tipo);
    _trc.add(trc, pos);
  }
  return *trc;
}

class TRecordCU : public TRecord770
{
private:
  virtual TObject* dup() const { return new TRecordCU(*this); }

protected:
  virtual const TTracciato770& tracciato() const
  { return _trcCU.tracciato(tipo_record());  }

public:
  virtual bool valid() const
  {
    const char tipo = tipo_record();
    return (tipo > ' ') && (strchr("ABCDGHZ", tipo) != NULL);
  }

  virtual bool ha_campi_non_posizionali() const { return strchr("DGH", tipo_record()) != NULL; }
  bool ha_campo_posizionale(int fld) const { return tracciato().exists(fld); }

  TRecordCU() { }
  TRecordCU(const TRecordCU& rec) : TRecord770(rec) { }
  TRecordCU(char tipo) { tipo_record(tipo); }
};

///////////////////////////////////////////////////////////
// TTrasferimentoCU
///////////////////////////////////////////////////////////

const TVariant& TTrasferimentoCU::get_var(const char* name) const
{
  if (_cur_pos >= 0 && _cur_pos < items())
  {
    const TRecordCU& cur_rec = (const TRecordCU&)_data[_cur_pos];
    const TFixed_string varname(name+1);
    if (real::is_natural(varname))
    {
      const int n = atoi(varname);
      if (n > 0 && cur_rec.ha_campo_posizionale(n))
      {
        TVariant& var = get_tmp_var();
        switch (column_info(n-1)._type)
        {
        case _nullfld:
          break;
        case _boolfld:
          {
            TString4 str; cur_rec.get(n, str);
            var = str == "1" || str == "X";
          }
          break;
        case _datefld:
          {
            TString8 str; cur_rec.get(n, str);
            if (str.full() && str != "00000000")
              var = str;
          }
          break;
        case _realfld:
          {
            TString80 str; cur_rec.get(n, str);
            var = real(str);
          }
          break;
        default:
          {
            TString256 str; cur_rec.get(n, str);
            var = str;
          }
          break;
        }
        return var;
      }
    }
    else
    {
      if (cur_rec.ha_campi_non_posizionali_compilati())
      {
        TString80 str;
        TString8 key;
        TString16 val; 
        for (int p = 0; cur_rec.np_get(p, key, val); p++)
        {
          if (p == 0 && key[0] != varname[0]) // Record di tipo errato!
            return NULL_VARIANT;
          if (key == varname)
          {
            str = val;
            while (cur_rec.np_get(++p, key, val) && key == varname)
              str << val.mid(1);
            str.rtrim();
            break;
          }
          if (key > varname)
            break;
        }
        return get_tmp_var() = str;
      }
    }
  }
  return NULL_VARIANT;
}


bool TTrasferimentoCU::load(const char* path)
{
  if (path && *path)
  {
    _name = path;
    if (_name.find(CU_DEFAULT_NAME) < 0)
      _name.add(CU_DEFAULT_NAME);
  }
  if (_name.empty())
    _name = CU_DEFAULT_NAME;

  ifstream is(_name, ios::in | ios::binary);
  TRecordCU rec;
  while (!is.eof())
  {
    is >> rec;
    if (rec.valid())
      _data.add(rec);
  }
  _cur_pos = _data.empty() ? 0 : -1;
  return _cur_pos>=0;
}

TTrasferimentoCU& TTrasferimentoCU::operator<<(const TRecordCU& rec)
{
  _data.add(rec);
  return *this;
}

TTrasferimentoCU& TTrasferimentoCU::operator>>(TRecordCU& rec)
{
  if (_cur_pos < items())
    rec = (const TRecordCU&)_data[_cur_pos++];
  return *this;
}

unsigned int TTrasferimentoCU::columns() const 
{ 
  int f = 1;
  if (_cur_pos >= 0 && _cur_pos < items())
  {
    const TRecordCU& cur_rec = (const TRecordCU&)_data[_cur_pos];
    f = cur_rec.campi_posizionali();
    if (cur_rec.ha_campi_non_posizionali_compilati())
    {
      TString16 key, val;
      for (int i = 0; cur_rec.np_get(i, key, val); i++)
        f++;
    }
  }
  return f; 
}

const TRecordset_column_info& TTrasferimentoCU::column_info(unsigned int column) const 
{ 
  static TRecordset_column_info ci;
  if (column < 256 /*column >= 0 && column < columns()*/)
  {
    const TRecordCU& cur_rec = (const TRecordCU&)_data[_cur_pos];
    const TTracciato770& trc = _trcCU.tracciato(cur_rec.tipo_record());
    if (column < (unsigned int)trc.campi_posizionali())
    {
      if (trc.exists(column+1))
      {
        const TField770& fld = trc.field(column+1);
        ci._name = fld._desc;
        switch (fld._type)
        {
        case VN:
        case VP: ci._type = _realfld; break;
        case DT: ci._type = _datefld; break;
        case CB: ci._type = _boolfld; break;
        default: ci._type = (ci._name == "Filler") ? _nullfld : _alfafld; break;
        }
        ci._width = fld._len;
      }
      else
      {
        ci._name = "Filler";
        ci._type = _nullfld;
        ci._width = 0;
      }
    }
    else
    {
      TString16 key, val;
      const int f = column - trc.campi_posizionali();
      cur_rec.np_get(f, key, val);
      ci._name = key;
      ci._type = _alfafld;
      ci._width = 16;
    }
  }
  else
  {
    ci._name.cut(0);
    ci._type = _nullfld;
    ci._width = 0;
  }
  return ci;
}

const TVariant& TTrasferimentoCU::get(unsigned int column) const
{
  if (column < columns())
  {
    const TRecordCU& cur_rec = (const TRecordCU&)_data[_cur_pos];
    if (column <= 0)
    {
      const char str[2] = { cur_rec.tipo_record(), '\0' };
      return get_tmp_var() = str;
    }
    else
    {
      if (column < (unsigned int)cur_rec.campi_posizionali())
      {
        TString4 fld; fld.format("#%d", column+1);
        return get_var(fld);
      }
      else
      {
        TString16 key, val;
        const int f = column - cur_rec.campi_posizionali();
        cur_rec.np_get(f, key, val);
        return get_tmp_var() = val;
      }
    }
  }
  return NULL_VARIANT;
}

bool TTrasferimentoCU::set_field(int n, const TVariant& var)
{
  bool done = _data.objptr(_cur_pos) != NULL;
  if (done)
  {
    TRecordCU& cur_rec = (TRecordCU&)_data[_cur_pos];
    done = cur_rec.ha_campo_posizionale(n);
    if (done)
      cur_rec.set(n, var.as_string());
  }
  return done;
}

bool TTrasferimentoCU::set_field(const char* name, const TVariant& var)
{
  bool done = name && *name && _data.objptr(_cur_pos) != NULL;
  if (done)
  {
    TRecordCU& cur_rec = (TRecordCU&)_data[_cur_pos];
    if (isdigit(*name))
      done = set_field(atoi(name), var);
    else
      done = cur_rec.np_put(name, var.as_string());
  }
  return done;
}


const TString& TTrasferimentoCU::read_codfis_dic(const TRectype& rec)
{
  TToken_string key;  // Stringa multiuso

  key = rec.get(BSE_CODDIC);
  if (key.empty())
    key = rec.get(BSE_CODDITTA);

  const TRectype& rec_nditte = cache().get(LF_NDITTE, key);
  if (rec_nditte.empty())
  {
    error_box(FR("Non esiste la ditta %s"), (const char*)key);
	  return EMPTY_STRING;
  }
  _cod_ditta = atol(key);
  _tipoa_dic = rec_nditte.get_char(NDT_TIPOA);
  _codan_dic = rec_nditte.get_long(NDT_CODANAGR);

  _codatt_dic = rec_nditte.get(NDT_CODATTPREV); // Codice attivita' prevalente
  key.add(_codatt_dic);                         // key = CODDITTA|CODATTPREV
  const TRectype& attiv = cache().get(LF_ATTIV, key);
  if (attiv.exist(ATT_CODATECO))                // Non e' detto che il campo esista sempre
  {
    const TString& codateco = attiv.get(ATT_CODATECO);
    if (codateco.full())
      _codatt_dic = codateco;
  }

  key.cut(0) << _tipoa_dic;
  key.add(rec_nditte.get(NDT_CODANAGR));
  const TRectype& rec_anagr = cache().get(LF_ANAG, key);
  if (rec_anagr.empty())
  {
    error_box(FR("Non esiste la persona %s"), (const char*)key);
	  return EMPTY_STRING;
  }
  _codfis_dic = rec_anagr.get(ANA_COFI);   //  Codice fiscale del dichiarante
  if (_codfis_dic.len() > 11)
    _codfis_dic = rec_anagr.get(ANA_PAIV);
  _ragsoc_dic = rec_nditte.get(NDT_RAGSOC); //  Denominazione del dichiarante
  
  return _codfis_dic;
}

void TTrasferimentoCU::set_operazione(char t, const TString& iden) 
{ 
  _tipo_operazione = (t == 'A' || t == 'S') ? t : ' '; 
  _certificazione = 0;
  if (_tipo_operazione >= 'A')
    _identificativo = iden;
  else
    _identificativo.cut(0);
}


TRecnotype TTrasferimentoCU::conta_certificazioni() const
{
  int anno = _anno;
  if (anno < 2015)
    anno = 2015;

  TString query;
  query.format("USE %d SELECT (ANNO=%d)&&(CODANAGR>0)\nFROM CODDITTA=%ld\nTO CODDITTA=%ld",
                LF_QUALA, anno, _cod_ditta, _cod_ditta);
  TISAM_recordset recset(query);
  return recset.items();
}

bool TTrasferimentoCU::append_record_b()
{
  if (!save_headers())
    return false;
  
  TRecordCU rec('B');        // Compila record di testata B
  rec.set(2, cod_fis_dic());
  rec.set(3, 1);             // Modulo (deve essere sempre 1)
  rec.set(8, CF_PRODUTTORE); // CF del produttore Sirio
  rec.set(10, _tipo_operazione == 'A');
  rec.set(11, _tipo_operazione == 'S');

  if (_tipoa_dic == 'F')
  {
    rec.set(12, _ragsoc_dic.left(24));
    rec.set(13, _ragsoc_dic.mid(30,20));
  }
  else
    rec.set(14, _ragsoc_dic);

  const TRectype& rec_nditte = cache().get(LF_NDITTE, _cod_ditta);
  rec.set(15, rec_nditte.get(NDT_MAIL));

  TString80 numtel = get_telephone(rec_nditte, NDT_PTEL, NDT_TEL);
  if (numtel.blank())
    numtel = get_telephone(rec_nditte, NDT_PFAX, NDT_FAX);
  rec.set(16, numtel);

  const TAnagrafica rapp(LF_ANAG, 'F', rec_nditte.get_long(NDT_RAPPR));
  if (rapp.ok())
  {
    _codfis_rap = rapp.codice_fiscale();
    rec.set(18, _codfis_rap);
    rec.set(19, rec_nditte.get(NDT_CARRAPP));
    rec.set(20, rapp.cognome().left(24));
    rec.set(21, rapp.nome());
  }
  else
  {
    _codfis_rap = _codfis_dic;
    cantread_box("legale rappresentante");
  }

  rec.set(23, 0);                      // Dichiarazioni relative a dipendenti
  rec.set(24, conta_certificazioni()); // Certificazioni per autonomi e provvigioni
  rec.set(26, true);                   // Firma

  if (_codfis_int.full())
  {
    rec.set(27, _codfis_int);
    rec.set(28, 1);                      // Impegno alla trasmissione (1 o 2)  
    rec.set(29, _data_imp);              // Data impegno alla trasmissione
    rec.set(30, true);                   // Firma intermediario
  }

  _data.add(rec);
  return true;
}

bool TTrasferimentoCU::append_record_d(const TRectype& qla, TLog_report& log)
{
  const char tipoanag = qla.get_char("TIPOA");
  const long codanagr = qla.get_long("CODANAGR");
  if (tipoanag < 'F'  || codanagr <= 0)
  {
    TString msg; msg.format(FR("Scartato percipiente non valido %c/%ld"), tipoanag, codanagr);
    log.log(2, msg);
    return false;
  }

  const TAnagrafica perc(LF_ANAG, tipoanag, codanagr);
  if (!perc.ok())
  {
    TString msg; msg.format(FR("Scartato percipiente non valido %c/%ld"), tipoanag, codanagr);
    log.log(2, msg);
    return false;
  }

  if (perc.codice_fiscale().blank())
  {
    TString msg; msg.format(FR("Scartato percipiente %c/%ld senza codice fiscale"), tipoanag, codanagr);
    log.log(2, msg);
    return false;
  }
  
  TRecordCU rec('D');         // Compila record percipiente D
  rec.set(2, cod_fis_dic());
  rec.set(3, 1);              // Modulo (deve essere sempre 1)
  rec.set(4, perc.codice_fiscale());
  rec.set(5, ++_certificazione); // Progressivo certificazione
  rec.set(9, _tipo_operazione); 
  if (_tipo_operazione >= 'A')
  {
    rec.set(6, _identificativo); 
    rec.set(7, _certificazione); 
  }
  rec.set(11, false); // Conferma singola certificazione

  const TAnagrafica sost(LF_NDITTE, _cod_ditta);
  rec.np_put("DA001001", cod_fis_dic());
  if (sost.fisica())
  {
    rec.np_put("DA001002", sost.cognome());
    rec.np_put("DA001003", sost.nome());
  }
  else
    rec.np_put("DA001002", sost.ragione_sociale());

  rec.np_put("DA001004", sost.comune_residenza());
  rec.np_put("DA001005", sost.provincia_residenza());
  rec.np_put("DA001006", sost.CAP_residenza());
  rec.np_put("DA001007", sost.indirizzo_residenza());

  const TRectype& rec_nditte = cache().get(LF_NDITTE, _cod_ditta);
  rec.np_put("DA001008", get_telephone(rec_nditte, NDT_PTEL, NDT_TEL));
  rec.np_put("DA001009", rec_nditte.get(NDT_MAIL));
  rec.np_put("DA001010", _codatt_dic);
  // rec.np_put("DA001011", "1"); // Codice Sede ???

  rec.np_put("DA002001", perc.codice_fiscale());
  if (perc.fisica())
  {
    rec.np_put("DA002002", perc.cognome());
    rec.np_put("DA002003", perc.nome());
    rec.np_put("DA002004", perc.sesso());
    rec.np_put("DA002005", perc.data_nascita());
    rec.np_put("DA002006", perc.comune_nascita());
    rec.np_put("DA002007", perc.provincia_nascita());
  }
  else
  {
    rec.np_put("DA002002", perc.ragione_sociale());
  }

  const TRectype& anag = cache().get_rec(LF_ANAG, qla.get("TIPOA"), qla.get("CODANAGR"));
  rec.np_put("DA002008", anag.get(ANA_CATPAR));
  rec.np_put("DA002009", anag.get_long(ANA_EVECC));
  rec.np_put("DA002010", anag.get_long(ANA_ESCPRECOMP));

  const TString& causale = qla.get("CAUSALE");
  if (causale == "N")
  {
    rec.np_put("DA002020", perc.comune_residenza());
    rec.np_put("DA002021", perc.provincia_residenza());
    rec.np_put("DA002022", perc.codice_comune_residenza());
  }

  // rec.np_put("DA002030", "");  // Codice fiscale del rappresentante un incapace

  if (perc.estero())
  {
    rec.np_put("DA002040", perc.partita_IVA());
    rec.np_put("DA002041", perc.comune_residenza());
    rec.np_put("DA002042", perc.indirizzo_residenza());
    // 2015
    //rec.np_put("DA002043", perc.stato_estero_UNICO());
    // 2016
    rec.np_put("DA002044", perc.stato_estero_UNICO());
  }

  rec.np_put("DA003001", _data_tra);
  rec.np_put("DA003002", true);

  _data.add(rec);
  return true;
}

bool TTrasferimentoCU::append_record_h(const TRectype& qla, int modulo, TLog_report& log)
{
  const char tipoanag = qla.get_char("TIPOA");
  const long codanagr = qla.get_long("CODANAGR");
  if (tipoanag < 'F' && codanagr <= 0)
  {
    TString msg; msg.format(FR("Scartato percipiente non valido %c/%ld"), tipoanag, codanagr);
    log.log(2, msg);
    return false;
  }

  TAnagrafica perc(LF_ANAG, tipoanag, codanagr);
  if (!perc.ok())
  {
    TString msg; msg.format(FR("Scartato percipiente non valido %c/%ld %s"), tipoanag, codanagr, (const char*)perc.codice_fiscale());
    log.log(2, msg);
    return false;
  }

  TRecordCU rec('H');                // Compila record H
  rec.set(2, cod_fis_dic());         // Codice fiscale sostituto
  rec.set(3, modulo);                // Progressivo modulo
  rec.set(4, perc.codice_fiscale()); // Codice fiscale del percipiente
  rec.set(5, _certificazione);       // Progressivo certificazione

  const TString4 causale = qla.get("CAUSALE");
  rec.np_put("AU001001", causale);
  if (causale >= "G" && causale <= "I")
    rec.np_put("AU001002", qla.get_long("ANNO")); // Potrebbe essere anche l'anno precedente

  //  rec.np_put("AU001003", "");
  rec.np_put("AU001004", qla.get_real("TOTALE"));
  
  if (perc.estero())
    rec.np_put("AU001005", qla.get_real("SOMREGCONV"));
  
  real altre_somme = qla.get_real("SOMME");
  real imponibile = qla.get_real("IMPONIBILE");

  const TString4 codcaus = qla.get("CODCAUS");
  long codice = atol(cache().get("%CA7", codcaus, "I1")); // 1, 2, 3
  if (altre_somme.is_zero() && codice == 3)
  {
    altre_somme = imponibile;
    imponibile = ZERO;
  }
  if (!altre_somme.is_zero())
  {
    if (codice <= 0) codice = 3; // Regime minimi
    rec.np_put("AU001006", codice);  // 1, 2, 3
    rec.np_put("AU001007", altre_somme);
  }
  rec.np_put("AU001008", imponibile); // 004 - 005 - 007
  rec.np_put("AU001009", qla.get_real("IMPORTO"));    // ritenute a titolo di acconto
  //rec.np_put("AU001010", ZERO);                     // ritenute a titolo di imposta
  rec.np_put("AU001011", qla.get_real("RITSOSPESE")); // ritenute sospese
  if (causale == "N")
    rec.np_put("AU001012", qla.get_real("ADDREG"));   // addizionale regionale

  rec.np_put("AU001018", qla.get_real("IMPANNIPRE")); // imponibile anni precedenti
  rec.np_put("AU001019", qla.get_real("RITANNIPRE")); // ritenute anni precedenti
  //rec.np_put("AU001020", qla.get_real("SPESERIMB"));  // spese rimborsate
  //rec.np_put("AU001021", qla.get_real("RITRIMB"));    // ritenute rimborsate

  const real cce = qla.get_real("CTINPSEROG");
  const real ccp = qla.get_real("CTINPSPERC");
  const real cal = qla.get_real("ALTRICONTR");
  const real cdo = qla.get_real("CONTRDOV");
  const real cve = qla.get_real("CONTRVER");
  if (!cce.is_zero() || !cal.is_zero() || !ccp.is_zero() || !cdo.is_zero() || !cve.is_zero())
  {
    TString8 entprev = qla.get("ENTEPREV");
    TString4 cat = qla.get("CATEGORIA");
    if (entprev.blank())
    {
      const TRectype& aperc = cache().get_rec(LF_PERC, qla.get("CODDITTA"), qla.get("TIPO"), qla.get("CODANAGR"));
      entprev = aperc.get("ENTEPREV");
      cat = aperc.get("CATEGORIA");
    }
    if (entprev.full())
    {
      const TRectype& inps = cache().get("%ENT", entprev);
      rec.np_put("AU001029", inps.get("S5")); // codice fiscale ente previdenziale
      rec.np_put("AU001030", inps.get("S0")); // denominazione ente previdenziale
      rec.np_put("AU001031", inps.get("S6")); // codice ente previdenziale (2, 4, A)

      TToken_string cod_az; cod_az.format("77ENT|%s|%05ld",(const char*)entprev, qla.get_long("CODDITTA")); 
      const TString& azienda = cache().get(LF_MULTIREL, cod_az, "DATA");
      rec.np_put("AU001032", azienda); // codice azienda presso ente previdenziale
    }

    rec.np_put("AU001033", cat);
    rec.np_put("AU001034", cce); // contributi a carico erogante
    rec.np_put("AU001035", ccp); // contributi a carico percipiente
    if (!cal.is_zero())
    {
      rec.np_put("AU001036", true); // altri contributi?
      rec.np_put("AU001037", cal);  // importo altri contributi
    }
    rec.np_put("AU001038", cdo); // contributi dovuti
    rec.np_put("AU001039", cve); // contributi versati
  }

  _data.add(rec);
  return true;
}

static real& real_at(TArray& riep, int idx)
{
  real* r = (real*)riep.objptr(idx);
  if (r == NULL)
    riep.add(r = new real, idx);
  return *r;
}

bool TTrasferimentoCU::save(const char* path)
{
  ofstream of(path && *path ? path : _name, ios::binary);
  for (_cur_pos = 0; _cur_pos < items(); _cur_pos++)
    of << cur_rec();
  return of.good();
}

bool TTrasferimentoCU::split(const char* path)
{
  TRecnotype totale[26]; memset(totale, 0, sizeof(totale));

  bool good = move_first();

  const unsigned long disk_size = 15*1024*1024;   // Max 15 Mb per fornitura
  const long records = items();
  const long records_per_disk = long(disk_size / TOTAL_SIZE) - 3;  // Tolgo A,B,Z
  const int volumes = int((records-1)/records_per_disk)+1;

  TProgress_monitor pi(records, TR("Generazione file trasferimento"));
  for (int volume = 1; good && volume <= volumes; volume++)
  {
    // Specifica volume solo se necessario
    TFilename fn = path; fn.add(CU_DEFAULT_NAME);
    if (volumes > 1) fn << '_' << volume;
    TTrasferimentoCU outfile(fn, 'w');
  
    if (save_headers())
    {      
      TRecordCU rec;
      rec.tipo_record('A');      // Compila record di testata A
      rec.set(3, "CUR16");       // Codice fornitura
      rec.set(4, 1);             // Tipo fornitore: 01=Soggetto che invia la propria dichiarazione; 10=CAF
      rec.set(5, _codfis_int.full() ? _codfis_int : cod_fis_dic()); // Codice fiscale del fornitore  
      outfile << rec;            // Scrive record testata
    }
    
    long written = 0;
  
    for (; good; good = move_next())
    {
      const TRecordCU& rec = cur_rec();
      const char tipo_rec = rec.tipo_record();
      if (tipo_rec <= 'A' || tipo_rec >= 'Z')
        continue;

      outfile << rec;
      written++;

      totale[tipo_rec-'A']++;
  
      if (written >= records_per_disk)
        break;

      if (!pi.add_status())
      {
        good = false;
        break;
      }
    }

    if (save_headers())
    {
      // Compi la record di coda
      TRecordCU rec; 
      rec.tipo_record('Z');
      rec.set(3, totale['B'-'A']);  // Totale B
      rec.set(4, totale['C'-'A']);  // Totale C
      rec.set(5, totale['D'-'A']);  // Totale D
      rec.set(6, totale['G'-'A']);  // Totale G
      rec.set(7, totale['H'-'A']);  // Totale H
  
      // Scrive record di coda
      outfile << rec;
    }
    outfile.save();
  }  
  return true;
}

// Cancella il file
void TTrasferimentoCU::remove()
{
  ::remove(_name);
}

TTrasferimentoCU::TTrasferimentoCU(const char* path, char  mode)
                : _save_headers(true), _data_imp(TODAY), _data_tra(TODAY), _tipo_operazione(' ')
{
  if (mode == 'r')
    load(path);
  else
  {
    _name = path;

    while (_data_tra.month() > 2 || _data_tra.wday() > 5 || _data_tra.is_holiday())
      --_data_tra;
  }
}

TTrasferimentoCU::~TTrasferimentoCU()
{ }

///////////////////////////////////////////////////////////
// TCU_mask
///////////////////////////////////////////////////////////

class TCU_mask : public TAutomask
{
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

public:
  TCU_mask() : TAutomask("777200a") {}
};

bool TCU_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
  case F_ANNO:
    if (e == fe_init)
    {
      const int anno = ini_get_int(CONFIG_STUDIO, "77", "AnnoDic", 2015);
      o.set(anno);
    }
    break;
  case F_PATH:
    if (e == fe_init || e == fe_modify)
    {
      TFilename f = o.get();
      f.add(CU_DEFAULT_NAME);
      enable(DLG_PREVIEW, f.exist());
    }
    break;
  case DLG_PREVIEW:
    if (e == fe_button)
    {
      TFilename tmp = get(F_PATH);
      tmp.add(CU_DEFAULT_NAME);
      if (tmp.exist())
      {
        const int quality = get_bool(F_QUALITY) ? 2 : 1;
        const bool simple = get_bool(F_SIMPLE);
        print_cu(tmp, quality, simple);
      }
      else
        cantread_box(tmp);
      return false; // don't close mask
    }
    break;
  case DLG_EDIT:
    if (e == fe_button)
    {
      TFilename tmp = get(F_PATH);
      tmp.add(CU_DEFAULT_NAME);
      if (tmp.input() && tmp.exist())
      {
        const int quality = get_bool(F_QUALITY) ? 2 : 1;
        const bool simple = get_bool(F_SIMPLE);
        edit_cu(tmp, quality, simple);
      }
      return false; // don't close mask
    }
    break;
  default: break;
  }
  return true;
}


///////////////////////////////////////////////////////////
// TCU_app
///////////////////////////////////////////////////////////

class TCU_app : public TSkeleton_application 
{
public:
  virtual void main_loop();
};

void TCU_app::main_loop()
{
  TCU_mask m;

  while (m.run() == K_ENTER)
  {
    const int anno = m.get_int(F_ANNO);
    TFilename tmp; tmp.tempdir();
    TTrasferimentoCU t(tmp, 'w');
    t.set_inter(m.get(F_INTER_CODFIS), m.get_date(F_INTER_DATA), anno);
    t.set_operazione(m.get(F_INVIO)[0], m.get(F_IDENTIFICATIVO));

    TString query;
    query.format("USE %d\nFROM CODDITTA=%ld\nTO CODDITTA=%ld",
                 LF_BASE, m.get_long(F_DADITTA), m.get_long(F_ADITTA));
    TISAM_recordset cur_base(query);
    const TRecnotype ditte = cur_base.items();
    if (ditte > 0)
    {
      TLog_report log; log.kill_duplicates();

      const TRectype& base = cur_base.cursor()->curr();
      for (bool ok = cur_base.move_first(); ok; ok = cur_base.move_next())
      {
        const long codditta = base.get_long(BSE_CODDITTA);
        TString msg; msg.format(FR("Generazione C.U. ditta %ld"), codditta);
        log.log(0, "");
        log.log(0, msg);

        t.read_codfis_dic(base);
        t.append_record_b();
      
        query.format("USE %d SELECT (ANNO=%d)\nBY TIPOA CODANAGR CAUSALE\nFROM CODDITTA=%ld\nTO CODDITTA=%ld",
                      LF_QUALA, anno, codditta, codditta);

        TISAM_recordset perc(query);
        const TRecnotype nperc = perc.items();
        if (nperc > 0)
        {
          TProgress_monitor pp(nperc, TR("Generazione record percipienti"));
          const TRectype& rec = perc.cursor()->curr();
          const int modulo = 1; // In realtà non accetta modulo != 1 per cui separa causali diverse in due comunicazioni 
          for (bool ok = perc.move_first(); ok; ok = perc.move_next())
          {
            t.append_record_d(rec, log);  
            t.append_record_h(rec, modulo, log);
            pp.add_status();
          }
        }
      }
      if (log.errors() || log.warnings())
        log.preview();
    }

    tmp = m.get(F_PATH);
    if (t.split(tmp))
    {
      tmp.add(CU_DEFAULT_NAME);
      if (yesno_box(FR("E' stato generato il file %s\nSi desidera visualizzarlo in anteprima?"), (const char*) tmp))
        m.send_key(K_SPACE, DLG_PREVIEW);
    }
    else
    {
      tmp.add(CU_DEFAULT_NAME);
      cantwrite_box(tmp);
    }
    t.remove();
  }
}

int m777200(int argc, char* argv[])
{
  TCU_app app;
  app.run(argc, argv, TR("Certificazione Unica"));
  return 0;
}