#include <applicat.h>
#include <automask.h>
#include <progind.h>
#include <reputils.h>

#include "../mg/movmag.h"
#include "../mg/rmovmag.h"

#include "halib.h"
#include "ha1300a.h"

#define UPLOAD_FILE "upload.d"


//funzione di ordinamento del file di upload una volta caricato in memoria
int ordina_upload(const TObject** o1, const TObject** o2)
{
  const TString& s1 = *(TString*)*o1;
  const TString& s2 = *(TString*)*o2;

  if (s1[1] == 'F' && s2[1] == 'F')
  {
    TToken_string k[2];
    for (int i = 0; i < 2; i++)
    {
      const TString& rec = i == 0 ? s1 : s2;
      TToken_string& key = k[i];
      if (rec[0] == 'T')
      {
        key.add(rec.mid(14,2));   //anno
        key.add(rec.mid(16,1));   //tipodoc
        key.add(rec.mid(5,5));    //numdoc
      }
      else
      {
        key.add(rec.mid(14,2));   //anno
        key.add(rec.mid(28,1));   //tipodoc
        key.add(rec.mid(5,5));    //numdoc
        key.add(rec.mid(29,5));   //codart
      }
    }
    return k[0].compare(k[1]);
  }
  else
  {
    if (s1[1] == 'F')
      return +1;
    if (s2[1] == 'F')
      return -1;
  }

  return s1.compare(s2);
}


//------------------------------------------------------------
//  Hardy_upload_recordset: serve per l'INPUT
//------------------------------------------------------------
class THardy_upload_recordset : public THardy_recordset
{
protected:
  virtual TRecnotype new_rec(const char* trc);

public:
  THardy_upload_recordset(const TFilename& filename);
};

/////////////////////////////////////////////////////////////
//	Recordset specifici per i dati da trasferire INPUT
/////////////////////////////////////////////////////////////

TRecnotype THardy_upload_recordset::new_rec(const char* trc)
{
  if (trc && *trc > ' ')
  {
    TString rec; rec << trc << "\r\n";
    return TText_recordset::new_rec(rec);
  }
  return -1;
}

//questo invece è il metodo magico che vale per il caricamento da file esterno
THardy_upload_recordset::THardy_upload_recordset(const TFilename& filename)
  : THardy_recordset(256)
{
  TFilename cazzone;
  //as400 con lunghezza 256 e chiave lunga 2 (a partire dall'inizio): è il tipo record
  parse_query("AS400(256,2)", cazzone);

  //Tipo record SU
  //--------------
  add_trc_field("SU", "TipoRecord",       T_X,    1,  2);   //x
  add_trc_field("SU", "CodiceTerminale",  T_N,    3,  3);   //x
  add_trc_field("SU", AGE_CODAGE,         T_N,    6,  3);   //x
  add_trc_field("SU", "NonUsato",         T_X,    9,  6);
  add_trc_field("SU", "Targa",            T_X,    15, 8);
  add_trc_field("SU", "nDDT",             T_N,    23, 5);
  add_trc_field("SU", "nFATT",            T_N,    28, 5);
  add_trc_field("SU", "nBOLLA",           T_N,    33, 5);
  add_trc_field("SU", AGE_RAGSOC,         T_X,    38, 30);  //x

  //Tipo record TF
  //--------------
  add_trc_field("TF", "TipoRecord",       T_X,    1,  2);   //x
  add_trc_field("TF", "CodiceTerminale",  T_N,    3,  3);   //x
  add_trc_field("TF", DOC_NDOC,           T_N,    6,  5);   //x
  add_trc_field("TF", DOC_DATADOC,        T_X,    11, 6);   //x
  add_trc_field("TF", DOC_TIPODOC,        T_X,    17, 1);   //x
  add_trc_field("TF", DOC_CODCF,          T_X,    18, 6);   //x
  add_trc_field("TF", DOC_CODCFFATT,      T_X,    24, 6);   //x
  add_trc_field("TF", "ImponibileLordo",  T_Nv2N, 30, 8);   // campi seguenti da righe doc
  add_trc_field("TF", "ScontoFattura",    T_2Nv2N,38, 4);
  add_trc_field("TF", "ImponibileDoc",    T_Nv2N, 42, 8);
  add_trc_field("TF", "TotaleDoc",        T_Nv2N, 50, 8);
  add_trc_field("TF", "ScontoTotale",     T_Nv2N, 58, 8);
  add_trc_field("TF", "ImponibileOmaggi", T_Nv2N, 66, 8);
  add_trc_field("TF", "ImponibileSost",   T_Nv2N, 74, 8);
  add_trc_field("TF", "Incasso",          T_Nv2N, 82, 8);   //forse IMPPAGATO ?
  add_trc_field("TF", DOC_CODPAG,         T_X,    90, 2);   //x
  add_trc_field("TF", DOC_DATAPART,       T_X,    92, 6);   //x
  add_trc_field("TF", "Iva1",             T_N,    98, 2);   //anche questi da righe doc
  add_trc_field("TF", "Imponibile1",      T_Nv2N, 100,8);
  add_trc_field("TF", "Imposta1",         T_Nv2N, 108,7);
  add_trc_field("TF", "Iva2",             T_N,    115,2);
  add_trc_field("TF", "Imponibile2",      T_Nv2N, 117,8);
  add_trc_field("TF", "Imposta2",         T_Nv2N, 125,7);
  add_trc_field("TF", "Iva3",             T_N,    132,2);
  add_trc_field("TF", "Imponibile3",      T_Nv2N, 134,8);
  add_trc_field("TF", "Imposta3",         T_Nv2N, 142,7);
  add_trc_field("TF", "Iva4",             T_N,    149,2);
  add_trc_field("TF", "Imponibile4",      T_Nv2N, 151,8);
  add_trc_field("TF", "Imposta4",         T_Nv2N, 159,7);
  add_trc_field("TF", "CodcliGiro3",      T_X,    166,6);
  add_trc_field("TF", "IvaOmag1",         T_N,    172,2);
  add_trc_field("TF", "ImponibileOmag1",  T_Nv2N, 174,6);
  add_trc_field("TF", "ImpostaOmag1",     T_Nv2N, 180,5);
  add_trc_field("TF", "IvaOmag2",         T_N,    185,2);
  add_trc_field("TF", "ImponibileOmag2",  T_Nv2N, 187,6);
  add_trc_field("TF", "ImpostaOmag2",     T_Nv2N, 193,5);
  add_trc_field("TF", "DataEmissione",    T_X,    198,6);
  add_trc_field("TF", "PagamentoCarta",   T_X,    204,1);
 
  //Tipo record RF
  //--------------
  add_trc_field("RF", "TipoRecord",       T_X,    1,  2);   //x
  add_trc_field("RF", "CodiceTerminale",  T_N,    3,  3);   //x
  add_trc_field("RF", RDOC_NDOC,          T_N,    6,  5);   //x
  add_trc_field("RF", DOC_DATADOC,        T_X,    11, 6);   //x testata
  add_trc_field("RF", DOC_CODCF,          T_X,    17, 6);   //x testata
  add_trc_field("RF", DOC_CODCFFATT,      T_X,    23, 6);   //x testata
  add_trc_field("RF", DOC_TIPODOC,        T_X,    29, 1);   //x testata
  add_trc_field("RF", RDOC_CODART,        T_X,    30, 5);   //x
  add_trc_field("RF", "TipoCessione",     T_X,    35, 1);
  add_trc_field("RF", "Qta[int]",         T_N,    36, 5);   //x
  add_trc_field("RF", "Qta[dec]",         T_N,    41, 2);   //x
  add_trc_field("RF", "Sconto1",          T_2Nv2N,43, 4);
  add_trc_field("RF", "Sconto2",          T_2Nv2N,47, 4);
  add_trc_field("RF", "Sconto3",          T_2Nv2N,51, 4);
  add_trc_field("RF", "ScontoLibero",     T_2Nv2N,55, 4);
  add_trc_field("RF", RDOC_PREZZO,        T_Nv3N, 59, 7); //x forse PREZZOL ?
  add_trc_field("RF", "TotaleRiga",       T_Nv3N, 66, 8);
  add_trc_field("RF", "TotaleSconto",     T_Nv3N, 74, 8);
  add_trc_field("RF", "AliquotaIva",      T_N,    82, 2); //noi abbiamo il codice
  add_trc_field("RF", RDOC_UMQTA,         T_X,    84, 2); //x
  add_trc_field("RF", "PrezzoScontato",   T_Nv3N, 86, 7);
  add_trc_field("RF", "Fascia",           T_X,    93, 1);
  add_trc_field("RF", "ScontoFascia",     T_2N,   94, 2);
  add_trc_field("RF", "NonUsato",         T_N,    96, 2);
  add_trc_field("RF", "CodcliGiro3",      T_X,    98, 6);
  add_trc_field("RF", "CodiceLotto",      T_X,    104,10);  //noi lo leghiamo all'articolo

  //Tipo record SI
  //--------------
  add_trc_field("SI", "TipoRecord",       T_X,    1,  2);   //x
  add_trc_field("SI", "CodiceTerminale",  T_N,    3,  3);   //x
  add_trc_field("SI", "CodiceCliente",    T_X,    6,  6);
  add_trc_field("SI", "NumeroFattura",    T_X,    12, 12);
  add_trc_field("SI", "DataFattura",      T_X,    24, 6);
  add_trc_field("SI", "NonUsato",         T_N,    30, 9);
  add_trc_field("SI", "ImportoIncassato", T_Nv2N, 39, 9);
  add_trc_field("SI", "DataIncasso",      T_X,    48, 6);
  add_trc_field("SI", "Partita",          T_X,    54, 15);
  add_trc_field("SI", "TipoDocumento",    T_X,    69, 1);
  add_trc_field("SI", "DataEmissione",    T_X,    70, 6);
  add_trc_field("SI", "PagamentoCarta",   T_X,    76, 1);

  //Tipo record BR
  //--------------
  add_trc_field("BR", "TipoRecord",       T_X,    1,  2);   //x
  add_trc_field("BR", "CodiceTerminale",  T_N,    3,  3);   //x
  add_trc_field("BR", "NumeroRiga",       T_N,    6,  3);
  add_trc_field("BR", "NumeroDoc",        T_N,    9,  5);
  add_trc_field("BR", "DataMov",          T_X,    14, 6);
  add_trc_field("BR", "CodiceArticolo",   T_X,    20, 5);
  add_trc_field("BR", "Qta[int]",         T_N,    25, 5);
  add_trc_field("BR", "Qta[dec]",         T_N,    30, 2);
  add_trc_field("BR", "Mittente",         T_N,    32, 3);
  add_trc_field("BR", "Destinatario",     T_N,    35, 3);
  add_trc_field("BR", "CausaleMov",       T_N,    38, 2);
  add_trc_field("BR", "CodiceLotto",      T_X,    40, 10);

  //Tipo record VC
  //--------------
  add_trc_field("VC", "TipoRecord",       T_X,    1,  2);   //x
  add_trc_field("VC", "CodiceTerminale",  T_N,    3,  3);   //x
  add_trc_field("VC", CLI_CODCF,          T_X,    6,  6);   //x
  add_trc_field("VC", CLI_RAGSOC,         T_X,    12, 34);  //x
  add_trc_field("VC", CLI_INDCF,          T_X,    46, 34);  //x
  add_trc_field("VC", "Localita",         T_X,    80, 20);  //x attenzione che potrebbe essere il com_dencom
  add_trc_field("VC", CLI_CAPCF,          T_X,    100, 5);  //x
  add_trc_field("VC", "Provincia",        T_X,    105, 2);  //x da questo e da dencom ricaviamo il codcom
  add_trc_field("VC", CLI_PAIV,           T_X,    107, 16); //x
  add_trc_field("VC", CLI_CODPAG,         T_X,    123, 1);  //x
  add_trc_field("VC", "CodiceListino",    T_X,    124, 3);
  add_trc_field("VC", "TipoDocumento",    T_X,    127, 1);
  add_trc_field("VC", CLI_COFI,           T_X,    128, 16); //x


  //Tipo record RC
  //--------------
  add_trc_field("RC", "TipoRecord",       T_X,    1,  2);   //x
  add_trc_field("RC", "CodiceTerminale",  T_N,    3,  3);   //x
  add_trc_field("RC", "CodiceArticolo",   T_X,    6,  5);   //x
  add_trc_field("RC", "Quantita",         T_Nv2N, 11, 7);   //x
  add_trc_field("RC", "DataCarico",       T_X,    18, 6);   //x

  TText_recordset::load_file(filename);
}


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

public:
  TUpload2Campo_mask();
};

bool TUpload2Campo_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  return true;
}

TUpload2Campo_mask::TUpload2Campo_mask() : TAutomask ("ha1300a")
{
  TConfig config(CONFIG_DITTA, "ha");
  const TString& path = config.get("InputPath");
  set(F_PATH, path);
}

///////////////////////////////////////
// TSkeleton_application
///////////////////////////////////////
class TUpload2Campo : public TSkeleton_application
{
  TFilename _intput_dir;
  bool _can_write;

protected:
  //metodi di basso livello
  const TString& check_agente(TString& codice_terminale, TLog_report& log);
  const TString& check_articolo(TString& codart, TLog_report& log);
  void check_magazzino(const TString& codmag_age, TLog_report& log);
  void check_causale(TString& codcaus, TLog_report& log);

    //metodi di alto livello
  void elabora_SU(THardy_upload_recordset& recset, TLog_report& log);
  void elabora_BR(THardy_upload_recordset& recset, TLog_report& log);
  void elabora_VC(THardy_upload_recordset& recset, TLog_report& log);
  void elabora_TF(THardy_upload_recordset& recset, TLog_report& log);
  void elabora_SI(THardy_upload_recordset& recset, TLog_report& log);
  void elabora_RC(THardy_upload_recordset& recset, TLog_report& log);

  void elabora(const TMask& mask);

public:
  virtual void main_loop();
  virtual bool create();
};

//metodo che controlla se il terminale corrisponde ad un agente registrato e restituisce l'agente
const TString& TUpload2Campo::check_agente(TString& codice_terminale, TLog_report& log)
{
  codice_terminale.right_just(3, '0');
  TString8 codice_agente = codice_terminale;
  codice_agente.right_just(5, '0');

  const TRectype& rec_age = cache().get(LF_AGENTI, codice_agente);
  const TString& codage_campo = rec_age.get(AGE_CODAGE);

  if (codage_campo != codice_agente)
  {
    _can_write = false;
    TString msg;
    msg << "Codice agente " << codice_agente << " da terminale: sconosciuto";
    log.log(2, msg);
  }
  return codage_campo;
}


//metodo che controlla che l'articolo esista su Campo
const TString& TUpload2Campo::check_articolo(TString& codart, TLog_report& log)
{
  codart.trim();
  const TRectype& rec_anamag = cache().get(LF_ANAMAG, codart);
  const TString& articolo_campo = rec_anamag.get(ANAMAG_CODART);
  if (articolo_campo != codart)
  {
    _can_write = false;
    TString msg;
    msg << "Codice articolo " << codart << " sconosciuto su Campo";
    log.log(2, msg);
  }
  return rec_anamag.get(ANAMAG_DESCR);
}


void TUpload2Campo::check_magazzino(const TString& codmag_age, TLog_report& log)
{
  const TString& codmag_campo = cache().get("MAG", codmag_age, "CODTAB");
  if (codmag_campo != codmag_age)
  {
    _can_write = false;
    TString msg;
    msg << "Codice magazzino " << codmag_age << " sconosciuto su Campo";
    log.log(2, msg);
  }
}

void TUpload2Campo::elabora_SU(THardy_upload_recordset& recset, TLog_report& log)
{
  const TString& cod_term = recset.get("CodiceTerminale").as_string();
  const TString& cod_age = recset.get(AGE_CODAGE).as_string();
  const TString& descr_age = recset.get(AGE_RAGSOC).as_string();
  TString msg;
  msg << "Scartati dati agente " << cod_term << " " << descr_age;
  log.log(0, msg);
}

void TUpload2Campo::elabora_VC(THardy_upload_recordset& recset, TLog_report& log)
{
  const TString& cod_term = recset.get("CodiceTerminale").as_string();
  const TString& codcf = recset.get(CLI_CODCF).as_string();
  const TString& ragsoc = recset.get(CLI_RAGSOC).as_string();
  TString msg;
  msg << "Scartato nuovo cliente. Terminale: " << cod_term << " CodCli: " << codcf << " Ragsoc: " << ragsoc;
  log.log(0, msg);
}


void TUpload2Campo::elabora_SI(THardy_upload_recordset& recset, TLog_report& log)
{
}


void TUpload2Campo::elabora_BR(THardy_upload_recordset& recset, TLog_report& log)
{
  //dati dal recordset di upload
  TString4 codice_terminale = recset.get("CodiceTerminale").as_string();
  const TString& codice_agente = check_agente(codice_terminale, log);
  const TString8 cod_magazzino = cache().get(LF_AGENTI, codice_agente, AGE_CODMAG);
  check_magazzino(cod_magazzino, log);

  const long curr_movmag = recset.get("NumeroDoc").as_int();
  const TString& str_data_mov = recset.get("DataMov").as_string();
  const TDate data_mov = upload_format_date6(str_data_mov);
  const int anno = data_mov.year();
  TString descr;
  descr << "Agente: " << codice_terminale;

  //1) crea la testata
  //movimento di magazzino da riempire
  TMov_mag movmag;

  //const long numreg = atol(movmag.get_next_key());
  //movmag.put(MOVMAG_NUMREG, numreg);
  movmag.put(MOVMAG_ANNOES, anno);
  movmag.put(MOVMAG_DATAREG, data_mov);
  movmag.put(MOVMAG_DATACOMP, data_mov);
  movmag.put(MOVMAG_EXNUMDOC, curr_movmag);
  movmag.put(MOVMAG_EXDATADOC, data_mov);
  movmag.put(MOVMAG_DESCR, descr);

  //la causale va trascodificata con l'apposita tabella &CAU
  const TString& caus_term = recset.get("CausaleMov").as_string();
  const TString& codcaus = cache().get("&CAU", caus_term, "S7");
  if (codcaus.empty())
  {
    _can_write = false;
    TString msg;
    msg << "Causale movimento " << caus_term << " non codificata";
    log.log(2, msg);
  }
  movmag.put(MOVMAG_CODCAUS, codcaus);

  bool go_on = true;
  // righe movimento di magazzino
  //scansione delle righe documento su record BR
  while (go_on)
  {
    //2) crea le righe (legge tutti i record di tipo BR successivi finchè hanno lo stesso numero documento!)

    //agginunge una nuova riga (solo merce, per quanto ne sappiamo)
    TRectype& rmovmag = movmag.new_row();
    rmovmag.put(RMOVMAG_CODMAG, cod_magazzino);
    TString8 codart = recset.get("CodiceArticolo").as_string();
    check_articolo(codart, log);
    rmovmag.put(RMOVMAG_CODART, codart);
    TToken_string key_umart;
    key_umart.add(codart);
    key_umart.add(1);
    const TString& um = cache().get(LF_UMART, key_umart, UMART_UM);
    rmovmag.put(RMOVMAG_UM, um);
    const TString& lotto = recset.get("CodiceLotto").as_string();
    rmovmag.put(RMOVMAG_LIVGIAC, lotto);
    
    real qta = recset.get("Qta[int]").as_real();
    qta += recset.get("Qta[dec]").as_real() / CENTO;
    rmovmag.put(RMOVMAG_QUANT, qta);

    //quando non trova un BR con lo stesso numero di movimento significa che le righe sono finite!
    go_on = recset.move_next();

    if (go_on && (recset.get("TipoRecord").as_string() != "BR" || curr_movmag != recset.get("NumeroDoc").as_int()))
    {
      recset.move_prev(); //allora torna indietro di un record per riposizionarsi sull'ultimo non letto
      go_on = false;
    }
  } //while(go_on)...


  //incredibilmente arriva in fondo
  TString msg;
  msg << "Doc.: " << curr_movmag << "  Terminale: " << codice_terminale;
  //se può scrivere...
  if (_can_write)
  {
    //alla fine della fiera salva il maggico movimento di magazzino
    TLocalisamfile file_movmag(LF_MOVMAG);
    int err = movmag.write(file_movmag);

    if (err == NOERR)
    {
      msg.insert("Registrato mov. magazzino: ", 0);
      log.log(0, msg);
    }
    else
    {
      msg.insert("Impossibile registrare mov. magazzino: ", 0);
      log.log(2, msg);
    }
  }
  else  //..sennò avverte e basta
  {
    msg.insert("Controllato mov. magazzino: ", 0);
    log.log(0, msg);
  }

  log.log(0, "");
}


void TUpload2Campo::elabora_TF(THardy_upload_recordset& recset, TLog_report& log)
{
  //1)  codice terminale (lungo 3) e codice agente (lungo 5)
  TString4 codice_terminale = recset.get("CodiceTerminale").as_string();
  const TString& codice_agente = check_agente(codice_terminale, log);
  const TString8 codmag = cache().get(LF_AGENTI, codice_agente, AGE_CODMAG);
  check_magazzino(codmag, log);

  //2) Testata documento
  //genera una simpatico documento di cui raccatta la chiave
  const TString& str_datadoc = recset.get(DOC_DATADOC).as_string();
  const TDate datadoc = upload_format_date6(str_datadoc);

  char rec_tipodoc = recset.get(DOC_TIPODOC).as_string()[0];
  //2a) tipo documento
  TString4 tipodoc;
  TConfig hardy(CONFIG_DITTA, "ha");
  switch (rec_tipodoc)
  {
  case 'F': tipodoc = hardy.get("InpFatTip");  break; //Fatture
  case 'B': tipodoc = hardy.get("InpBolTip");  break; //Bolle
  case 'V': tipodoc = hardy.get("InpValTip");  break; //bolle Valorizzate: attenzione!! devono essere trasformate in 'B'olle alla creazione della numerazione di Campo
  case 'O': tipodoc = hardy.get("InpOrdTip");  break; //Ordini
  default:
    {
      _can_write = false;
      TString msg;
      msg << "Tipo documento in input " << rec_tipodoc << " sconosciuto";
      log.log(2, msg);
    }
    break;
  }
  //2b) numerazione documento
  //il codnum dipende dal tipo documento del terminale (F,B,O...) e dal codice del terminale
  //se tipo 'V' va cambiato in tipo 'B' in quanto le bolle valorizzate sono normali bolle in Campo
  TString4 codnum;
  if (rec_tipodoc == 'V')
    rec_tipodoc = 'B';

  codnum << rec_tipodoc << codice_terminale;
  const TString& numerazione = cache().get("%NUM", codnum, "CODTAB");
  if (numerazione != codnum)
  {
    _can_write = false;
    TString msg;
    msg << "Codice numerazione " << codnum << " sconosciuto";
    log.log(2, msg);
  }

  const long ndoc = recset.get(DOC_NDOC).as_int();

  TDocumento doc('D', datadoc.year(), codnum, ndoc);

  //2c) tipo documento e data documento
  doc.put(DOC_TIPODOC, tipodoc);
  TTipo_documento td(tipodoc);
  const TString& caus_movmag = td.caus_mov();
  doc.put(DOC_CAUSMAG, caus_movmag);

  doc.put(DOC_DATADOC, datadoc);
  
  //2d) cliente e campi collegati via cli2doc()
  doc.put(DOC_TIPOCF, "C");
  const long codcf = recset.get(DOC_CODCF).as_int();
  TToken_string key_clifo;
  key_clifo.add("C");
  key_clifo.add(codcf);
  const long cliente = atol(cache().get(LF_CLIFO, key_clifo, CLI_CODCF));
  if (cliente != codcf)
  {
    _can_write = false;
    TString msg;
    msg << "Codice cliente " << codcf << " sconosciuto";
    log.log(2, msg);
  }

  doc.put(DOC_CODCF, codcf);
  doc.put(DOC_CODCFFATT, recset.get(DOC_CODCFFATT).as_int());
  //sconto in fattura, sconto totale, incasso ecc.... che cazzo sono?
  //TString8 scontone = recset.get();
  doc.put(DOC_CODPAG, recset.get(DOC_CODPAG).as_string());
  //data spedizione...datapart o datacons? (solo per ordini)

  //usa la cli2doc per riempire tutti i campi legati al cliente
  TCli_for clifor('C', codcf);
  clifor.cli2doc(doc);

  //al simpatico documento appiccia tutte le righe RF che seguono il record TF..
  //..dopo il magico ordinamento iniziale del recordset
  //intanto azzera le righe eventualmente già presenti (riscrittura)
  doc.destroy_rows();


  //3) righe documento
  //scansione delle righe documento su record RF
  while (recset.move_next())
  {
    if (recset.get("TipoRecord").as_string() != "RF") //quando non trova un RF significa che le righe della testata sono finite!
    {
      recset.move_prev(); //allora torna indietro di un record per riposizionarsi sull'ultimo non letto
      break;
    }

    //agginunge una nuova riga (solo merce, per quanto ne sappiamo)
    TRiga_documento& rigadoc = doc.new_row("01");

    //serie delle put sulla riga documento; ricordiamo che la chiave della riga viene riempita dalla new_row
    //3a) articolo
    TString8 codart = recset.get(RDOC_CODART).as_string();
    const TString& descr = check_articolo(codart, log);

    rigadoc.put(RDOC_CODART, codart);
    rigadoc.put(RDOC_CODARTMAG, codart);
    rigadoc.put(RDOC_CHECKED, "X");
    rigadoc.put(RDOC_DESCR, descr);

    //3b) umart e qta
    const TString& umqta = recset.get(RDOC_UMQTA).as_string();
    TLocalisamfile file_umart(LF_UMART);
    file_umart.setkey(2);
    file_umart.put(UMART_CODART, codart);
    file_umart.put(UMART_UM, umqta);
    const int err_umart = file_umart.read();
    if (err_umart != NOERR)
    {
      _can_write = false;
      TString msg;
      msg << "U.m. " << umqta << " dell'articolo " << codart << " sconosciuta";
      log.log(2, msg);
    }
    rigadoc.put(RDOC_UMQTA, umqta);

    real qta = recset.get("Qta[int]").as_real();
    qta += recset.get("Qta[dec]").as_real() / CENTO;
    rigadoc.put(RDOC_QTA, qta);

    //panegirico sugli sconti
    TString str_sconto;
    real sconto[4];
    sconto[0] = recset.get("Sconto1").as_real();
    sconto[1] = recset.get("Sconto2").as_real();
    sconto[2] = recset.get("Sconto3").as_real();
    sconto[3] = recset.get("ScontoLibero").as_real();
    for (int s = 0; s < 4; s++)
    {
      if (!sconto[s].is_zero())
        str_sconto << (sconto[s] / CENTO) << '+';
    }
    str_sconto.rtrim(1);

    rigadoc.put(RDOC_SCONTO, str_sconto);
  
    //prezzi
    real prezzo_lordo = recset.get(RDOC_PREZZO).as_real();
    prezzo_lordo /= 1000;
    rigadoc.put(RDOC_PREZZO, prezzo_lordo);

    //3x) iva
    const int aliquota_iva = recset.get("AliquotaIva").as_int();
    TString4 codiva;
    //il codice lo si trova nella configurazione del modulo Ha (c'è un magico sheet apposito)
    TConfig config(CONFIG_DITTA, "ha");
    TString curr_name;
    for (int j = 0; ; j++)
    {
      const real curr_aliq_iva = config.get("IVAaliquota", NULL, j);
      if (curr_aliq_iva == ZERO)
        break;
      if (curr_aliq_iva.integer() == aliquota_iva)
      {
        codiva = config.get("IVAcodice", NULL, j);
        break;
      }
    }

    rigadoc.put(RDOC_CODIVA, codiva);

    rigadoc.put(RDOC_LIVELLO, recset.get("CodiceLotto").as_string());

    rigadoc.put(RDOC_CODMAG, codmag); //questo viene dall'agente ed è stato preso all'inizio del metodo
  }

  //incredibilmente arriva in fondo
  TString msg;
  msg << datadoc.year() << "-" << codnum << "-" << ndoc << "  Terminale: " << codice_terminale << "  Cliente: " << codcf;
  //se può scrivere...
  if (_can_write)
  {
    int err = doc.write();

    if (err == NOERR)
    {
      msg.insert("Registrato documento: ", 0);
      log.log(0, msg);
    }
    else
    {
      msg.insert("Impossibile registrare documento: ", 0);
      log.log(2, msg);
    }
  }
  else  //..sennò avverte e basta
  {
    msg.insert("Controllato documento: ", 0);
    log.log(0, msg);
  }

  log.log(0, "");
}


void TUpload2Campo::elabora_RC(THardy_upload_recordset& recset, TLog_report& log)
{
  //1)  codice terminale (lungo 3) e codice agente (lungo 5)
  TString4 codice_terminale = recset.get("CodiceTerminale").as_string();
  const TString& codice_agente = check_agente(codice_terminale, log);
  const TRectype& rec_agente = cache().get(LF_AGENTI, codice_agente);
  const TString8 codmag = rec_agente.get(AGE_CODMAG);
  const long codcf = rec_agente.get_long(AGE_CODFORN);  //cliente (legato all'agente) 

  //2) Testata documento
  const TString& str_datadoc = recset.get("DataCarico").as_string();
  const TDate datadoc = upload_format_date6(str_datadoc);
  const int anno = datadoc.year();

  //2a) numerazione e tipo documento
  TConfig hardy(CONFIG_DITTA, "ha");
  const TString4 codnum = hardy.get("CarDocNum");
  const TString4 tipodoc = hardy.get("CarDoctip");
  const TString4 stato = hardy.get("CarDocSta");

  //2b) documento vero e proprio (stessi campi del caso tipo record = TF)
  TDocumento doc;
  
  doc.put(DOC_CODNUM, codnum);
  doc.put(DOC_ANNO, anno);
  doc.put(DOC_PROVV, "D");
  doc.put(DOC_TIPODOC, tipodoc);
  doc.put(DOC_STATO, stato);
  doc.put(DOC_DATADOC, datadoc);
  doc.put(DOC_TIPOCF, "C");
  doc.put(DOC_CODCF, codcf);

  TTipo_documento td(tipodoc);
  const TString& caus_movmag = td.caus_mov();
  doc.put(DOC_CAUSMAG, caus_movmag);

  TCli_for clifor('C', codcf);
  clifor.cli2doc(doc);

  doc.destroy_rows();

  // righe documento di carico
  bool go_on = true;
  //scansione delle righe documento su record RC
  while (go_on)
  {
    //3) crea le righe (legge tutti i record di tipo RC successivi)
    TRiga_documento& rigadoc = doc.new_row("01");

    //serie delle put sulla riga documento; ricordiamo che la chiave della riga viene riempita dalla new_row
    //3a) articolo
    TString8 codart = recset.get("CodiceArticolo").as_string();
    const TString& descr = check_articolo(codart, log);

    rigadoc.put(RDOC_CODART, codart);
    rigadoc.put(RDOC_CODARTMAG, codart);
    rigadoc.put(RDOC_CHECKED, "X");
    rigadoc.put(RDOC_DESCR, descr);

    TToken_string key_umart;
    key_umart.add(codart);
    key_umart.add(1);
    const TString& um = cache().get(LF_UMART, key_umart, UMART_UM);
    rigadoc.put(RDOC_UMQTA, um);

    const real qta = recset.get("Quantita").as_real() / CENTO;
    rigadoc.put(RDOC_QTA, qta);

    rigadoc.put(RDOC_CODMAG, codmag);

    //quando non trova un RC significa che le righe sono finite!
    go_on = recset.move_next();

    if (go_on && (recset.get("TipoRecord").as_string() != "RC"))
    {
      recset.move_prev(); //allora torna indietro di un record per riposizionarsi sull'ultimo non letto
      go_on = false;
    }
  }

  //incredibilmente arriva in fondo
  TString msg;
  msg << anno << "-" << codnum << "  Terminale: " << codice_terminale << "  Cliente: " << codcf;
  //se può scrivere...
  if (_can_write)
  {
    int err = doc.write();

    if (err == NOERR)
    {
      msg.insert("Registrato documento di carico: ", 0);
      log.log(0, msg);
    }
    else
    {
      msg.insert("Impossibile registrare documento di carico: ", 0);
      log.log(2, msg);
    }
  }
  else  //..sennò avverte e basta
  {
    msg.insert("Controllato documento di carico: ", 0);
    log.log(0, msg);
  }

  log.log(0, "");
}


void TUpload2Campo::elabora(const TMask& mask)
{
  TToken_string tipi_record("SU|TF|RF|SI|BR|VC|RC");

  //creazione del filename del file da importare
  TFilename src_file = mask.get(F_PATH);
  src_file.add(UPLOAD_FILE);

  THardy_upload_recordset recset(src_file);
  const long items = recset.items();
  //ordinamento del file in memoria; sotto ogni TF (testata) mette le sue righe (RF)...MAGIA!!!
  recset.sort(ordina_upload);

#ifdef DBG
  recset.save_as("D:/dati/hardy/cazzone.txt");
#endif

  //creazione progind e log
  TProgind pi(items, TR("Acquisizione dati in corso..."), true, true);
  TLog_report log("Segnalazioni su acquisizione");
  log.kill_duplicates();
  log.log(0, "");

  //parametro di controllo; solo se resta true fino alla fine il documento viene writato
  //solo in caso di elaborazione definitiva può diventare true
  _can_write = false;
  if (mask.get_bool(F_DEFINITIVO))
    _can_write = true;

  //giro su tutti i record del terribile recordset per l'acquisizione dei dati
  for (bool ok = recset.move_first(); ok; ok = recset.move_next())
  {
    if (!pi.addstatus(1))
      break;

    //acquisizione tipo record da riga corrente del file di input
    TString4 tipo_record = recset.rec_type();
    tipo_record.trim();

    const int pos = tipi_record.get_pos(tipo_record);
    
    //trattazione dei vari tracciati record
    switch (pos)
    {
    case 0: //tipo record: SU (SetUp...ovvero agente)
      //elabora_SU(recset, log);  //non serve a una cippa!
      break;
    case 1: //tipo record: TF (Testata Fattura)
      elabora_TF(recset, log);
      break;
    case 2: //tipo record: RF (Riga Fattura)
      //elabora_RF(recset, log);  //non serve! lo fa l'elaborazione di testata
      break;
    case 3: //tipo record: SI (incasso documenti)
      elabora_SI(recset, log);
      break;
    case 4: //tipo record: BR (righe movimenti magazzino)
      elabora_BR(recset, log);
      break;
    case 5: //tipo record: VC (Variazioni Cliente)
      //elabora_VC(recset, log);  //non serve! gli agenti non possono immettere clienti da terminale!
      break;
    case 6: //tipo record: RC (Richiesta Carico)
      elabora_RC(recset, log);
      break;
    default:  //se il tipo record non esiste nella lista dei tipi record si incazza e lo scrive!
      {
        TString msg;
        msg << "Tipo record non riconosciuto '" << tipo_record << "' alla riga " << (recset.current_row() + 1);
        log.log(2, msg);
      }
      break;
    } //switch(pos)..

  } //for (bool ok...

  log.preview();
}


void TUpload2Campo::main_loop()
{
  TUpload2Campo_mask mask;
  _intput_dir = mask.get(F_PATH);
  while (mask.run() == K_ENTER)
  {
    elabora(mask);
  }
}

bool TUpload2Campo::create()
{
	return TSkeleton_application::create();
}

int ha1300(int argc, char* argv[])
{
  TUpload2Campo a;
  a.run(argc, argv, "Importazione dati da file");
  return 0;
}