#include <applicat.h>
#include <automask.h>
#include <execp.h>
#include <progind.h>
#include <utility.h>

#include <comuni.h>
#include <multirel.h>
#include <scadenze.h>
#include "../cg/cgsaldac.h"
#include "../ve/condv.h"

#include "halib.h"
#include "ha1250.h"
#include "ha1200a.h"

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

public:
  TFile2Txt_mask();
};


bool TFile2Txt_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
	{
  case F_CARICO:
    if ((e == fe_modify || e == fe_init) && o.get().full())
    {
      //in base alla configurazione Hardyca completa i campi chiave sulla maschera così che, in caso..
      //..l'utonto decida di fare una ricerca sui documenti, gli appaiano solo quelli buoni per il trasferimento!
      TConfig config(CONFIG_DITTA, "ha");
      const TString& codnum = config.get("CarDocNum");
      const TString& stato = config.get("CarDocSta");
      set(F_CODNUM, codnum);
      set(F_STATO, stato);

      TBrowse& dacardoc = *efield(F_DA_CARDOC).browse();
      TCursor& cur = *dacardoc.cursor();
      dacardoc.do_input(true);
      const TRecnotype tot = cur.items();
      if (tot > 0)
      {
        cur = tot - 1;
        dacardoc.do_output();
        set(F_A_CARDOC, get(F_DA_CARDOC));
      }
    }
    break;
  default:
    break;
  }
  return true;
}

TFile2Txt_mask::TFile2Txt_mask() : TAutomask ("ha1200a")
{
}

///////////////////////////////////////
// TSkeleton_application
///////////////////////////////////////
class TFile2Txt : public THardy_transaction
{
protected:
  virtual void elabora(const TMask& mask, TLog_report& log);
  virtual TMask* create_mask() const;
  virtual const char* fake_trans_file() const;

  bool genera_agenti_txt();
  bool genera_clienti_txt(const long da_codcli);
  bool genera_sospesi_txt(const long da_codcli);
  bool genera_righelistini_txt();
  bool genera_contratti_txt();
  bool genera_promozioni_txt();
  bool genera_prodotti_txt();
  bool genera_barcode_txt();
  bool genera_decodart_txt();
  bool genera_attrezzature_txt();
  bool genera_tabpag_txt();
  bool genera_carico_txt(const TMask& mask);
  bool genera_ripristino_txt(const TMask& mask);

  void fill_anagrafica_cliente(const TISAM_recordset& archivio_clienti, 
                               TEsporta_clienti_recordset& clienti, const bool is_fatt = false);

  bool genera_nomi_output(const char* nome, TFilename& txt, TFilename& tmp) const;
  bool salva_recordset(TRecordset& recset, const char* nome) const;
  bool accoda_recordset(TRecordset& recset, const char* nome) const;
  const TString& curr_cod_list(const long codcf) const;

public:
};

bool TFile2Txt::genera_nomi_output(const char* nome, TFilename& txt, TFilename& tmp) const
{
  txt = _output_path;
  txt.add(nome);
  txt.ext("txt");
  txt.lower();

  tmp = txt;
  tmp.ext("tmp");

  return txt.exist();
}

bool TFile2Txt::salva_recordset(TRecordset& recset, const char* nome) const
{
  TFilename txt_path, tmp_path;
  genera_nomi_output(nome, txt_path, tmp_path);
  const bool ok = recset.save_as(tmp_path, fmt_text);
  if (ok)
  {
    txt_path.fremove();           // Cancello nome.txt (potrebbe esistere)
    ::rename(tmp_path, txt_path); // rinomino nome.tmp in nome.txt
  }
  else
    cantwrite_box(tmp_path);
  return ok;
}

bool TFile2Txt::accoda_recordset(TRecordset& recset, const char* nome) const
{
  TFilename txt_path, tmp_path;
  const bool append = genera_nomi_output(nome, txt_path, tmp_path);
  bool ok = true;
  
  if (append)
  {
    // Rinomino il file di destinazione per evitare interferenze dal concentratore
    ::rename(txt_path, tmp_path);

    TFilename local_path; 
    local_path.tempdir();
    local_path.add(nome);
    local_path.ext(".txt");
    local_path.lower();
    ok = recset.save_as(local_path, fmt_text);
    if (ok)
    {
      ok = ::fcopy(local_path, tmp_path, true, false); 
      if (!ok)
        cantwrite_box(tmp_path);
      local_path.fremove();
    }
    else
      cantwrite_box(local_path);

    // Ripristino il nome del file di destinazione
    ::rename(tmp_path, txt_path);            
  }
  else
    ok = salva_recordset(recset, nome);

  return ok;
}


bool TFile2Txt::genera_agenti_txt()
{
  //AS400 recordset da riempire (da lui nascerà il .txt)
  TEsporta_agenti_recordset agenti;

  //ISAM recordset con tutti i dati degli archivi Campo (servirà per riempire l'AS400 recset)
  TISAM_recordset archivio_agenti("USE AGENTI");
  const long archivio_agenti_items = archivio_agenti.items();
  //scansione ISAM
  TProgind progind(archivio_agenti_items, "Agenti...", false, true);
  for (bool ok = archivio_agenti.move_first(); ok; ok = archivio_agenti.move_next())
  {
    progind.addstatus(1);

    //riga dell'AS400 recset da riempire
    agenti.new_rec("");

    TString8 codage = archivio_agenti.get(AGE_CODAGE).as_string();
    codage = codage.right(3);
    agenti.set("CodiceTerminale", codage);
    agenti.set(AGE_CODAGE, codage);
    agenti.set(AGE_RAGSOC, archivio_agenti.get(AGE_RAGSOC));
    agenti.duplica_capi_zona();
  }

  return salva_recordset(agenti, "agenti");
}


void TFile2Txt::fill_anagrafica_cliente(const TISAM_recordset& archivio_clienti,
                                        TEsporta_clienti_recordset& clienti, const bool is_fatt)
{
    clienti.set_fatt("RagioneSociale", archivio_clienti.get(CLI_RAGSOC), is_fatt);

    TString80 indcf = archivio_clienti.get(CLI_INDCF).as_string();
    indcf << " " << archivio_clienti.get(CLI_CIVCF).as_string();

    clienti.set_fatt("Indirizzo", indcf, is_fatt);

    const TString80 localitacf = archivio_clienti.get(CLI_LOCCF).as_string();
    clienti.set_fatt("Localita", localitacf, is_fatt);

    const TString& statocf = archivio_clienti.get(CLI_STATOCF).as_string();
    if (statocf.blank())
    {
      const TString& comcf = archivio_clienti.get(CLI_COMCF).as_string();
      TToken_string key;
      key.add(statocf);
      key.add(comcf);
      const TRectype& rec_comuni = cache().get(LF_COMUNI, key);
      if (localitacf.blank())
      {
        TString80 dencom = rec_comuni.get(COM_DENCOM);
        clienti.set_fatt("Localita", dencom, is_fatt);
      }
      const TString& provcf = rec_comuni.get(COM_PROVCOM);
      clienti.set_fatt("Provincia", provcf, is_fatt);
    }

    clienti.set_fatt("CAP", archivio_clienti.get(CLI_CAPCF), is_fatt);

    clienti.set_fatt("PartitaIVA", archivio_clienti.get(CLI_PAIV), is_fatt);
    clienti.set_fatt("CodiceFiscale", archivio_clienti.get(CLI_COFI), is_fatt);
}

const TString& TFile2Txt::curr_cod_list(const long codcf) const
{
  TString16 key; key.format("C|%ld", codcf);
  TString4 codlist = cache().get(LF_CFVEN, key, CFV_CODLIST);
  bool done = codlist.blank();
  while (!done)
  {
    done = true;
    key.format("L||||%s", (const char*)codlist);
    const TRectype& rec = cache().get(LF_CONDV, key);
    const TString4 nxtlist = rec.get(CONDV_CODLISSUCC);
    if (nxtlist.full())
    {
      TDate datascad = rec.get(CONDV_VALFIN);
      if (datascad.ok())
      {
        while (datascad.wday() >= 6)
          --datascad;
        if (datascad <= TDate(TODAY))
        {
          codlist = nxtlist;
          done = false;
        }
      }
    }
  }
  return get_tmp_string() = codlist;
}


//clienti: i commenti del metodo sono nella genera_cliente_txt() della ha1100 (che è la mamma di questo)
bool TFile2Txt::genera_clienti_txt(const long da_codcli)
{
  //controlla se c'è un codice selezionato da cui partire

  TEsporta_clienti_recordset clienti;

  TString query;
  query << "USE CLIFO";
  query << "\nSELECT (SOSPESO!=\"X\")";
  query << "\nJOIN CFVEN INTO TIPOCF=TIPOCF CODCF=CODCF";
  query << "\nFROM TIPOCF=C";
  if (da_codcli > 0L)
    query << " CODCF=" << da_codcli;
  query << "\nTO TIPOCF=C";

  TISAM_recordset archivio_clienti(query);
  const long archivio_clienti_items = archivio_clienti.items();

  TProgind progind(archivio_clienti_items, "Clienti...", false, true);
  for (bool ok = archivio_clienti.move_first(); ok; ok = archivio_clienti.move_next())
  {
    progind.addstatus(1);

    clienti.new_rec("");

    //il codice terminale è il codagente legato al cliente (codice agente lungo 5, codice terminale lungo 3)
    const TString8 codage = archivio_clienti.get("CFVEN.CODAG").as_string();
    clienti.set("CodiceTerminale", codage.right(3));

    const long codcf = archivio_clienti.get(CLI_CODCF).as_int();
    clienti.set("CodiceCliente", codcf);

    //riempie l'anagrafica del cliente principale
    fill_anagrafica_cliente(archivio_clienti, clienti, false);

    //riempie l'anagrafica del cliente in allegato (se c'è)
    const long codalleg = archivio_clienti.get(CLI_CODALLEG).as_int();
    if (codalleg > 0)
    {
      TString queryna;
      queryna << "USE CLIFO";
      queryna << "\nJOIN CFVEN INTO TIPOCF=TIPOCF CODCF=CODCF";
      queryna << "\nFROM TIPOCF=C CODCF=#CODALLEG";
      queryna << "\nTO TIPOCF=C CODCF=#CODALLEG";

      TISAM_recordset cliente_allegato(queryna);
      cliente_allegato.set_var("#CODALLEG", codalleg);

      fill_anagrafica_cliente(cliente_allegato, clienti, true);
    }


    const TString4 codpag = archivio_clienti.get(CLI_CODPAG).as_string();
    clienti.set("CodicePagamento", codpag.right(2));

    //Nel campo CodiceListino ci va il codice del Listino Campo associato al cliente in cfven
    clienti.set("CodiceListino", curr_cod_list(codcf));

    const TString& str_sconto = archivio_clienti.get(CFV_SCONTO).as_string();
    clienti.set("ScontoFineFattura", hd_find_sconto(str_sconto));

    //gestione giri
    //i giri stanno nella tabella di modulo &HGI, con chiave CODTAB=agente-giorno-cliente
    TString query;
    query << "USE &HGI";
    query << "\nSELECT (CODTAB[7,12]=#CODCLI)";
    query << "\nFROM CODTAB=#CODAGE";
    query << "\nTO CODTAB=#CODAGE";
    TISAM_recordset cli_giri_recset(query);
    cli_giri_recset.set_var("#CODCLI", codcf);
    cli_giri_recset.set_var("#CODAGE", codage);

    for (bool ok = cli_giri_recset.move_first(); ok; ok = cli_giri_recset.move_next())
    {
      const int giorno = cli_giri_recset.get("CODTAB[6,6]").as_int();
      TString8 nome_campo = "Giro0";
      nome_campo << giorno;
      const long ordine = cli_giri_recset.get("I0").as_int();
      clienti.set(nome_campo, ordine);
    }
 
    TString80 ntel = archivio_clienti.get(CLI_PTEL).as_string();
    ntel << archivio_clienti.get(CLI_TEL).as_string();
    clienti.set("NumeroTelefono", ntel);

    clienti.set("EsenteIVA", archivio_clienti.get(CFV_ASSFIS));

    clienti.set(CLI_CODCFFATT, archivio_clienti.get(CLI_CODCFFATT));

    TString8 td = archivio_clienti.get("CFVEN.CODLEG").as_string();
    if (td.blank())
      td = "F";
    else
      td.cut(1);
    clienti.set("TipoDoc", td);

    real fido = archivio_clienti.get(CLI_FIDO).as_real();
    fido *= CENTO;
    fido.round();
    clienti.set("Fido", fido);

    /*const bool sospeso = archivio_clienti.get(CLI_SOSPESO).as_bool();
    TString4 s;
    if (sospeso)
      s='S';
    clienti.set("NoConsegna", TVariant(s));*/

    clienti.duplica_capi_zona();
  } //for (bool ok = archivio_clienti.move_first()...

  return salva_recordset(clienti, "clienti");
}


bool TFile2Txt::genera_sospesi_txt(const long da_codcli)
{
  TEsporta_sospesi_recordset sospesi;

  TString query;
  query << "USE PART";
  query << "\nSELECT (CHIUSA!=\"X\")&&(TIPOMOV=1)";
  query << "\nFROM TIPOC=C SOTTOCONTO=#DACODC";
  query << "\nTO TIPOC=C";

  TISAM_recordset archivio_part(query);
  archivio_part.set_var("#DACODC", da_codcli);
  const long archivio_part_items = archivio_part.items();

  TProgind progind(archivio_part_items, "Sospesi...", false, true);
  for (bool ok = archivio_part.move_first(); ok; ok = archivio_part.move_next())
  {
    progind.addstatus(1);

    //per riempire i campi è necessario un po' di casino sulla partita in esame
    const TRectype& rec_part = archivio_part.cursor()->curr();
    TPartita partita(rec_part);
    //cerca il saldo, il totale del doc originale, il residuo
    TImporto saldo, doc, pag, imp;
    partita.calcola_saldo(saldo, doc, pag, imp);
    saldo.normalize(doc.sezione());  // 29/02/2012
    //solo se il saldo è > 0 crea la nuova riga da esportare nel txt ... così volle Hardy!
    if (saldo.valore() > ZERO && doc.valore() > ZERO)
    {
      sospesi.new_rec("");

      const int nriga = rec_part.get_int(PART_NRIGA);
      const TRiga_scadenze& scad = partita.rata(nriga, 1);
      const TDate datascad = scad.get_date(SCAD_DATASCAD);

      //e vai che riempiamo i campi
      const long codcf = rec_part.get_long(PART_SOTTOCONTO);  //riprendiamo il codcf come long
      const TString& codage = hd_find_codag(codcf);
      sospesi.set("CodiceTerminale", codage);
      sospesi.set("CodiceCliente", codcf);
      const TString& ndoc = rec_part.get(PART_NUMDOC);
      sospesi.set("NumeroFattura", ndoc);
      const TDate datadoc = rec_part.get_date(PART_DATADOC);
      sospesi.set("DataFattura", hd_format_date6(datadoc));
      real residuo = saldo.valore();
      residuo *= CENTO;
      sospesi.set("ImportoResiduo", residuo);
      sospesi.set("ImpOriginalDoc", doc.valore());
      sospesi.set("DataScadenza", hd_format_date6(datascad));

      //partita: il codice sul terminalino deve avere il seguente formato (alla cazzo!)
      //anno[4]-numpart[7, allineato a dx]
      TString16 cod_partita;
      const int anno = rec_part.get_int(PART_ANNO);
      const TString& numpart = rec_part.get(PART_NUMPART);  //lo si prende così perchè Hardy allinea a destra il saldaconto
      cod_partita << anno << "-" << numpart;
      sospesi.set("Partita", cod_partita);
      sospesi.set("TipoDocumento", "F");

      sospesi.duplica_capi_zona();
    }
  }

  return salva_recordset(sospesi, "sospesi");
}

//listini: i commenti del metodo sono nella genera_listino_txt() della ha1100
bool TFile2Txt::genera_righelistini_txt()
{
  const TDate oggi(TODAY);
  TEsporta_listini_recordset righe_listini;

  TISAM_recordset agenti("USE AGENTI");
  const long agenti_items = agenti.items();

  TString query;
  query << "USE RCONDV";
  query << "\nJOIN CONDV INTO TIPO=TIPO TIPOCF=TIPOCF CODCF==CODCF COD==COD";
  query << "\nFROM TIPO=L";
  query << "\nTO TIPO=L";

  TISAM_recordset archivio_rcondv(query);
  const long archivio_rcondv_items = archivio_rcondv.items();

  for (bool ok = agenti.move_first(); ok; ok = agenti.move_next())
  {
    const TString4 codage = agenti.get(AGE_CODAGE).as_string().right(3);
    TProgind progind(archivio_rcondv_items, "Listini...", false, true);
    for (bool ok = archivio_rcondv.move_first(); ok; ok = archivio_rcondv.move_next())
    {
      if (!progind.addstatus(1))
        break;

      const TDate datascad = archivio_rcondv.get("CONDV.VALFIN").as_date();
      if (datascad.ok() && datascad < oggi)
        continue;

      righe_listini.new_rec("");

      righe_listini.set("CodiceTerminale", codage);
      righe_listini.set(RCONDV_COD, archivio_rcondv.get(RCONDV_COD));
      const TString80 codart = archivio_rcondv.get(RCONDV_CODRIGA).as_string();
      righe_listini.set(RCONDV_CODRIGA, codart);

      real prezzo = archivio_rcondv.get(RCONDV_PREZZO).as_real();
      if (prezzo.is_zero())
      {
        TToken_string key_umart;
        key_umart.add(codart);
        key_umart.add(1);
        const TRectype& rec_umart = cache().get(LF_UMART, key_umart);
        prezzo = rec_umart.get_real(UMART_PREZZO);
      }
      prezzo *= 1000;
      prezzo.round();
      righe_listini.set(RCONDV_PREZZO, prezzo.integer());

      const TString& str_sconto = archivio_rcondv.get(RCONDV_SCONTO).as_string();
      righe_listini.set(RCONDV_SCONTO, hd_find_sconto(str_sconto));
    }
  }

  return salva_recordset(righe_listini, "listini");
}


bool TFile2Txt::genera_contratti_txt()
{
  const TDate oggi(TODAY);
  TEsporta_contratti_recordset righe_contratti;

  TString query;
  query << "USE RCONDV";
  query << "\nJOIN CONDV INTO TIPO=TIPO TIPOCF=TIPOCF CODCF==CODCF COD==COD";
  query << "\nFROM TIPO=C TIPOCF=C";
  query << "\nTO TIPO=C TIPOCF=C" ;

  TISAM_recordset archivio_rcondv(query);
  const long archivio_rcondv_items = archivio_rcondv.items();
  TProgind progind(archivio_rcondv_items, archivio_rcondv.cursor()->file().name());

  for (bool ok = archivio_rcondv.move_first(); ok; ok = archivio_rcondv.move_next())
  {
    if (!progind.addstatus(1))
      break;

    const TDate datafine = archivio_rcondv.get("CONDV.VALFIN").as_date();
    if (datafine.ok() && datafine < oggi) // Ignora i contratti scatuti
      continue; 

    righe_contratti.new_rec("");

    const long codcf = archivio_rcondv.get(CONDV_CODCF).as_int();
    righe_contratti.set("CodiceTerminale", hd_find_codag(codcf));
    righe_contratti.set(CONDV_CODCF, codcf);
    righe_contratti.set(RCONDV_CODRIGA, archivio_rcondv.get(RCONDV_CODRIGA));
    real prezzo = archivio_rcondv.get(RCONDV_PREZZO).as_real();
    prezzo *= 1000;
    prezzo.round();
    righe_contratti.set(RCONDV_PREZZO, prezzo.integer());
    const TString& str_sconto = archivio_rcondv.get(RCONDV_SCONTO).as_string();
    righe_contratti.set(RCONDV_SCONTO, hd_find_sconto(str_sconto));

    const TDate dataini = archivio_rcondv.get("CONDV.VALIN").as_date();
    righe_contratti.set(CONDV_VALIN, hd_format_date8(dataini));
    righe_contratti.set(CONDV_VALFIN, hd_format_date8(datafine));
    righe_contratti.duplica_capi_zona();
  }

  return salva_recordset(righe_contratti, "particolari");
}

bool TFile2Txt::genera_promozioni_txt()
{
  TEsporta_contratti_recordset righe_offerte;

  TString query;
  query << "USE RCONDV";
  query << "\nJOIN CONDV INTO TIPO=TIPO TIPOCF=TIPOCF CODCF=CODCF COD=COD";
  query << "\nFROM TIPO=O";
  query << "\nTO TIPO=O";

  TISAM_recordset archivio_rcondv(query);
  const long archivio_rcondv_items = archivio_rcondv.items();

  TProgind progind(archivio_rcondv_items, "Promozioni...", false, true);
  for (bool ok = archivio_rcondv.move_first(); ok; ok = archivio_rcondv.move_next())
  {
    progind.addstatus(1);

    righe_offerte.new_rec("");
    //non si sa quali campi trasferire!
  }

  return salva_recordset(righe_offerte, "promo");
}

//prodotti: i commenti del metodo sono nella genera_prodotto_txt() della ha1100
bool TFile2Txt::genera_prodotti_txt()
{
  TEsporta_prodotti_recordset prodotti;

  TString query;
  query << "USE ANAMAG";
  query << "\nSELECT USER1=\"X\"";
  query << "\nJOIN UMART INTO CODART=CODART NRIGA=1";

  TISAM_recordset archivio_anamag(query);
  const long archivio_anamag_items = archivio_anamag.items();

  TProgind progind(archivio_anamag_items, TR("Prodotti..."), false, true);
  for (bool ok = archivio_anamag.move_first(); ok; ok = archivio_anamag.move_next())
  {
    progind.addstatus(1);

    prodotti.new_rec("");

    prodotti.set(ANAMAG_CODART, archivio_anamag.get(ANAMAG_CODART));
    prodotti.set(ANAMAG_DESCR, archivio_anamag.get(ANAMAG_DESCR));
    real prezzo = archivio_anamag.get("UMART.PREZZO").as_real();
    prezzo *= 1000;
    prezzo.round();
    prodotti.set(UMART_PREZZO, prezzo.integer());

    const TString& codiva = archivio_anamag.get(ANAMAG_CODIVA).as_string();
    //esportiamo un'aliquota, non un codice iva!
    const real aliq_iva = cache().get("%IVA", codiva, "R0");
    prodotti.set(ANAMAG_CODIVA, aliq_iva.integer());

    prodotti.set(UMART_UM, archivio_anamag.get("UMART.UM"));
    const TString& str_sconto = archivio_anamag.get(ANAMAG_SCONTO).as_string();
    prodotti.set(ANAMAG_SCONTO, hd_find_sconto(str_sconto));

    // Flag di prodotto in omaggio da controllare
    prodotti.set("Fascia", archivio_anamag.get(ANAMAG_USER4).as_string().left(1));
  }

  return salva_recordset(prodotti, "prodotti");
}

bool TFile2Txt::genera_barcode_txt()
{
  TEsporta_barcode_recordset barcode;
    
  TISAM_recordset archivio_codcorr("USE CODCORR SELECT (TIPO=#TIPO)");
  const TString& tipo = ini_get_string(CONFIG_DITTA, "ha", "TipoBarcode");
  archivio_codcorr.set_var("#TIPO", tipo);
  const long archivio_codcorr_items = archivio_codcorr.items();

  TProgind progind(archivio_codcorr_items, TR("Barcode..."), false, true);
  for (bool ok = archivio_codcorr.move_first(); ok; ok = archivio_codcorr.move_next())
  {
    progind.addstatus(1);

    barcode.new_rec("");
    barcode.set(CODCORR_CODARTALT, archivio_codcorr.get(CODCORR_CODARTALT));
    barcode.set(CODCORR_CODART, archivio_codcorr.get(CODCORR_CODART));
    barcode.duplica_capi_zona();
  }

  return salva_recordset(barcode, "barcode");
}


bool TFile2Txt::genera_decodart_txt()
{
  TEsporta_decodart_recordset decodart;

  const char* const query = "USE MULTIREL\nFROM COD=HACOR\nTO COD=HACOR";
  TISAM_recordset archivio_codcorr(query);
  const long archivio_codcorr_items = archivio_codcorr.items();

  TProgind progind(archivio_codcorr_items, TR("Decodart..."), false, true);
  for (bool ok = archivio_codcorr.move_first(); ok; ok = archivio_codcorr.move_next())
  {
    progind.addstatus(1);

    decodart.new_rec("");
    decodart.set(CODCORR_CODCF, archivio_codcorr.get(MULTI_FIRST));
    decodart.set(CODCORR_CODART, archivio_codcorr.get(MULTI_SECOND));

    const TString& data = archivio_codcorr.get(MULTI_DATA).as_string();
    decodart.set(CODCORR_CODARTALT, data.left(6));
    decodart.set(CODCORR_DESCR, data.mid(6, 30));
    decodart.duplica_capi_zona();
  }

  return salva_recordset(decodart, "decodart");
}


bool TFile2Txt::genera_attrezzature_txt()
{
  //esporta le attrezzature (tabella &HAATT)
  TEsporta_attrezzature_recordset attrezzature;

  //esporta solo le attrezzature legate ad un cliente (quelle con I0=0 non esistono più o sono in sede Hardy)
  TString query;
  query << "USE &ATT";
  query << "\nSELECT I0>0";

  TISAM_recordset archivio_attr(query);
  const long archivio_attr_items = archivio_attr.items();

  TProgind progind_att(archivio_attr_items, TR("Attrezzature..."), false, true);
  for (bool ok = archivio_attr.move_first(); ok; ok = archivio_attr.move_next())
  {
    progind_att.addstatus(1);

    attrezzature.new_rec("");

    //in base al codice cliente stabilisce quale è il codice agente
    const long codcf = archivio_attr.get("I0").as_int();
    attrezzature.set("CodiceTerminale", hd_find_codag(codcf));
    attrezzature.set("CodiceArticolo", archivio_attr.get("CODTAB[1,5]"));
    attrezzature.set("Progressivo", archivio_attr.get("CODTAB[6,12]").as_int());
    attrezzature.set("Matricola", archivio_attr.get("S0[6,20]"));
    attrezzature.set("DescrAttrezz", archivio_attr.get("S3"));
    attrezzature.set("CodiceCliente", codcf);
    attrezzature.set("CodiceSedeCliente", archivio_attr.get("I1").as_int());
    //occhio alle date
    TDate data_ass = archivio_attr.get("D0").as_date();
    attrezzature.set("DataAssegnamento", hd_format_date8(data_ass));
    TDate data_fabb = archivio_attr.get("D1").as_date();
    attrezzature.set("DataFabbricazione", hd_format_date8(data_fabb));
    attrezzature.duplica_capi_zona();
  }

  salva_recordset(attrezzature, "attrezzature");


  //esporta lo storico attrezzature (tabella &HAHIS)
  TEsporta_storico_attrezzature_recordset storico;

  //deve esportare solo lo storico delle attrezzature legate ad un cliente non nullo e relative al cliente stesso..
  //..escludendo quindi lo storico dell'attrezzatura che non compete al cliente che l'ha attualmente in uso
  query.cut(0);
  query << "USE &HAHIS";
  query << "\nSELECT (401@->I0>0)&&(401@->I0=I0)";
  query << "\nJOIN &HAATT ALIAS 401 INTO CODTAB=CODTAB[1,12]";

  TISAM_recordset archivio_storico(query);
  const long archivio_storico_items = archivio_storico.items();

  TProgind progind_sto(archivio_storico_items, TR("Storico interventi..."), false, true);
  for (bool ok = archivio_storico.move_first(); ok; ok = archivio_storico.move_next())
  {
    progind_sto.addstatus(1);

    storico.new_rec("");

    const long codcf = archivio_storico.get("I0").as_int();
    storico.set("CodiceTerminale", hd_find_codag(codcf));
    storico.set("CodiceArticolo", archivio_storico.get("CODTAB[1,5]"));
    storico.set("Progressivo", archivio_storico.get("CODTAB[6,12]").as_int());
    storico.set("ProgrIntervento", archivio_storico.get("CODTAB[13,17]").as_int());
    TDate data_int = archivio_storico.get("D0").as_date();
    storico.set("DataIntervento", hd_format_date8(data_int));
    storico.set("TipoIntervento", archivio_storico.get("S7[1,1]"));
    storico.set("DescrIntervento", archivio_storico.get("S0"));
    storico.set("CodArtIntervento", archivio_storico.get("S3[1,5]"));
    storico.set("UnitaMisura", archivio_storico.get("S6[1,2]"));
    real qta = archivio_storico.get("R0").as_real();
    qta *= CENTO;
    qta.round();
    storico.set("Quantita", qta);
    real importo = archivio_storico.get("R1").as_real();
    importo *= CENTO;
    importo.round();
    storico.set("Importo", importo);
    storico.set("ChiusuraComodato", archivio_storico.get("B0"));
    storico.duplica_capi_zona();
  }

  return salva_recordset(storico, "storico");
}

bool TFile2Txt::genera_tabpag_txt()
{
  TEsporta_pagamenti_recordset tabpag;

  TString query;
  query << "USE %CPG";
  query << "\nJOIN %RPG ALIAS 401 INTO CODTAB=CODTAB";

  TISAM_recordset archivio_pagamenti(query);
  const long archivio_pagamenti_items = archivio_pagamenti.items();

  TProgind progind(archivio_pagamenti_items, TR("Pagamenti..."), false, true);
  for (bool ok = archivio_pagamenti.move_first(); ok; ok = archivio_pagamenti.move_next())
  {
    progind.addstatus(1);

    tabpag.new_rec("");
    const TString& codtab = archivio_pagamenti.get("CODTAB").as_string();
    tabpag.set("CodicePagamento", codtab.right(2));
    const TString& cpg_s0 = archivio_pagamenti.get("S0").as_string();
    tabpag.set("DescrPagamento", cpg_s0);
    long giorni = archivio_pagamenti.get("401@.I0").as_int();
    if (giorni <= 0)
      giorni = archivio_pagamenti.get("I3").as_int();
    tabpag.set("GiorniScadenza", giorni);
    tabpag.duplica_capi_zona();
  }

  return salva_recordset(tabpag, "tabpag");
}

bool TFile2Txt::genera_carico_txt(const TMask& mask)
{
  TEsporta_carico_recordset carico;

  TString query;
  query << "USE RDOC";
  query << "\nSELECT (DOC.TIPODOC=#TIPODOC)&&(DOC.STATO=#STATO)";
  query << "\nBY DOC.CODAG NDOC";
  query << "\nJOIN DOC INTO PROVV==PROVV ANNO==ANNO CODNUM==CODNUM NDOC==NDOC";
  query << "\nFROM CODNUM=#CODNUM ANNO=#ANNO PROVV=D NDOC=#DA_NDOC";
  query << "\nTO CODNUM=#CODNUM ANNO=#ANNO PROVV=D NDOC=#A_NDOC";

  TISAM_recordset archivio_rdoc(query);

  //parametri dalla configurazione
  TConfig config(CONFIG_DITTA, "ha");
  const TString& tipodoc = config.get("CarDocTip");
  archivio_rdoc.set_var("#TIPODOC", tipodoc);
  const TString& stato_ini = config.get("CarDocSta");
  archivio_rdoc.set_var("#STATO", stato_ini);
  const TString& codnum = config.get("CarDocNum");
  archivio_rdoc.set_var("#CODNUM", codnum);

  TString4 stato_fin = config.get("CarDocFin");
  if (stato_fin.blank() || stato_fin == stato_ini)
    stato_fin.format("%d", atoi(stato_ini)+1);
  
  //parametri dalla maschera
  const long anno = mask.get_long(F_ANNO);
  archivio_rdoc.set_var("#ANNO", anno);
  const long da_ndoc = mask.get_long(F_DA_CARDOC);
  archivio_rdoc.set_var("#DA_NDOC", da_ndoc);
  const long a_ndoc = mask.get_long(F_A_CARDOC);
  archivio_rdoc.set_var("#A_NDOC", a_ndoc);

  const long archivio_rdoc_items = archivio_rdoc.items();

  TProgind progind(archivio_rdoc_items, "Documenti carico...", false, true);

  long last_ndoc = 0;

  for (bool ok = archivio_rdoc.move_first(); ok; ok = archivio_rdoc.move_next())
  {
    progind.addstatus(1);

    const long ndoc = archivio_rdoc.get(RDOC_NDOC).as_int();
    if (ndoc != last_ndoc)
    {
      TLocalisamfile& doc = archivio_rdoc.cursor()->file(LF_DOC);
      int err = doc.read(_isequal, _testandlock);
      if (err == NOERR)
      {
        doc.put(DOC_STATO, stato_fin);
        doc.rewrite();
        last_ndoc = ndoc;
      }
      else
        continue;
    }

    carico.new_rec("");

    TString8 codage = archivio_rdoc.get("DOC.CODAG").as_string();
    codage = codage.right(3);
    carico.set("CodiceTerminale", codage);
    carico.set("CodiceArticolo", archivio_rdoc.get(RDOC_CODART));
    real qta = archivio_rdoc.get(RDOC_QTA).as_real();
    qta *= CENTO;
    qta.round();
    carico.set("QuantitaCaricata", qta);
    carico.set("CodiceLotto", archivio_rdoc.get(RDOC_LIVELLO));
  }

  return accoda_recordset(carico, "carico");
}

bool TFile2Txt::genera_ripristino_txt(const TMask& mask)
{
  TEsporta_carico_recordset ripristino;

  TString query;
  query << "USE 109 KEY 2";
  query << "\nSELECT (STR(GIAC>0))&&(ANAMAG.USER1!=\"\")";
  query << "\nJOIN ANAMAG INTO CODART==CODART";
  query << "\nFROM ANNOES=#ANNOES CODMAG=#CODMAG";
  query << "\nTO ANNOES=#ANNOES CODMAG=#CODMAG";

  TISAM_recordset archivio_mag(query);

  //parametri dalla maschera
  const long annoes = mask.get_long(F_ANNOES);
  archivio_mag.set_var("#ANNOES", annoes);
  const TString& codmag = mask.get(F_CODMAG);
  archivio_mag.set_var("#CODMAG", codmag);
  //il codice terminale è il codice magazzino dell'agente selezionato sulla maschera..
  //..poichè gli agenti devono avere codice lungo 3 zerofilled ed i magazzini Hardy sono..
  //..lunghi 2 e numerici ->...
  TString4 codage;
  codage << 0 << codmag;

  const long archivio_mag_items = archivio_mag.items();

  TProgind progind(archivio_mag_items, TR("Ripristino magazzino..."), false, true);
  for (bool ok = archivio_mag.move_first(); ok; ok = archivio_mag.move_next())
  {
    progind.addstatus(1);

    ripristino.new_rec("");
    
    ripristino.set("CodiceTerminale", codage);
    ripristino.set("CodiceArticolo", archivio_mag.get(MAG_CODART));
    real qta = archivio_mag.get(MAG_GIAC).as_real();
    qta *= CENTO;
    qta.round();
    ripristino.set("QuantitaCaricata", qta);
    ripristino.set("CodiceLotto", archivio_mag.get(MAG_LIVELLO));
  }

  return salva_recordset(ripristino, "carico");
}

//metodo di alto livello per la gestione delle chiamate
void TFile2Txt::elabora(const TMask& mask, TLog_report& log)
{
  // a) stoppa il concentratore
  // chiudi_concentratore();

  //b) esegue le vere elaborazioni
  //------------------------------
  bool go_on = true;

  if (mask.get_bool(F_AGENTI))
    go_on = genera_agenti_txt();

  if (mask.get_bool(F_CLIENTI) && go_on)
  {
    const long da_codcli = mask.get_long(F_DA_CODCLI);
    go_on = genera_clienti_txt(da_codcli);
  }

  if (mask.get_bool(F_SOSPESI) && go_on)
  {
    const long da_codcli = mask.get_long(F_DA_SOSP_CODCLI);
    go_on = genera_sospesi_txt(da_codcli);
  }

  if (mask.get_bool(F_LISTINI) && go_on)
    go_on = genera_righelistini_txt();

  if (mask.get_bool(F_CONTRATTI) && go_on)
    go_on = genera_contratti_txt();

  if (mask.get_bool(F_PROMOZIONI) && go_on)
    go_on = genera_promozioni_txt();

  if (mask.get_bool(F_PRODOTTI) && go_on)
    go_on = genera_prodotti_txt();

  if (mask.get_bool(F_BARCODE) && go_on)
    go_on = genera_barcode_txt();

  if (mask.get_bool(F_DECODART) && go_on)
    go_on = genera_decodart_txt();

  if (mask.get_bool(F_ATTREZZA) && go_on)
    go_on = genera_attrezzature_txt();

  if (mask.get_bool(F_TABPAG) && go_on)
    go_on = genera_tabpag_txt();

  if (mask.get_bool(F_CARICO) && go_on)
    go_on = genera_carico_txt(mask);

  if (mask.get_bool(F_INIMAG) && go_on)
    go_on = genera_ripristino_txt(mask);

  /* Per il momento preferiscono agire manualmente
  //c) lancia il concentratore in modalità di carico
  carica_concentratore();

  //d) rilancia il concentratore in modalità di trasmissione
  trasmetti_concentratore();
  */
}

TMask* TFile2Txt::create_mask() const
{
  TMask* mask = new TFile2Txt_mask;
  mask->set(F_OUTPUT_PATH, _output_path);
  //mask->set(F_CONC_PATH, _conc_path);
  //mask->set(F_TRANS_PATH, _trans_path);
  return mask;
}

const char* TFile2Txt::fake_trans_file() const
{ return "157"; }

int ha1200(int argc, char* argv[])
{
  TFile2Txt a;
  a.run(argc, argv, TR("Generazione .txt da archivi"));
  return 0;
}