#include <applicat.h>
#include <form.h>
#include <automask.h>
#include <progind.h>
#include <recset.h>
#include <recarray.h>
#include <utility.h>

#include "777.h"
#include "777lib.h"
#include "777100a.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"

// Il nuovo quadro ST e' il vecchio quadro L
#define LF_QUADRO_ST LF_QUAL

///////////////////////////////////////////////////////////
// Utility
///////////////////////////////////////////////////////////

const int ANNO_PAG = 2015;

///////////////////////////////////////////////////////////
// TForm770
///////////////////////////////////////////////////////////

class TTrasferimento770;

class TForm770 : public TForm
{
  TCursor* _sortedcur;

  int _index;
  TArray _records;
  TPointer_array _positions;

protected:
  bool compatible(const TRectype& r1, const TRectype& r2);
  void add_rec(TRectype& r1, const TRectype& r2);

  long raggruppa_c();
  int first();
  int next();

  void transfer_section(TPrint_section& body, int rigo,
                        TRecord770& rec, TTrasferimento770& file);
  char log2rec(int num, int& rpm) const;

protected:

  virtual TCursor* cursor() { return _sortedcur ? _sortedcur : TForm::cursor(); }
  virtual bool validate(TForm_item &cf, TToken_string &s);

public:
  TRecnotype trasfer(long codditta, TTrasferimento770& file, char tipo, int rpm);

  TForm770(const char* name);
  virtual ~TForm770();
};

class TTrasferimento770 : public TObject
{
  TFilename _name;
  ifstream* _in_stream;
  ofstream* _out_stream;

  long _cod_ditta, _codan_dic;
  TString8 _codatt_dic;
  char _tipoa_dic;
  TString16 _codfis_dic;
  bool _save_headers;
  bool _centesimi; // Salva importi in centesimi invece che in euro

  TAssoc_array _form;
  
protected:
  void riepiloga_ss(const TRecord770& rec, TArray& riep_ss) const;
  void riepiloga_sx(const TRecord770& rec, TArray& riep_sx) const;
  TForm770& form(const char* quadro, char& tiporec, int& rpm);

public:
  const char* default_name() const;

  bool open(const char* path = "", char mode = 'r', int volume = 0);
  bool close();
  bool write(const TRecord770& rec);
  bool read(TRecord770& rec);
  bool eof() const { return _in_stream && _in_stream->eof(); }

  void set_cent_mode(bool cb) { _centesimi = cb; }
  bool importi_in_centesimi() const { return _centesimi; }
  bool importi_in_euro() const { return !_centesimi; }

  TTrasferimento770& operator<<(const TRecord770& rec)
  { write(rec);  return *this; }
  TTrasferimento770& operator>>(TRecord770& rec)
  { read(rec); return *this; }

  const TString& read_codfis_dic(const TRectype& rec);
  const TString& cod_fis_dic() const { return _codfis_dic; }

  TRecnotype conta_certificazioni() const;
  bool casella_prospetto_st() const;
  bool casella_prospetto_sx() const;
  bool append_record_b();
  long append_quadro(const char* quadro, long codditta, TProgress_monitor& pi);

  bool split(const char* dest_path);
  void remove();

  void save_headers(bool s) { _save_headers = s; }
  bool save_headers() const { return _save_headers; }

  TTrasferimento770(const char* name = "", char mode = 'r', int volume = 0);
  virtual ~TTrasferimento770();
};

///////////////////////////////////////////////////////////
// TForm770
///////////////////////////////////////////////////////////

bool TForm770::validate(TForm_item &cf, TToken_string &s)
{ 
  const TFixed_string code = s.get(0); // prende il primo parametro, il codice del messaggio
  if (code == "_PERIODO_RIF")
  {
    const TRectype& curr = relation()->curr();
    const int anno = curr.get_int("QLAP");
    const int mese = curr.get_int("QLMP");
    TString8 str; str.format("%02d%04d", mese, anno);
    cf.set(str);
    return true;
  }
  if (code == "_PROVINCIA")
  {
    const TFixed_string prov = cf.get();
    if (prov == "EE") // Il 770 non gradisce la provincia EE associata agli stati esteri
      cf.set(""); else
    if (prov == "FO") // Ci sono ancora vecchie province :-( 
      cf.set("FC");
    return true;
  }
  if (code == "_SOLO_CAUS_M")
  {
    const TRectype& curr = relation()->curr();
    if (!curr.get("CAUSALE").starts_with("M") || curr.get_real("IMPONIBILE") <= 5000)
      cf.set("");
    return true;
  }
  if (code == "_SOLO_CAUS_N")
  {
    const TRectype& curr = relation()->curr();
    if (curr.get("CAUSALE") != "N")
      cf.set("");
    return true;
  }

  return TForm::validate(cf, s);
}

void TForm770::transfer_section(TPrint_section& body, int rigo,
                                TRecord770& rec, TTrasferimento770& file)
{
  TString8 basecode, code, type;
  TString str;

  body.update(); 
  for (word f = 0; f < body.fields(); f++)
  {
    TForm_item& fi = body.field(f);
    str = fi.get(); str.trim();
    if (fi.shown() && str.not_empty())
    {
      basecode = fi.get_special_value("TRASFER");
      if (basecode.not_empty())
      {
        type = fi.get_special_desc("TRASFER");
        if (type.full())
        {
          if (type == "CB")  // Casella Barrata
          {
            if (str == "1" || str == "X")
            {
              str = "1";
              str.right_just(16);
            }
            else
              str.cut(0);
          } else
          if (type == "NP" || type == "NU" || type == "VP" || type == "VN")  // Numero Positivo, NUmero, Valuta positiva o libera
          {     
            if (real::is_null(str))
              str.cut(0);
            else
            {
              // Trattamento a parte degli importi cho possono essere in Euro o Eurocent
              if (xvt_str_compare_ignoring_case(fi.class_name(), "VALUTA") == 0)
              {
                real val = str;
                if (file.importi_in_centesimi())
                {
                  val *= CENTO;
                  str = val.stringa(16, 0);
                }
                else
                  str = val.stringa(16, 2);
              }
              else  
                str.right_just(16);
            }
          } else
          if (type == "DT")
          {
            str.strip("-");
            str.right_just(16);
          }
        }
        else
        {
          if (fi.fields() > 0)
          {
            const TFieldref& fr = ((TForm_string&)fi).field(0);
            const int num = fr.file();
            const char* fn = fr.name();
            const TFieldtypes ft = cursor()->curr(num).type(fn);
            switch (ft)
            {
            case _boolfld:
              str = str.full() ? "1" : "0";
              str.right_just(16);
              break;
            case _datefld:
              if (str.len() == 10 && str[2] == '-' && str[5] == '-')
              {
                str.strip("-"); 
                str.right_just(16);
              }
              break;
            case _realfld:
              if (real::is_null(str))
                str.cut(0);
              else
              {
                // Trattamento a parte degli importi cho possono essere in Euro o Eurocent
                if (xvt_str_compare_ignoring_case(fi.class_name(), "VALUTA") == 0)
                {
                  real val = str;
                  if (file.importi_in_centesimi())
                    val *= CENTO;
                  str = val.string(16, 0);
                }
                else  
                  str.right_just(16);
              }
              break;            
            default:
              break;
            }
          }
        }
        
        if (str.not_empty())
        {
          const int vero_rigo = atoi(basecode.mid(2, 3)) - 1 + rigo;
          code.format("%c%c%03d%c%c%c", 
                      basecode[0], basecode[1], vero_rigo, 
                      basecode[5], basecode[6], basecode[7]);
          if (!rec.np_put(code, str))
          {
            file << rec;
            rec.azzera_campi_non_posizionali();
            rec.np_put(code, str);
          }
        }     
      }
    }
  }
}

bool TForm770::compatible(const TRectype& r1, const TRectype& r2)
{
  if (r1.empty() || r2.empty())
    return true;

  if (r1.get_long(QUC_CODDITTA) != r2.get_long(QUC_CODDITTA))
    return false;
  if (r1.get_char(QUC_TIPOA) != r2.get_char(QUC_TIPOA))
    return false;
  if (r1.get_long(QUC_CODANAGR) != r2.get_long(QUC_CODANAGR))
    return false;
  if (r1.get_char(QUC_CAUSALE) != r2.get_char(QUC_CAUSALE))
    return false;
  if (r1.get_int(QUC_TASSAZIONE) != r2.get_int(QUC_TASSAZIONE))
    return false;

  const real p1 = r1.get_real(QUC_PERC);
  const real p2 = r2.get_real(QUC_PERC);
  bool yes = (p1 == ZERO && p2 != ZERO) || (p1 == p2);
  return yes;
}

void TForm770::add_rec(TRectype& r1, const TRectype& r2)
{
  if (r1.empty())
    r1 = r2;
  else
  {
    for (int f = r1.items()-1; f >= 0; f--)
    {
      const char* name = r1.fieldname(f);
      if (r1.type(name) == _realfld)
      {
        real val = r1.get_real(name);
        val += r2.get_real(name);
        r1.put(name, val);
      }
    }
    r1.put(QUC_PERC, r2.get(QUC_PERC));
  }
}

long TForm770::raggruppa_c()
{
  TCursor& cur = *cursor();
  TRectype& rc = cur.curr();
  _records.destroy();
  for (cur = 0; cur.ok(); ++cur)
  {
    bool append = true;
    const int last = _records.items()-1;
    if (last >= 0)
    {
      TRectype& sum = (TRectype&)_records[last];
      if (compatible(sum, rc))
      {
        add_rec(sum, rc);
        append = false;
      }
    }
    if (append)
    {
      _records.add(rc);
      _positions.add_long(cur.pos()+1);
    }
  }                
 
  return _records.items();
}

int TForm770::first()
{
  TCursor& cur = *cursor();

  cur = 0;
  bool ok = cur.ok();
  
  if (cur.file().num() == LF_QUAC)
  {
    if (ok)
    {
      raggruppa_c();
      _index = 0;
      cur.curr() = (TRectype&)_records[0];
    }
  }

  return ok ? NOERR : _iseof;
}

int TForm770::next()
{
  TCursor& cur = *cursor();

  bool ok;
  if (cur.file().num() == LF_QUAC)
  {
    _index++;
    ok = _index < _records.items();
    if (ok)
    {
      cur = _positions.get_long(_index) - 1;
      cur.curr() = (TRectype&)_records[_index];
    }
  }
  else
  {
    ++cur;
    ok = cur.ok();
  }

  return ok ? NOERR : _iseof;
}

TRecnotype TForm770::trasfer(long codditta, TTrasferimento770& file, char rectype, int rpm)
{
  TCursor& cur = *cursor();
  
  // Filtra il cursore sulla ditta corrente
  TRectype region(cur.curr());
  region.zero();
  region.put(BSE_CODDITTA, codditta);
  cur.setregion(region, region);

  TString16 filter;
  switch (region.num())
  {
  case LF_QUADRO_ST: filter.format("QLAP=%d", ANNO_PAG); break;
  case LF_QUALA    : filter.format("ANNO=%d", ANNO_PAG); break;
  default: break;
  }
  cur.setfilter(filter);

  const TRecnotype items = cur.items();
  if (items > 0)         // Se c'e almeno un record ...
  {
    cur.freeze(true);    // Per efficienza congela il cursore

    // Inizializza record col primo modulo
    TRecord770 rec(rectype);
    int modulo = 1;
    int rigo = 1;
    
    rec.set(2, file.cod_fis_dic());
    rec.set(3, modulo);

    switch (rectype)
    {
    case 'E': rec.set(8, CF_PRODUTTORE); break;
    case 'H': rec.set(9, CF_PRODUTTORE); break;
    default : break;
    }

    TPrint_section& body = section('B', odd_page);

    int err = first();   // Deve sempre tornare NOERR
    for (; err == NOERR; err = next())
    {
      // Normalizza cognome e nome delle persone fisiche
      if (cur.relation()->log2ind(LF_ANAG) > 0)
      {
        TLocalisamfile& anag = cur.file(-216);  // Anagrafica percipiente
        const TString& ragsoc = anag.get(ANA_RAGSOC);
        const TString& nome = ragsoc.mid(30);
        if (nome.blank() && anag.get_char(ANA_TIPOA) == 'F')
        {
          TToken_string rs(ragsoc, ' '); rs.strip_double_spaces();
          const int pezzi = rs.items();

          int spc = 0;
          if (pezzi >= 4)
          {
            int spc = rs.find(' ', 0);
            spc = rs.find(' ', spc+1);
          }
          else
          {
            spc = rs.find(' ', 3);
            if (spc <= 5 && rs.starts_with("DE", true) && pezzi >= 3)
              spc = rs.find(' ', spc+1);
            if (spc < 0)
              spc = rs.find(' ', 0);
          }
          if (spc >= 2)
          {
            const TString80 nome = rs.mid(spc+1);
            rs.cut(spc); rs.overwrite(nome, 30, 20);
            anag.put(ANA_RAGSOC, rs);
            if (pezzi == 2) // Salvo solo quando sono sicuro!
              anag.rewrite();
          }
        }
      }

      transfer_section(body, rigo, rec, file);
      rigo++;
      if (rigo > rpm)
      {
        // Scrivi record se non vuoto
        if (rec.ha_campi_non_posizionali_compilati())
          file << rec;
        
        // Avanza al prossimo modulo ed azzera la riga
        rigo = 1;
        modulo++;
  
        rec.azzera_campi_non_posizionali();
        rec.set(3, modulo);
      }
    }

    // Ultimo record parzialmente compilato
    if (rec.ha_campi_non_posizionali_compilati())
      file << rec;
    
    cur.freeze(false);
  }

  return items;
}

TForm770::TForm770(const char* name)
        : TForm(name), _sortedcur(NULL)
{
  const char* key = NULL;
  
  switch (TForm::cursor()->file().num())
  {
  case LF_QUALA: key = "CODDITTA|216@->RAGSOC|TIPOA|CODANAGR"; break;
  default     : break;
  }
  if (key)
    _sortedcur = new TSorted_cursor(TForm::relation(), key);
}

TForm770::~TForm770()
{
  if (_sortedcur)
    delete _sortedcur;
}

class TCache770 : public TObject
{
  TArray _files;
  TAssoc_array _tables;

public:
  const TRectype& get(int num, const char* key);
  const TRectype& get(int num, long key);
  void destroy();
} _cache770;

///////////////////////////////////////////////////////////
// TCache770
///////////////////////////////////////////////////////////

const TRectype& TCache770::get(int num, const char* key)
{
  TRecord_cache* rc = (TRecord_cache*)_files.objptr(num);
  if (rc == NULL)
  {
    rc = new TRecord_cache(num);
    _files.add(rc, num);
  }
  return rc->get(key);
}

const TRectype& TCache770::get(int num, long key)
{
  TString16 str; str << key;
  return get(num, str);
}

void TCache770::destroy()
{
  _files.destroy();
  _tables.destroy();
}

///////////////////////////////////////////////////////////
// TTrasferimento770
///////////////////////////////////////////////////////////

const char* TTrasferimento770::default_name() const 
{ return "MOD77015"; }

bool TTrasferimento770::open(const char* path, char mode, int volume)
{
  CHECK(mode == 'r' || mode == 'w', "Invalid open mode");
  close();

  if (path && *path)
  {
    _name = path;
    _name.add(default_name());
    if (volume > 0)
      _name << '_' << volume;
  }
  if (_name.empty())
  {
    _name = default_name();
    if (volume > 0)
      _name << '_' << volume;
  }
  if (mode == 'r')
    _in_stream = new ifstream(_name, ios::in | ios::binary);
  else
    _out_stream = new ofstream(_name, ios::out | ios::binary);

  return true;
}

bool TTrasferimento770::close()
{
  if (_in_stream)
  {
    delete _in_stream;
    _in_stream = NULL;
  }
  if (_out_stream)
  {
    delete _out_stream;
    _out_stream = NULL;
  }
  return true;
}

bool TTrasferimento770::write(const TRecord770& rec)
{
  bool ok = _out_stream != NULL;
  if (ok)
    (*_out_stream) << rec;
  return ok;
}

bool TTrasferimento770::read(TRecord770& rec)
{
  bool ok = _in_stream != NULL && !_in_stream->eof(); 
  if (ok)
  {
    (*_in_stream) >> rec;
    ok = rec.valid();
  }
  return ok;
}

const TString& TTrasferimento770::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 = _cache770.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 = _cache770.get(LF_ATTIV, key);
  const TString& codateco = attiv.get(ATT_CODATECO);
  if (codateco.full())
    _codatt_dic = codateco;
  else
    error_box(TR("Non esiste il codice attivitą ATECO"));

  const TAnagrafica dich(LF_ANAG, _tipoa_dic, _codan_dic);
  if (!dich.ok())
  {
    error_box(TR("Non esiste l'anagrafica del dichiarante"));
	  return EMPTY_STRING;
  }
  _codfis_dic = dich.codice_fiscale();   //  Codice fiscale del dichiarante
  
  return _codfis_dic;
}

TRecnotype TTrasferimento770::conta_certificazioni() const
{
  TString query;
  query.format("USE %d SELECT ANNO=%d\nFROM CODDITTA=%ld\nTO CODDITTA=%ld",
               LF_QUALA, ANNO_PAG,_cod_ditta, _cod_ditta);
  TISAM_recordset recset(query);
  const TRecnotype nc = recset.items();
  return nc;
}

bool TTrasferimento770::casella_prospetto_st() const
{
  // Il quadro ST e' il "vecchio" quadro L
  TString query;
  query.format("USE %d\nSELECT QLAP=%d\nFROM CODDITTA=%ld\nTO CODDITTA=%ld",
               LF_QUADRO_ST, ANNO_PAG, _cod_ditta, _cod_ditta);
  TISAM_recordset recset(query);
  const TRecnotype nr = recset.items();
  return nr > 0;
}

bool TTrasferimento770::casella_prospetto_sx() const
{
  // Il quadro SX sono le ritenute versate in eccesso
  TString query;
  query.format("USE %d\nSELECT QLAP=%d\nFROM CODDITTA=%ld\nTO CODDITTA=%ld",
               LF_QUADRO_ST, ANNO_PAG, _cod_ditta, _cod_ditta);
  TISAM_recordset recset(query);
  bool found = false;
  for (bool ok = recset.move_first(); ok && !found; ok = recset.move_next())
  {
    const real verecc = recset.get("QLRITVEREC").as_real();
    found = !verecc.is_zero();
  }
  return found;
}


bool TTrasferimento770::append_record_b()
{
  bool ok = false;
  if (save_headers())
  {
    TRecord770 rec('B');       // Compila record di testata B
    rec.set(2, cod_fis_dic());
    rec.set(3, 1);             // Modulo (deve essere sempre 1)
    rec.set(7, CF_PRODUTTORE); // CF del produttore Sirio

    const TAnagrafica dich(LF_ANAG, _tipoa_dic, _codan_dic);
    if (dich.fisica())
    {
      rec.set(13, dich.cognome());
      rec.set(14, dich.nome());
      rec.set(23, dich.comune_nascita());
      rec.set(24, dich.provincia_nascita());
      rec.set(25, dich.data_nascita());
      rec.set(26, dich.sesso());
      rec.set(27, dich.comune_residenza());
      rec.set(28, dich.provincia_residenza());
      rec.set(29, dich.CAP_residenza());
      if (!dich.estero())
        rec.set(30, dich.codice_comune_residenza());
      rec.set(31, dich.indirizzo_residenza());
    }

    rec.set(19, _codatt_dic);
  
    if (dich.giuridica())
    {
      rec.set(15, dich.ragione_sociale());

      const TRectype& rec_anagiu = _cache770.get(LF_ANAGGIU, _codan_dic);
      rec.set(33, rec_anagiu.get(ANG_NATGIU));
      
      rec.set(35, dich.comune_residenza());
      rec.set(36, dich.provincia_residenza());
      rec.set(37, dich.CAP_residenza());
      rec.set(38, dich.codice_comune_residenza());
      rec.set(39, dich.indirizzo_residenza());

      rec.set(46, rec_anagiu.get(ANG_STATOSOC));
      rec.set(47, rec_anagiu.get(ANG_SITSOC));
    }

    rec.set(75, 1); // Redazione della dichiarazione (sezione I)
    rec.set(76, 0); // Comunicazioni relative a certificazioni lavoro dipendente
    const int autonomi = conta_certificazioni();
    const bool prosp_st = casella_prospetto_st();
    const bool prosp_sx = casella_prospetto_sx();
    rec.set(77, autonomi);
    rec.set(78, autonomi > 0); // casella prospetto SS
    rec.set(79, prosp_st);     // casella prospetto ST
    rec.set(80, false);        // casella prospetto SV
    rec.set(81, prosp_sx);     // casella prospetto SX
    rec.set(82, false);        // casella prospetto SY
    
    rec.set(94, true);         // Firma del dichiarante

    rec.set(116, 0);           // situazioni particolari: vale sempre 0

    const TRectype& rec_nditte = _cache770.get(LF_NDITTE, _cod_ditta);
    const TAnagrafica rec_rap(LF_ANAG, 'F', rec_nditte.get_long(NDT_RAPPR));
    if (rec_rap.ok())
    {
      rec.set(126, rec_rap.codice_fiscale());
      rec.set(127, rec_nditte.get(NDT_CARRAPP));
      rec.set(131, rec_rap.cognome());
      rec.set(132, rec_rap.nome());
      rec.set(133, rec_rap.sesso());
      rec.set(134, rec_rap.data_nascita());
      rec.set(135, rec_rap.comune_nascita());
      rec.set(136, rec_rap.provincia_nascita());

      if (rec_rap.comune_nascita().blank())
        cantread_box("dati nascita legale rappresentante");
    }
    else
      cantread_box("dati del legale rappresentante");

    // Ignoro la parte "estera"

    ok = write(rec);
  }
  return ok;
}

// Determina a partire dal codice quadro (LA o ST) il tipo record (H o E) ed il numero di record per modulo (1 o 12)
// Ritorna il form da cui prelevare i codici (come AUXXX010) da inserire nei tracciati
TForm770& TTrasferimento770::form(const char* quadro, char& tiporec, int& rpm)
{
  CHECK(quadro && *quadro != '\0' && quadro[1] != '\0', "Codice quadro non valido");

  const char* name = NULL;
  switch(quadro[1])
  {
  case 'A': name = "77qla"; tiporec = 'H'; rpm = 1; break;
  case 'T': name = "77qst"; tiporec = 'E'; rpm = 12; break;
  default : name = NULL; break;
  }

  TForm770* frm = (TForm770*)_form.objptr(name);
  if (frm == NULL)
  {
    frm = new TForm770(name);
    _form.add(name, frm);
  }

  return *frm;
}

long TTrasferimento770::append_quadro(const char* quadro, long codditta, TProgress_monitor& pi)
{
  TString str;
  str << TR("Trasferimento quadro ") << quadro << TR(" ditta ") << codditta;
  pi.set_text(str);
  
  char tipo;
  int rpm;
  TForm770& frm = form(quadro, tipo, rpm);
  long items = frm.trasfer(codditta, *this, tipo, rpm);
  return items;
}

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;
}

void TTrasferimento770::riepiloga_ss(const TRecord770& rec, TArray& riep_ss) const
{
  TString8 code;
  real val;
  for (int i = 0; rec.np_get_real(i, code, val); i++) if (code.starts_with("AU") && code[5] != 'A' && !val.is_zero())
  {   
    const TString& key = code.right(3);
    const int num = atoi(key);
    if (num >= 9 && num <= 17) 
    {
      real& r = real_at(riep_ss, num-9);  // AU_9 -AU_54 -> SS003001
      r += val;                           // AU_10-AU_55 -> SS003002
    } else
    if (num >= 54 && num <= 62) 
    {
      real& r = real_at(riep_ss, num-54);
      r -= val;
    }
  }
}

void TTrasferimento770::riepiloga_sx(const TRecord770& rec, TArray& riep_sx) const
{
  TString8 code;
  real val;
  for (int i = 0; rec.np_get_real(i, code, val); i++) if (code.starts_with("ST") && !val.is_zero())
  {   
    const int rig = atoi(code.mid(2,3));
    const int col = atoi(code.mid(5,3));
    if (rig >= 2 && rig <= 25 && col >= 4 && col <= 5) 
    {
      real& r = real_at(riep_sx, 5); // SX004005
      r += val;
    }
  }
}


bool TTrasferimento770::split(const char* path)
{
  close();

  const long records = fsize(_name) / TOTAL_SIZE;
  TRecnotype totale[26]; memset(totale, 0, sizeof(totale));

  TRecord770 rec;

  unsigned long disk_size = 15*1024*1024;   // Max 15 Mb per fornitura
  const bool magnetic = ::xvt_fsys_is_floppy_drive(path)!=0;
  if (magnetic)
  {
    if (!yesno_box(FR("Inserire il primo disco del trasferimento nell'unitą %s\n"
                   "Tutti i dischi devono essere vuoti ed avere la stesso formato.\n"
                   "Si desidera iniziare il trasferimento?"), path))
      return false;

    disk_size = ::xvt_fsys_get_disk_size(path, 'b');
  }
  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"));
  
  // Read from start
  open("", 'r');
  
  for (int volume = 1; volume <= volumes; volume++)
  {
    if (magnetic && volume > 1)
    {
      if (!yesno_box(FR("Inserire il disco %d di %d:\nSi desidera proseguire il trasferimento?"),
                     volume, volumes))
        break;
    }

    // Specifica volume solo se necessario
    const int v = (volumes > 1 && !magnetic) ? volume : 0; 
    TTrasferimento770 outfile(path, 'w', v);
  
    if (_save_headers)
    {      
      rec.tipo_record('A');      // Compila record di testata A
      rec.set(3, "77S16");       // Codice fornitura
      rec.set(4, 1);             // Tipo fornitore 01 = Soggetto che invia la propria dichiarazione
      rec.set(5, cod_fis_dic()); // Codice fiscale del fornitore
      if (volumes > 1)
      {
        rec.set(7, volume);
        rec.set(8, volumes);
      }
      else
      {
        rec.set(7, 0);
        rec.set(8, 0);
      }
  
      outfile << rec;  // Scrive record testata
    }
    
    long written = 0;
  
    TArray riep_ss, riep_sx;
    
    if (records > 0)
    {
      while (read(rec))
      {
        pi.add_status();
  
        const char tipo_rec = rec.tipo_record();
        if (tipo_rec <= 'A' || tipo_rec == 'F' || tipo_rec == 'J' || tipo_rec >= 'Z')
          continue;

        if (_save_headers && tipo_rec > 'E' && riep_sx.items() > 0)
        {
          TRecord770 recf('F');
          recf.set(2, cod_fis_dic());
          recf.set(3, 1);
          recf.set(8, CF_PRODUTTORE);
          FOR_EACH_ARRAY_ITEM(riep_sx, i, obj)
          {
            const real* val = (const real*)obj;
            if (val != NULL)
            {
              TString8 code;
              code.format("SX004%03d", i);
              recf.np_put(code, *val);
            }
          }
          outfile << recf;
          totale['F'-'A']++; // Praticamente vale sempre 1
          riep_sx.destroy(); // La prossima volta non deve salvare nulla
        }
  
        outfile << rec;
        written++;
  
        // Tengo traccia degli eventuali riepiloghi
        if (_save_headers)
        {
          totale[tipo_rec - 'A']++;
          switch (tipo_rec)
          {
          case 'E': riepiloga_sx(rec, riep_sx); break;
          case 'H': riepiloga_ss(rec, riep_ss); break;
          default : break;
          }
        }
  
        if (written >= records_per_disk)
          break;
      }
    }  

    if (_save_headers)
    {
      // Compila record di riepilogo SS
      if (!riep_ss.empty())
      {
        rec.tipo_record('J');
        rec.set(2, cod_fis_dic());
        rec.set(3, 1);
        rec.set(8, CF_PRODUTTORE);
        FOR_EACH_ARRAY_ITEM(riep_ss, i, obj)
        {
          const real* val = (const real*)obj;
          if (val != NULL && !val->is_zero())
          {
            TString8 code;
            code.format("SS003%03d", i+1);   // i=0 -> SS0003001 -> AUXXX027-AUXXX047
            rec.np_put(code, *val);
          }
        }
        outfile << rec;
        totale['J'-'A']++; // Praticamente vale sempre 1
      }

      // Compila record di coda
      rec.tipo_record('Z');
      rec.set(3, totale['B'-'A']);  // Totale B
      rec.set(4, totale['D'-'A']);  // Totale D
      rec.set(5, totale['E'-'A']);  // Totale E
      rec.set(6, totale['F'-'A']);  // Totale F
      rec.set(7, totale['G'-'A']);  // Totale G
      rec.set(8, totale['H'-'A']);  // Totale H
      rec.set(9, totale['I'-'A']);  // Totale I
      rec.set(10,totale['J'-'A']);  // Totale J
  
      // Scrive record di coda
      outfile << rec;
    }
  }  
  return true;
}

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

TTrasferimento770::TTrasferimento770(const char* path, char  mode, int volume)
                 : _in_stream(NULL), _out_stream(NULL), _save_headers(false), _centesimi(false)
{
  open(path, mode, volume);
}

TTrasferimento770::~TTrasferimento770()
{
  close();
}

///////////////////////////////////////////////////////////
// main
///////////////////////////////////////////////////////////

class TTransfer770_msk : public TAutomask
{
protected:
  virtual bool on_field_event(TOperable_field& of, TField_event fe, long jolly);

public:         
  TTransfer770_msk();
  ~TTransfer770_msk();
};

bool TTransfer770_msk::on_field_event(TOperable_field& of, TField_event fe, long jolly)
{
  switch (of.dlg())
  {
  case F_PATH:
    if (fe == fe_modify || fe == fe_close)
    {
      TFilename name = of.get();
      if (!name.exist())
        return cantread_box(name);
    }
    break;
  default:
    break;
  }
  return true;
}

TTransfer770_msk::TTransfer770_msk() : TAutomask("777100a") 
{ 
  set(F_ANNOPAG, ANNO_PAG);
  set(F_ANNODIC, ANNO_PAG+1);
  set(F_NOHEADERS,ini_get_bool(CONFIG_STUDIO, "77", "SaveDataOnly", false));
  set(F_PATH,   ini_get_string(CONFIG_STUDIO, "77", "SavePath"));
  long ditta1 = ini_get_int   (CONFIG_STUDIO, "77", "SaveFirm1", 0);
  long ditta2 = ini_get_int   (CONFIG_STUDIO, "77", "SaveFirm2", 0);
  if (ditta1 <= 0 || ditta2 <= 0)
  {
    TPointer_array d;
    prefix().firms(d);
    if (!d.empty())
    {
      if (ditta1 <= 0) 
        ditta1 = d.get_long(0);
      if (ditta2 < ditta1) 
        ditta2 = d.get_long(d.last());
    }
  }
  set(F_DADITTA, ditta1);
  set(F_ADITTA,  ditta2);
}

TTransfer770_msk::~TTransfer770_msk()
{
  ini_set_bool  (CONFIG_STUDIO, "77", "SaveDataOnly",get_bool(F_NOHEADERS));
  ini_set_string(CONFIG_STUDIO, "77", "SavePath",    get(F_PATH));
  ini_set_int   (CONFIG_STUDIO, "77", "SaveFirm1",   get_long(F_DADITTA));
  ini_set_int   (CONFIG_STUDIO, "77", "SaveFirm2",   get_long(F_ADITTA));
}

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

void TTransfer770_app::main_loop()
{
  TTransfer770_msk m;

  while (m.run() == K_ENTER)
  {
    TFilename tmp; tmp.tempdir();
    TTrasferimento770 t(tmp, 'w');
    t.save_headers(!m.get_bool(F_NOHEADERS));
    t.set_cent_mode(m.get_bool(F_CENT));

    TRelation rel_base(LF_BASE);
    TRectype da_rec(LF_BASE), a_rec(LF_BASE);
    da_rec.put(BSE_CODDITTA, m.get(F_DADITTA));
    a_rec.put(BSE_CODDITTA, m.get(F_ADITTA));

    TString16 filter;
/*
    filter << '(' << BSE_ANNODIC << '=' << m.get(F_ANNO) << ")||"
           << '(' << BSE_ANNODIC << "=0)"; 
*/
    TCursor cur_base(&rel_base, filter, 1, &da_rec, &a_rec);
    const TRecnotype items = cur_base.items();
    cur_base.freeze();
    
    if (items > 0)
    {
      TProgress_monitor pi(items, TR("Generazione file di trasferimento"));
      for (cur_base = 0; cur_base.ok(); ++cur_base)
      {
        const TRectype& base = cur_base.curr();
        const long codditta = base.get_long(BSE_CODDITTA);
        t.read_codfis_dic(base);

        t.append_record_b();
        t.append_quadro("ST", codditta, pi);
        t.append_quadro("LA", codditta, pi);
        if (!pi.add_status())
          break;
      }
    }

    tmp = m.get(F_PATH);
    if (t.split(tmp))
    {
      tmp.add(t.default_name());
      TString msg; msg << TR("E' stato generato il file ") << tmp;
      xvt_dm_popup_message(msg);
    }
    else
    {
      tmp.add(t.default_name());
      cantwrite_box(tmp);
    }
    t.remove();
  }
}

int m777100(int argc, char* argv[])
{
  TTransfer770_app app;
  app.run(argc, argv, TR("Invio 770"));
  return 0;
}