#include <applicat.h>
#include <automask.h>
#include <config.h>
#include <modaut.h>
#include <progind.h>
#include <recarray.h>
#include <utility.h>
#include <textset.h>

#include "../cg/cglib01.h"
#include "../cg/cglib03.h"

#include "tc0.h"
#include "tc9300a.h"

#include <anagr.h>
#include <anafis.h>
#include <clifo.h>
#include <comuni.h>
#include <mov.h>
#include <nditte.h>
#include <rmov.h>
#include <rmoviva.h>
#include <multirel.h>

#include "../ca/rip.h"
#include "../ca/rrip.h"

#define SLF_MOV "23" 
#define ALIAS_REG		100
#define REG_OFFSET 1000000L
#define GIRO_OFFSET 2000000L

///////////////////////////////////////////////////////////
// TRiclassifica_cache
///////////////////////////////////////////////////////////

class TRiclassifica_cache : public TCache
{
	TLocalisamfile _multirel;

protected:
  virtual TObject* key2obj(const char* key);

public:
	const char * sdecode(const char* tab, const TString& cod);
	long decode(const char* tab, const TString& cod);
	const TString& sdecode_caufor(const TString& cod);
	const TString& sdecode_caureg(const TString& cod);
	const TString& sdecode_caugiro(const TString& cod);
	const TString& sdecode_contov(const TString& cod);
	const TString& sdecode_caucon(const TString& cod);
	const TString& sdecode_sezcon(const TString& cod);
	bool sdecode_rc(const TString& cod);
	TRiclassifica_cache() : _multirel(LF_MULTIREL) { _multirel.setkey(2);}
};

TObject* TRiclassifica_cache::key2obj(const char* key)
{
	TToken_string tok(key);
	TString8 tab, cod;
	tok.get(0,tab);
	tok.get(1, cod);
	_multirel.setkey(1);
	_multirel.put(MULTI_COD, tab);
	_multirel.put(MULTI_FIRST, cod);
	_multirel.put(MULTI_SECOND, "");
	int err = _multirel.read(_isgteq);
	if (err == NOERR && _multirel.get(MULTI_FIRST) == cod)
		return _multirel.get(MULTI_SECOND).dup();
	return NULL;
}

long TRiclassifica_cache::decode(const char* tab, const TString& cod)
{
	TToken_string tok;
	tok.add(tab);
	tok.add(cod);
	const TString* ric = (const TString*) objptr(tok);
	return (ric ? atol(*ric) : 0);
}

const TString & TRiclassifica_cache::sdecode_caufor(const TString& cod)
{
  TString & codricl = get_tmp_string();
	TToken_string tok;

	tok.add("SCCAU");
	tok.add(cod);
	const TString* ric = (const TString*) objptr(tok);
	if (ric && *ric)
	{
		_multirel.setkey(1);
		_multirel.put(MULTI_COD, "SCCAU");
		_multirel.put(MULTI_FIRST, cod);
		_multirel.put(MULTI_SECOND, *ric);
		int err = _multirel.read(_isequal);
		if (err == NOERR)
			codricl = _multirel.get(MULTI_DATA).sleft(5);
	}
	return codricl;
}

const TString & TRiclassifica_cache::sdecode_caureg(const TString& cod)
{
  TString & codricl = get_tmp_string();
	TToken_string tok;

	tok.add("SCCAU");
	tok.add(cod);
	const TString* ric = (const TString*) objptr(tok);
	if (ric && *ric)
	{
		_multirel.setkey(1);
		_multirel.put(MULTI_COD, "SCCAU");
		_multirel.put(MULTI_FIRST, cod);
		_multirel.put(MULTI_SECOND, *ric);
		int err = _multirel.read(_isequal);
		if (err == NOERR)
			codricl = _multirel.get(MULTI_DATA).smid(6, 5);
	}
	return codricl;
}

bool TRiclassifica_cache::sdecode_rc(const TString& cod)
{
  TString & codricl = get_tmp_string();
	TToken_string tok;

	tok.add("SCCAU");
	tok.add(cod);
	const TString* ric = (const TString*) objptr(tok);
	if (ric && *ric)
	{
		_multirel.setkey(1);
		_multirel.put(MULTI_COD, "SCCAU");
		_multirel.put(MULTI_FIRST, cod);
		_multirel.put(MULTI_SECOND, *ric);
		int err = _multirel.read(_isequal);
		if (err == NOERR)
			codricl = _multirel.get(MULTI_DATA).smid(5, 1);
	}
	return codricl.full();
}

const TString & TRiclassifica_cache::sdecode_caugiro(const TString& cod)
{
  TString & codricl = get_tmp_string();
	TToken_string tok;

	tok.add("SCCAU");
	tok.add(cod);
	const TString* ric = (const TString*) objptr(tok);
	if (ric && *ric)
	{
		_multirel.setkey(1);
		_multirel.put(MULTI_COD, "SCCAU");
		_multirel.put(MULTI_FIRST, cod);
		_multirel.put(MULTI_SECOND, *ric);
		int err = _multirel.read(_isequal);
		if (err == NOERR)
			codricl = _multirel.get(MULTI_DATA).smid(11, 5);
	}
	return codricl;
}

const TString & TRiclassifica_cache::sdecode_caucon(const TString& cod)
{
  TString & codricl = get_tmp_string();
	TToken_string tok;

	tok.add("SCCAU");
	tok.add(cod);
	const TString* ric = (const TString*) objptr(tok);
	if (ric && *ric)
	{
		_multirel.setkey(1);
		_multirel.put(MULTI_COD, "SCCAU");
		_multirel.put(MULTI_FIRST, cod);
		_multirel.put(MULTI_SECOND, *ric);
		int err = _multirel.read(_isequal);
		if (err == NOERR)
			codricl = _multirel.get(MULTI_DATA).smid(28, 5);
	}
	return codricl;
}

const TString & TRiclassifica_cache::sdecode_sezcon(const TString& cod)
{
  TString & codricl = get_tmp_string();
	TToken_string tok;

	tok.add("SCCAU");
	tok.add(cod);
	const TString* ric = (const TString*) objptr(tok);
	if (ric && *ric)
	{
		_multirel.setkey(1);
		_multirel.put(MULTI_COD, "SCCAU");
		_multirel.put(MULTI_FIRST, cod);
		_multirel.put(MULTI_SECOND, *ric);
		int err = _multirel.read(_isequal);
		if (err == NOERR)
			codricl = _multirel.get(MULTI_DATA).smid(33, 1);
	}
	return codricl;
}

const TString & TRiclassifica_cache::sdecode_contov(const TString& cod)
{
  TString & codricl = get_tmp_string();
	TToken_string tok;

	tok.add("SCCAU");
	tok.add(cod);
	const TString* ric = (const TString*) objptr(tok);
	if (ric && *ric)
	{
		_multirel.setkey(1);
		_multirel.put(MULTI_COD, "SCCAU");
		_multirel.put(MULTI_FIRST, cod);
		_multirel.put(MULTI_SECOND, *ric);
		int err = _multirel.read(_isequal);
		if (err == NOERR)
			codricl = _multirel.get(MULTI_DATA).smid(16, 12);
	}
	return codricl;
}

const char * TRiclassifica_cache::sdecode(const char* tab, const TString& cod)
{
	TToken_string tok;
	tok.add(tab);
	tok.add(cod);
	const TString* ric = (const TString*) objptr(tok);
	return ric ? (const char *) *ric : "";
}

///////////////////////////////////////////////////////////
// TRip_cache
///////////////////////////////////////////////////////////

class TRip_cache : public TCache
{
  TLocalisamfile _rip, _rrip;

protected:
  virtual TObject* key2obj(const char* key);

public:
  bool cdc(int gruppo, int conto, long sottoconto, TString& cdc, TString& cms);

  TRip_cache() : _rip(LF_RIP), _rrip(LF_RRIP) { _rip.setkey(3); }
};

TObject* TRip_cache::key2obj(const char* key)
{
  TToken_string* tok = new TToken_string(key);

  const int g = tok->get_int();
  const int c = tok->get_int();
  const long s = tok->get_long();

  tok->cut(0);

  _rip.zero();
  _rip.put(RIP_TIPO,     "I");
  _rip.put(RIP_GRUPPO,     g);
  _rip.put(RIP_CONTO,      c);
  _rip.put(RIP_SOTTOCONTO, s);
  if (_rip.read(_isgteq) == NOERR && _rip.get_int(RIP_GRUPPO)==g && _rip.get_int(RIP_CONTO)==c && _rip.get_long(RIP_SOTTOCONTO)==s)
  {
    _rrip.zero();
    _rrip.put(RRIP_TIPO,   _rip.get(RIP_TIPO));
    _rrip.put(RRIP_CODICE, _rip.get(RIP_CODICE));
    _rrip.put(RRIP_NRIGA, 1);

    if (_rrip.read() == NOERR)
    {
      tok->add(_rrip.get(RRIP_CODFASE),  0);  // CDC contabile
      tok->add(_rrip.get(RRIP_CODCMS),   1);  // CDC analitico
    }
  }

  return tok;
}

bool TRip_cache::cdc(int gruppo, int conto, long sottoconto, TString& cdc, TString& cms)
{
  TString16 gcs; gcs.format("%d|%d|%d", gruppo, conto, sottoconto);
  const TToken_string* tok = (const TToken_string*)objptr(gcs);
  if (tok && tok->full())
  {
    tok->get(0, cdc);
    tok->get(1, cms);
  }
  else
    cdc = cms = "";
  return cms.full();
}

///////////////////////////////////////////////////////////
// TSISPAC_set
///////////////////////////////////////////////////////////

class TSISPAC_set : public TAS400_recordset
{
protected:
  void add_field(const char* name = "Filler", int from = -1, int len = 0, TFieldtypes t = _alfafld, const char* def = NULL);
  virtual bool set_field(const TAS400_column_info& fi, const TVariant& var);

public:
  TSISPAC_set(const char* header) : TAS400_recordset(header) {}
};

void TSISPAC_set::add_field(const char* name, int from, int len, TFieldtypes t, const char* def)
{
	const bool required = false;
  TString80 fname(name);

  switch (t)
  {
  case _datefld:
    len = 8;
  case _intfld:
  case _intzerofld:
  case _longfld:
    t = _longzerofld;
    break;
  default:
    t = _alfafld;
    break;
  }
  
  const int pos = from - 1;
  if (def && *def)
  {
    CHECKS(def == NULL || (int)strlen(def) <= len, "Invalid default value ", def);
    TVariant var(def); var.convert_to(t);
    create_field(fname, pos, len, t, required, var);
  }
  else
    create_field(fname, pos, len, t, required);
}

bool TSISPAC_set::set_field(const TAS400_column_info& fi, const TVariant& var)
{
  if (var.is_date() && (fi._type == _intzerofld || fi._type == _longzerofld) && 
                       (fi._width == 6          || fi._width == 8))
  {
    long d = var.as_int();
    if (d && fi._width == 6)
      d %= 1000000;
    return TAS400_recordset::set_field(fi, d);
  }
  return TAS400_recordset::set_field(fi, var);
}

///////////////////////////////////////////////////////////
// TMovim_set
///////////////////////////////////////////////////////////

class TMovim_set : public TSISPAC_set
{
public:
  TMovim_set();
};

TMovim_set::TMovim_set() : TSISPAC_set("AS400(217)")
{
  create_field("COFI", -1, 16, _alfafld);
  create_field("PAIV", -1, 11, _alfafld);
  create_field("RAGSOC", -1, 50, _alfafld);
  create_field("ESIVA", -1, 2, _alfafld);
  create_field("ESCOGE", -1, 4, _alfafld);
  create_field("ARGOMENTO", -1, 1, _alfafld);
  create_field("COMPETENZA", -1, 1, _alfafld);
  create_field("NUMPART", -1, 7, _longzerofld);
  create_field("NUMINT", -1, 3, _longzerofld);
  create_field("DATAOP", -1, 6, _longzerofld);
  create_field("CODCONTO", -1, 12, _alfafld);
  create_field("TIPOREG", -1, 2, _longzerofld);
  create_field("CODREG", -1, 2, _longzerofld);
  create_field("NUMPROT", -1, 7, _longzerofld);
  create_field("TIPOART", -1, 1, _longzerofld);
  create_field("TIPOMOV", -1, 1, _alfafld);
  create_field("CODCOST", -1, 3, _longzerofld);
  create_field("CODCAUS", -1, 5, _longzerofld);
  create_field("NUMDESC", -1, 1, _longzerofld);
  create_field("SGNIMPT", -1, 1, _alfafld);
  create_field("IMPORTO", -1, 13, _longzerofld);
  create_field("SGNCONTIMP", -1, 1, _alfafld);
  create_field("ANNOTAZ", -1, 30, _alfafld);
  create_field("DATADOC", -1, 6, _longzerofld);
  create_field("NUMDOC", -1, 7, _alfafld);
  create_field("TIPOANAG", -1, 1, _alfafld);
  create_field("FLGSTO", -1, 1, _alfafld);
  create_field("LIBERO", -1, 20, _alfafld);
  create_field("FINEREC", -1, 2, _alfafld, true, "\r\n");
}

class TIvamov_set : public TSISPAC_set
{
public:
  TIvamov_set();
};

TIvamov_set::TIvamov_set() : TSISPAC_set("AS400(171)")
{
  create_field("COFI", -1, 16, _alfafld);
  create_field("PAIV", -1, 11, _alfafld);
  create_field("RAGSOC", -1, 50, _alfafld);
  create_field("NUMPART", -1, 7, _longzerofld);
  create_field("NUMINT", -1, 2, _longzerofld);
  create_field("SGNIMPB", -1, 1, _alfafld);
  create_field("IMPONIBILE", -1, 13, _longzerofld);
  create_field("SGNIMPIVA", -1, 1, _alfafld);
  create_field("IMPOSTA", -1, 13, _longzerofld);
  create_field("CODCAUS", -1, 5, _longzerofld);
  create_field("CODIVA", -1, 3, _alfafld);
  create_field("FILLER", -1, 2, _alfafld);
  create_field("MERCIVEN", -1, 1, _alfafld);
  create_field("QUADROA", -1, 1, _alfafld);
  create_field("CODCOSTRIC", -1, 6, _alfafld);
  create_field("FLGES", -1, 1, _alfafld);
  create_field("DETRAIB", -1, 5, _longzerofld);
  create_field("CODTABPRODAG", -1, 3, _alfafld);
  create_field("CODIVACOMPAG", -1, 3, _alfafld);
  create_field("DATAFATTSOSP", -1, 1, _alfafld);
  create_field("MULTIPUNTO", -1, 2, _alfafld);
  create_field("LIBERO", -1, 22, _alfafld);
  create_field("FINEREC", -1, 2, _alfafld,true,"\r\n");
}

class TIntramov_set : public TSISPAC_set
{
public:
  TIntramov_set();
};

TIntramov_set::TIntramov_set() : TSISPAC_set("AS400(206)")
{
  create_field("COFI", -1, 16, _alfafld);
  create_field("PAIV", -1, 11, _alfafld);
  create_field("RAGSOC", -1, 50, _alfafld);
  create_field("TIPOREC", -1, 1, _alfafld);
  create_field("ESERCIZIO", -1, 4, _longzerofld);
  create_field("NUMPART", -1, 7, _longzerofld);
  create_field("NUMPROG", -1, 2, _longzerofld); 
  create_field("SGNIMPT", -1, 1, _alfafld);
  create_field("IMPORTO", -1, 13, _longzerofld);
  create_field("SGNVAL", -1, 1, _alfafld);
  create_field("IMPVAL", -1, 13, _longzerofld);
  create_field("TRANSAZ", -1, 1, _longzerofld);
  create_field("NOMENC", -1, 8, _longzerofld);
  create_field("MASSA", -1, 10, _longzerofld);
  create_field("UNIT", -1, 10, _longzerofld);
  create_field("SGNSTAT", -1, 1, _alfafld);
  create_field("IMPVAL", -1, 13, _longzerofld);
  create_field("RGMCONS", -1, 1, _alfafld);
  create_field("MODTRASP", -1, 1, _longzerofld);
  create_field("PAPROV", -1, 2, _alfafld);
  create_field("PADEST", -1, 2, _alfafld);
  create_field("PROVINCIA", -1, 2, _alfafld);
  create_field("MESE", -1, 2, _longzerofld);
  create_field("TRIMESTRE", -1, 1, _longzerofld);
  create_field("ANNO", -1, 1, _longzerofld);
  create_field("SGNATTRIB", -1, 1, _alfafld);
  create_field("ESIVA", -1, 2, _longzerofld);
  create_field("CODCLIFO", -1, 6, _alfafld);
  create_field("LIBERO", -1, 20, _alfafld);
  create_field("FINEREC", -1, 2, _alfafld, true, "\r\n");
}

/* non li abbiamo i ratei
class TRateimov_set : public TSISPAC_set
{
public:
  TRateimov_set();
};

TRateimov_set::TRateimov_set() : TSISPAC_set("AS400(222)")
{
  create_field("COFI", -1, 16, _alfafld);
  create_field("PAIV", -1, 11, _alfafld);
  create_field("RAGSOC", -1, 50, _alfafld);
  create_field("ESCOGEIN", -1, 4, _longzerofld);
  create_field("ESCOGEFI", -1, 4, _longzerofld);
  create_field("NUMPART", -1, 7, _longzerofld); 
  create_field("NUMPROG", -1, 3, _longzerofld);
  create_field("INRATRIS", -1, 8, _longzerofld);
  create_field("FIRATRIS", -1, 8, _longzerofld);
  create_field("CODCPART", -1, 6, _alfafld);
  create_field("CODCCONT", -1, 6, _alfafld);
  create_field("SGNIMPT", -1, 1, _alfafld);
  create_field("IMPORTO", -1, 13, _longzerofld);
  create_field("SGNCNIMPT", -1, 1, _alfafld);
  create_field("CODCLIFO", -1, 6, _alfafld);
  create_field("DATADOC", -1, 8, _longzerofld);
  create_field("NUMDOC", -1, 7, _alfafld);
  create_field("ANNOTAZ", -1, 30, _alfafld);
  create_field("DATAOP", -1, 8, _longzerofld);
  create_field("CCOSTO", -1, 3, _longzerofld);
  create_field("LIBERO", -1, 20, _alfafld);
  create_field("FINEREC", -1, 2, _alfafld,true,"\r\n");
}
*/

class TForsisp_set : public TSISPAC_set
{
public:
  TForsisp_set();
};

TForsisp_set::TForsisp_set() : TSISPAC_set("AS400(304)")
{
  create_field("CODANAG",  -1,  6, _alfafld);
  create_field("COFI",     -1, 16, _alfafld);
  create_field("PAIV",     -1, 11, _alfafld);
  create_field("TIPOANAG", -1,  1, _alfafld);
  create_field("RAGSOC",   -1, 50, _alfafld);
  create_field("INDIRIZZO",-1, 28, _alfafld);
  create_field("NUMERO",   -1,  7, _alfafld); 
  create_field("COMUNE",   -1, 35, _alfafld);
  create_field("CAP",      -1,  5, _longzerofld);
  create_field("STATEST",  -1, 35, _alfafld);
  create_field("TELEFONO", -1, 20, _alfafld);
  create_field("TELEFAX",  -1, 20, _alfafld);
  create_field("TELEX",    -1, 20, _alfafld);
  create_field("PREFISSO", -1,  4, _alfafld);
  create_field("FRAZIONE", -1, 35, _alfafld);
  create_field("PROVINCIA",-1,  2, _alfafld);
  create_field("TESTAZMUN",-1,  1, _alfafld);
  create_field("CODCOM",   -1,  4, _alfafld);
  create_field("CODFRAZ",  -1,  2, _alfafld);
  create_field("FINEREC",  -1,  2, _alfafld,true,"\r\n");
}

class TClisisp_set : public TSISPAC_set
{
public:
  TClisisp_set();
};

TClisisp_set::TClisisp_set() : TSISPAC_set("AS400(304)")
{
  create_field("CODANAG",   -1,  6, _alfafld);
  create_field("COFI",      -1, 16, _alfafld);
  create_field("PAIV",      -1, 11, _alfafld);
  create_field("TIPOANAG",  -1,  1, _alfafld);
  create_field("RAGSOC",    -1, 50, _alfafld);
  create_field("INDIRIZZO", -1, 28, _alfafld);
  create_field("NUMERO",    -1,  7, _alfafld); 
  create_field("COMUNE",    -1, 35, _alfafld);
  create_field("CAP",       -1,  5, _longzerofld);
  create_field("STATEST",   -1, 35, _alfafld);
  create_field("TELEFONO",  -1, 20, _alfafld);
  create_field("TELEFAX",   -1, 20, _alfafld);
  create_field("TELEX",     -1, 20, _alfafld);
  create_field("PREFISSO",  -1,  4, _alfafld);
  create_field("FRAZIONE",  -1, 35, _alfafld);
  create_field("PROVINCIA", -1,  2, _alfafld);
  create_field("TESTAZMUN", -1,  1, _alfafld);
  create_field("CODCOM",    -1,  4, _alfafld);
  create_field("CODFRAZ",   -1,  2, _alfafld);
  create_field("FINEREC",   -1,  2, _alfafld,true,"\r\n");
}

/*
class TMovplus_set : public TSISPAC_set
{
public:
  TMovplus_set();
};

TMovplus_set::TMovplus_set() 
             : TSISPAC_set("AS400(200)")
{
  create_field("COFI", -1, 16, _alfafld);
  create_field("PAIV", -1, 11, _alfafld);
  create_field("RAGSOC", -1, 50, _alfafld);
  create_field("ARGOMENTO", -1, 1, _alfafld);
  create_field("NUMPART", -1, 7, _longzerofld);
  create_field("NUMINT", -1, 3, _longzerofld);
  create_field("PROMEM", -1, 50, _alfafld);
  create_field("NOTEVAR", -1, 1, _alfafld);
  create_field("CODANCOIN", -1, 6, _alfafld);
  create_field("TIPOCOIN", -1, 1, _alfafld);
  create_field("PRIPCOIN", -1, 5, _longzerofld);
  create_field("LIBERO", -1, 47, _alfafld);
  create_field("FINEREC", -1, 2, _alfafld,true,"\r\n");
}
*/

class TMovpart_set : public TSISPAC_set
{
public:
  TMovpart_set();
};

TMovpart_set::TMovpart_set() : TSISPAC_set("AS400(322)")
{
  create_field("COFI", -1, 16, _alfafld);
  create_field("PAIV", -1, 11, _alfafld);
  create_field("RAGSOC", -1, 50, _alfafld);
  create_field("ARGOMENTO", -1, 1, _longzerofld);
  create_field("NUMPART", -1, 7, _longzerofld);
  create_field("NUMINT", -1, 3, _longzerofld);
  create_field("DATAOP", -1, 8, _longzerofld);
  create_field("CODSCONT", -1, 6, _alfafld);
  create_field("CODCLIFO", -1, 6, _alfafld);
  create_field("TIPOREG", -1, 2, _longzerofld);
  create_field("CODREG", -1, 2, _longzerofld);
  create_field("ANNODOC", -1, 4, _longzerofld);
  create_field("NUMDOC", -1, 7, _alfafld);
  create_field("NUMPROT", -1, 7, _longzerofld);
  create_field("DATADOC", -1, 8, _longzerofld);
  create_field("ANNOPAG", -1, 4, _longzerofld);
  create_field("TIPOMOV", -1, 1, _alfafld);
  create_field("CODCAUS", -1, 5, _longzerofld);
  create_field("CODPAG", -1, 6, _alfafld);
  create_field("DATASCAD", -1, 8, _longzerofld);
  create_field("IMPTMOV", -1, 12, _longzerofld);
  create_field("SGNIMPT", -1, 1, _alfafld);
  create_field("CODAG", -1, 3, _alfafld);
  create_field("CODVALEST", -1, 3, _alfafld);
  create_field("CAMBIO", -1, 9, _longzerofld);
  create_field("CODABICF", -1, 5, _longzerofld);
  create_field("CODCABCF", -1, 5, _longzerofld);
  create_field("CODABIAZ", -1, 5, _longzerofld);
  create_field("CODCABAZ", -1, 5, _longzerofld);
  create_field("NUMDOC2", -1, 7, _alfafld);
  create_field("NUMPROT2", -1, 7, _longzerofld);
  create_field("DATADOC2", -1, 8, _longzerofld);
  create_field("ANNOTAZ", -1, 30, _alfafld);
  create_field("TIPOPAG", -1, 1, _longzerofld);
  create_field("DTNEWSCAD", -1, 8, _longzerofld);
  create_field("IMPTSP", -1, 12, _longzerofld);
  create_field("CONTUNI", -1, 8, _longzerofld);
  create_field("IMPTIVA", -1, 12, _longzerofld);
  create_field("TIPOANAG", -1, 1, _alfafld);
  create_field("TIPOVAL", -1, 1, _alfafld);
  create_field("LIBERO", -1, 15, _alfafld);
  create_field("FINEREC", -1, 2, _alfafld,true,"\r\n");
}

class TMovanal_set : public TSISPAC_set
{
public:
  TMovanal_set();
};

TMovanal_set::TMovanal_set() : TSISPAC_set("AS400(351)")
{
  create_field("COFI",       -1, 16, _alfafld);     //   1
  create_field("PAIV",       -1, 11, _alfafld);     //  17 
  create_field("RAGSOC",     -1, 50, _alfafld);     //  28
  create_field("ESCOGE",     -1,  4, _intzerofld);  //  78
  create_field("NUMPART",    -1,  7, _longzerofld); //  82
  create_field("NUMINT",     -1,  3, _intzerofld);  //  89
  create_field("PROGINT",    -1,  3, _intzerofld);  //  92
  create_field("DATAOP",     -1,  8, _longzerofld); //  95
  
  create_field("CODCONTO",   -1,  6, _alfafld);     // 103
  create_field("SGNCONTIMP", -1,  1, _alfafld);     // 109
  create_field("IMPORTO",    -1, 12, _longzerofld); // 110
  create_field("SGNIMPT",    -1,  1, _alfafld);     // 122
  
  create_field("PERC",       -1,  5, _intzerofld);  // 123
  create_field("ANNO",       -1,  4, _intzerofld);  // 128
  create_field("CODCAUS",    -1,  5, _longzerofld); // 132
  create_field("NUMDOC",     -1,  7, _alfafld);     // 137
  create_field("DATADOC",    -1,  8, _longzerofld); // 144
  create_field("NUMPROT",    -1,  7, _longzerofld); // 152
  create_field("CDCCONT",    -1,  6, _alfafld);     // 159

  create_field("COFIANAL",   -1, 16, _alfafld);     // 165 
  create_field("PAIVANAL",   -1, 11, _alfafld);     // 181
  create_field("RAGSOCANAL", -1, 50, _alfafld);     // 192
  create_field("NOTEANAL",   -1, 50, _alfafld);     // 242
  create_field("DATAOPANAL", -1,  8, _longzerofld); // 292
  create_field("DATAFIANAL", -1,  8, _longzerofld); // 300
  create_field("PDC",        -1,  9, _alfafld);     // 308
  create_field("CDC1",       -1,  9, _alfafld);     // 317
  create_field("CDC2",       -1,  9, _alfafld);     // 326

  //create_field("LIBERO",     -1, 15, _alfafld);
  create_field("FINEREC",   349,  2, _alfafld, true,"\r\n");
}

///////////////////////////////////////////////////////////
// TInvioSispac_mask
///////////////////////////////////////////////////////////

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

  TInvioSispac_mask();
  
  virtual ~TInvioSispac_mask(){};
};
  
TInvioSispac_mask::TInvioSispac_mask() :TAutomask ("tc9300a")
{
}  
  
bool TInvioSispac_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{ 
	switch (o.dlg())
	{
	case F_CODDITTA:                               
		if (e == fe_init && o.empty())
		{
			o.set(main_app().get_firm());
			o.check();
			o.disable();
		}	
		break;
	default:
		break;	
	}
  return true;
}

class TInvioSispac : public TSkeleton_application
{                     
	TCursor*				   _cur;
  TInvioSispac_mask* _msk;
	TConfig*					 _configfile;
  TDate							 _dataini, _datafin;
	TRiclassifica_cache *  _tabelle;
 
protected:
  virtual bool create(void);
  virtual bool destroy(void);
  virtual void main_loop() ;
  void invio_sispac();
  void sispac_cli();
  void sispac_for();
  const TString& bill2code(const TISAM_recordset& input) const;

	void sispac_reverse_movim(long numreg, TMovim_set & recset, long firstmov, long lastmov,
														const TString & cofi, const TString & paiv,
														const TString & ragsoc, const TString & esiva,
														const TString &	annoes, bool comp);
	void sispac_reverse_giro(long numreg, TMovim_set & recset, long firstmov, long lastmov,
													 const TString & cofi, const TString & paiv,
													 const TString & ragsoc, const TString & esiva,
												   const TString &	annoes, bool comp);
  void fill_last_cdc(const TString& cdc, TMovim_set& recset) const;
  void sispac_movim();
	void sispac_reverse_moviva(long numreg, TIvamov_set & recset, const TString & cofi,
														 const TString & paiv, const TString & ragsoc);
  void sispac_moviva();
  void sispac_intramov();
	void sispac_movpart();
	void conferma(bool conf = true);
	const TString & scod2ricl(const char* tab, const TString& cod);
	const TString & scod2caucf(const TString& cod);
	const TString & scod2ricl(const char* tab, const TVariant& cod);
	const TString & scod2caureg(const TString& cod);
	const TString & scod2caugiro(const TString& cod);
	const TString & scod2caucon(const TString& cod);
	const TString & scod2sezcon(const TString& cod);
	const TString & scod2contov(const TString& cod);
	bool scod2rc(const TString& cod);
	const long cod2ricl(const char* tab, const TString& cod);
  const char* get_tipo_anag(const TRecordset& input) const;
  const char* get_tipo_anag2(const TRecordset& input) const;

public:
	TConfig& config() {return *_configfile;};
  TInvioSispac() {} ;
  virtual ~TInvioSispac() {} ;
};  

// restituisce un riferimento all' applicazione
inline TInvioSispac& app() { return (TInvioSispac&) main_app();}

const TString & TInvioSispac::scod2ricl(const char* tab, const TString& cod)
{
  TString & codricl = get_tmp_string();

	if (cod.full())
	{
		codricl = _tabelle->sdecode(tab, cod);
		if (codricl.blank())
			codricl = cod;
	}
  return codricl;
}

const TString & TInvioSispac::scod2caucf(const TString& cod)
{
	if (cod.full())
	 return _tabelle->sdecode_caufor(cod);
  return EMPTY_STRING;
}

const TString & TInvioSispac::scod2caureg(const TString& cod)
{
	if (cod.full())
		return _tabelle->sdecode_caureg(cod);
  return EMPTY_STRING;
}

const TString & TInvioSispac::scod2caugiro(const TString& cod)
{
	if (cod.full())
		return _tabelle->sdecode_caugiro(cod);
  return EMPTY_STRING;
}

const TString & TInvioSispac::scod2caucon(const TString& cod)
{
	if (cod.full())
		return _tabelle->sdecode_caucon(cod);
  return EMPTY_STRING;
}

const TString & TInvioSispac::scod2sezcon(const TString& cod)
{
	if (cod.full())
		return  _tabelle->sdecode_sezcon(cod);
  return EMPTY_STRING;
}

const TString & TInvioSispac::scod2contov(const TString& cod)
{
	if (cod.full())
		return _tabelle->sdecode_contov(cod);
  return EMPTY_STRING;
}

bool TInvioSispac::scod2rc(const TString& cod)
{
	if (cod.full())
		return _tabelle->sdecode_rc(cod);
  return false;
}

const TString & TInvioSispac::scod2ricl(const char* tab, const TVariant& cod)
{
	return scod2ricl(tab, cod.as_string());
}

const long TInvioSispac::cod2ricl(const char* tab, const TString& cod)
{
  long codricl = 0;
	if (cod.full())
	{
		codricl = _tabelle->decode(tab, cod);
		if (codricl <= 0 &&	real::is_natural(cod))
			codricl = atol(cod);
	}
  return codricl;
}

const char* TInvioSispac::get_tipo_anag(const TRecordset& input) const
{
  const char* var = "P";

  const char cf = input.get(CLI_COFI).as_string()[0];
  const char pi = input.get(CLI_PAIV).as_string()[0];

  if (isalpha(cf))
    var = isdigit(pi) ? "D" : "P";
  else
  {
    if (isdigit(cf))
      var = isdigit(pi) ? "S" : "A";
    else
      var = isdigit(pi) ? "S" : "F";
  }

  return var;
}

const char* TInvioSispac::get_tipo_anag2(const TRecordset& input) const
{
  const char ta = *get_tipo_anag(input);
  return ta == 'F' ? "2" : "";
}


void TInvioSispac::sispac_cli()
{
	TClisisp_set recset;
	TString query;

	query << "USE " << LF_CLIFO
		    << "\nJOIN " << LF_COMUNI << " INTO " << COM_STATO << "==" << CLI_STATOCF << ' ' << COM_COM << "==" << CLI_COMCF
				<< "\nFROM " << CLI_TIPOCF << "=C"
				<< "\nTO " << CLI_TIPOCF << "=C";

	TISAM_recordset input(query);
	TVariant var;
	TString fcomname;

	fcomname << LF_COMUNI << "." << COM_DENCOM;

	TProgind p(input.items(), TR("Esportazione Clienti"), true, true);

  for (bool ok = input.move_first(); ok ; ok = input.move_next())
  {
		if (!p.addstatus(1L))
			break;
		recset.new_rec();
		
		const long codcli = input.get(CLI_CODCF).as_int();
		
		var = format("%06d", codcli);
		recset.set("CODANAG", var);
		recset.set("COFI", input.get(CLI_COFI));
		recset.set("PAIV", input.get(CLI_PAIV));
		recset.set("TIPOANAG", get_tipo_anag(input));
		recset.set("RAGSOC", input.get(CLI_RAGSOC));
		recset.set("INDIRIZZO", input.get(CLI_INDCF));
		recset.set("NUMERO", input.get(CLI_CIVCF)); 
		TString loc(input.get(CLI_LOCCF).as_string());
		TString comune(input.get(fcomname).as_string());

		if (comune.full())
		{
			if (loc.full())
				loc << " - ";
			loc << comune;
		}
		var = comune;
		recset.set("COMUNE", var);
		recset.set("CAP", input.get(CLI_CAPCF));
		recset.set("FINEREC", "\r\n");

  }	

	TFilename outputname = _configfile->get("PATH", "OPZIONI");
	
	outputname << "/clisisp";
	recset.save_as(outputname);
}

void TInvioSispac::sispac_for()
{
	TForsisp_set recset;
	TString query;

	query << "USE " << LF_CLIFO
		    << "\nJOIN " << LF_COMUNI << " INTO  " << COM_STATO << "==" << CLI_STATOCF << " " << COM_COM << "==" << CLI_COMCF
				<< "\nFROM " << CLI_TIPOCF << "=F"
				<< "\nTO " << CLI_TIPOCF << "=F";

	TISAM_recordset input(query);
	TVariant var;
	TString fcomname;

	fcomname << LF_COMUNI << "." << COM_DENCOM;

	TProgind p(input.items(), TR("Esportazione Fornitori"), true, true);

  for (bool ok = input.move_first(); ok ; ok = input.move_next())
  {
		if (!p.addstatus(1L))
			break;

    recset.new_rec();
		const long codfor = input.get(CLI_CODCF).as_int();
		
		var = format("%06d", codfor);
		recset.set("CODANAG", var);
		recset.set("COFI", input.get(CLI_COFI));
		recset.set("PAIV", input.get(CLI_PAIV));
		recset.set("TIPOANAG", get_tipo_anag(input));
		recset.set("RAGSOC", input.get(CLI_RAGSOC));
		recset.set("INDIRIZZO", input.get(CLI_INDCF));
		recset.set("NUMERO", input.get(CLI_CIVCF)); 
		TString loc(input.get(CLI_LOCCF).as_string());
		TString comune(input.get(fcomname).as_string());

		if (comune.full())
		{
			if (loc.full())
				loc << " - ";
			loc << comune;
		}
		var = comune;
		recset.set("COMUNE", var);
		recset.set("CAP", input.get(CLI_CAPCF));
		recset.set("FINEREC", "\r\n");
  }	

	TFilename outputname = _configfile->get("PATH", "OPZIONI");
	
	outputname << "/forsisp";
	recset.save_as(outputname);
}

const TString& TInvioSispac::bill2code(const TISAM_recordset& input) const
{
  const char tipocf = input.get(RMV_TIPOC).as_string()[0];
  const long sottoconto =	input.get(RMV_SOTTOCONTO).as_int();
	const int conto =	 input.get(RMV_CONTO).as_int();
  int gruppo = input.get(RMV_GRUPPO).as_int();
  if (gruppo >= 10)
    gruppo = 0;

  TString& codice = get_tmp_string();
  if (tipocf > 0)
		codice.format("%01d%02d001%06ld", gruppo, conto, sottoconto);
  else
	  codice.format("%01d%02d%03ld      ", gruppo, conto, sottoconto);
  return codice;
}

void TInvioSispac::sispac_reverse_movim(long numreg, TMovim_set & recset, long firstmov, long lastmov,
																				const TString & cofi, const TString & paiv,
																				const TString & ragsoc, const TString & esiva,
																				const TString &	annoes, bool comp)
{
	TString query;
	TString key;

	query << "USE " << LF_RMOV << " SELECT " <<  RMV_NUMREG << "==" << numreg 
				<< "\nJOIN " << LF_MOV << " INTO " << MOV_NUMREG << "==" << RMV_NUMREG;

	TISAM_recordset input(query);
	TVariant var;
	TVariant treg;
	TVariant tpart;
	TArray tipoart;
	int rdare = 0;
	int ravere = 0;

	for (bool ok = input.move_first(); ok ; ok = input.move_next())
  {
		const long codes = input.get(RMV_ANNOES).as_int();
		const TString4 rowtype = input.get(RMV_ROWTYPE).as_string();
		
		if (rowtype == "F")
			continue;
		recset.new_rec();
		var = cofi;
		recset.set(CLI_COFI, var);  
		var = paiv;
		recset.set(CLI_PAIV, var);
		var = ragsoc;
		recset.set(CLI_RAGSOC, var);
		var = esiva;
		recset.set("ESIVA", var);
		var = annoes;
		recset.set("ESCOGE", var);

		var = "V";
		treg = "03";
		recset.set("ARGOMENTO", var);

  	var = comp ? "1" : "N";
		recset.set("COMPETENZA", var);
	
    var = format("%07ld", input.get(RMV_NUMREG).as_int() + REG_OFFSET);
	  recset.set("NUMPART", var);
		var = format("%03ld", input.get(RMV_NUMRIG).as_int());
	  recset.set("NUMINT", var);
		const TDate datareg(input.get(SLF_MOV "." MOV_DATAREG).as_date());
	  recset.set("DATAOP", datareg.string(brief, '\0', full, full, amg_date));
		const TString8 ccaus(input.get(SLF_MOV "." MOV_CODCAUS).as_string()); 

		TString16 codice;
		if (rowtype == "I") // verificare
			codice = scod2contov(ccaus);
		else
      codice = bill2code(input);
		recset.set("CODCONTO", codice);

    recset.set("TIPOREG", treg);
	  recset.set("CODREG", TVariant("01")); // in futuro campo su registro
		const long prot = input.get(SLF_MOV "." MOV_PROTIVA).as_int();
		var = format("%07ld", prot);
	  recset.set("NUMPROT", var);
		const real* v = (real*)tipoart.objptr(lastmov - firstmov); // qui

		if (v != NULL)
			recset.set("TIPOART", *v);

		TString8 codcaus = scod2caureg(ccaus);
		
		if (input.get(RMV_TIPOC).as_string().full())
		{
			const TString8 codcauscf = scod2caucf(ccaus);
			if (codcauscf.full())
				codcaus = codcauscf;
		}
		var = "R";
		if (codcaus == "00255")
			var = "S";
		recset.set("TIPOMOV", var);
		recset.set("CODCOST", TVariant("000"));
		var = codcaus;
		recset.set("CODCAUS", var);

		recset.set("NUMDESC", TVariant("0"));

		real importo = input.get(RMV_IMPORTO).as_real();

		if (rowtype == "T")
			importo += input.get(SLF_MOV "." MOV_RITFIS).as_real();
		var = "P";
		if (importo < ZERO)
		{
			importo = -importo;
			var = "N";
		}

		recset.set("SGNIMPT", var);
		importo *= CENTO;
		var = importo.string(13, 0, '0');
		recset.set("IMPORTO", var);
		const bool dare = input.get(RMV_SEZIONE).as_string() == "D";
		var = dare ? "A" : "D";
		recset.set("SGNCONTIMP",  var);

    const TDate datadoc(input.get(SLF_MOV "." MOV_DATADOC).as_date());
		var = datadoc.string(brief, '\0', full, full, amg_date);
		recset.set("DATADOC", var);
		recset.set("NUMDOC", input.get(SLF_MOV "." MOV_NUMDOC).as_int());

		var = get_tipo_anag2(recset);
		recset.set("TIPOANAG", var);
		recset.set("FINEREC", "\r\n");
  }	
}

void TInvioSispac::sispac_reverse_giro(long numreg, TMovim_set & recset, long firstmov, long lastmov,
																			 const TString & cofi, const TString & paiv,
																			 const TString & ragsoc, const TString & esiva,
																		   const TString &	annoes, bool comp)
{
	TString query;
	TString key;

	query << "USE " << LF_RMOV << " SELECT " <<  RMV_NUMREG << "==" << numreg 
				<< "\nJOIN " << LF_MOV << " INTO " << MOV_NUMREG << "==" << RMV_NUMREG;

	TISAM_recordset input(query);
	TVariant var;
	TVariant treg;
	TString codice_cf;
	TVariant tpart;
	TArray tipoart;
	int rdare = 0;
	int ravere = 0;

	for (bool ok = input.move_first(); ok ; ok = input.move_next())
  {
		const long codes = input.get(RMV_ANNOES).as_int();
		const TString4 rowtype = input.get(RMV_ROWTYPE).as_string();
		
		if (rowtype == "F")
			continue;

		recset.new_rec();
		var = cofi;
		recset.set(CLI_COFI, var);
		var = paiv;
		recset.set(CLI_PAIV, var);
		var = ragsoc;
		recset.set(CLI_RAGSOC, var);
		var = esiva;
		recset.set("ESIVA", var);
		var = annoes;
		recset.set("ESCOGE", var);

		var = "P";
		treg = "01";
		recset.set("ARGOMENTO", var);
		var = "N";

		const TDate datareg(input.get(SLF_MOV "." MOV_DATAREG).as_date());

		if (comp)
			var = "1";
		recset.set("COMPETENZA", var);
		var = format("%07ld", input.get(RMV_NUMREG).as_int() + GIRO_OFFSET);
	  recset.set("NUMPART", var);
		var = format("%03ld", input.get(RMV_NUMRIG).as_int());
	  recset.set("NUMINT", var);
	  recset.set("DATAOP", datareg.string(brief, '\0', full, full, amg_date));
		const TString8 ccaus(input.get(SLF_MOV "." MOV_CODCAUS).as_string()); 

		TString16 codice;
		if (rowtype == "I") // verificare
			codice = scod2contov(ccaus);
		else
    {
			if (rowtype == "D" || rowtype == "N") // verificare
				codice = codice_cf;
			else
        codice = bill2code(input);
    }
		var = codice;
		recset.set("CODCONTO", var);
		recset.set("TIPOREG", treg);
	  recset.set("CODREG", TVariant("01")); // in futuro campo su registro
		const long prot = input.get(SLF_MOV "." MOV_PROTIVA).as_int();
		var = format("%07ld", prot);
	  recset.set("NUMPROT", var);
		const real  * v = (real *) tipoart.objptr(lastmov - firstmov); // qui

		if (v != NULL)
			recset.set("TIPOART", *v);

		TString8 codcaus = scod2caugiro(ccaus);
		
		if (input.get(RMV_TIPOC).as_string().full())
		{
			const TString8 codcauscf = scod2caucf(ccaus);
			if (codcauscf.full())
				codcaus = codcauscf;
		}
		var = "R";
		if (codcaus == "00255")
			var = "S";
		recset.set("TIPOMOV", var);
		recset.set("CODCOST", TVariant("000"));
		var = codcaus;
		recset.set("CODCAUS", var);

		recset.set("NUMDESC", TVariant("0"));

		real importo = input.get(RMV_IMPORTO).as_real();

		if (rowtype == "T")
			importo += input.get(SLF_MOV "." MOV_RITFIS).as_real();
		var = "P";
		if (importo < ZERO)
		{
			importo = -importo;
			var = "N";
		}

		recset.set("SGNIMPT", var);
		importo *= CENTO;
		var = importo.string(13, 0, '0');
		recset.set("IMPORTO", var);
		recset.set("SGNCONTIMP", input.get(RMV_SEZIONE));
		const TDate datadoc(input.get(SLF_MOV "." MOV_DATADOC).as_date());
		var = datadoc.string(brief, '\0', full, full, amg_date);
		recset.set("DATADOC", var);
		recset.set("NUMDOC", input.get(SLF_MOV "." MOV_NUMDOC).as_int());

    var = get_tipo_anag2(recset);
		recset.set("TIPOANAG", var);

    recset.set("FINEREC", "\r\n");
  }	
}

void TInvioSispac::fill_last_cdc(const TString& cdc, TMovim_set& recset) const
{
  for (bool ok = recset.move_last(); ok; ok = recset.move_prev())
  {
    if (recset.get("CODCOST").as_int() == 0)
      recset.set("CODCOST", cdc);
    else
      break;
  }
}

void TInvioSispac::sispac_movim()
{
	TMovim_set recset;
  TMovanal_set analset;

	TString query;
	TString key;
	TEsercizi_contabili esc;
	long numregrev = -1L;

  TRip_cache rip;

	key << prefix().get_codditta();

	const TRectype & ditta = cache().get(LF_NDITTE, key);
	
	key = ditta.get(NDT_TIPOA);
	key << "|" <<ditta.get_long(NDT_CODANAGR);

	const TRectype & anagr = cache().get(LF_ANAG, key);

	const TString16 paiv(anagr.get(ANA_PAIV));
	const TString16 cofi(anagr.get(ANA_COFI));
	const TString80 ragsoc(anagr.get(ANA_RAGSOC));
	TString4 esiva; esiva.format("%02d", _dataini.year() % 100) ;
	TString4 annoes; annoes << esiva << esiva ;

	query << "USE " << LF_RMOV << " SELECT BETWEEN(" <<  LF_MOV << "." << MOV_DATAREG << "," << _dataini.date2ansi() << "," << _datafin.date2ansi() << ")&&("
		    << LF_MOV << "." << MOV_INVIATO << "!=\"X\")"
				<< "\nJOIN " << LF_MOV << " INTO " << MOV_NUMREG << "==" << RMV_NUMREG;

	TISAM_recordset input(query);
	TVariant var;
	TVariant treg;
	TVariant tpart;
	TArray tipoart;
	long lastmov = -1;
	long firstmov = -1;
	int rdare = 0;
	int ravere = 0;

	TProgind p(input.items() * 2, TR("Esportazione Movimenti"), true, true);

  for (bool ok = input.move_first(); ok ; ok = input.move_next())
  {
		const long nmov = input.get(RMV_NUMREG).as_int();
		TString4 sezione(input.get(RMV_SEZIONE).as_string());

		if (nmov != lastmov)
		{
			if (firstmov < 0)
				firstmov = nmov;
			if (lastmov > 0)
			{
				real v = ZERO;
				
				if (rdare == 1 && ravere > 1)
					v = UNO;
				else
				if (rdare > 1 && ravere == 1)
					v = 2.00;
				else
					if (rdare > 1 && ravere > 1)
						v = 3.00;
				tipoart.add(v, lastmov - firstmov);
			}
			lastmov = nmov;
			rdare = 0;
			ravere = 0;
		}
		if (sezione == "D")
			rdare++;
		else
			ravere++;
		p.addstatus(1L);
		if (p.iscancelled())
			break;
	}
	if (lastmov > 0)
	{
		real v = ZERO;
		
		if (rdare == 1 && ravere > 1)
			v = UNO;
		else
		if (rdare > 1 && ravere == 1)
			v = 2.00;
		else
			if (rdare > 1 && ravere > 1)
				v = 3.00;
		tipoart.add(v, lastmov - firstmov);
	}

	lastmov = 0;
	int nrow = 0;
  
  TString8 lastcdc;
  real impcdc;

	for (bool ok = input.move_first(); ok ; ok = input.move_next())
  {
		const long codes = input.get(RMV_ANNOES).as_int();
		const TString4 rowtype = input.get(RMV_ROWTYPE).as_string();
		const TString8 ccaus(input.get(SLF_MOV "." MOV_CODCAUS).as_string()); 
		const long numreg = input.get(RMV_NUMREG).as_int();
		const TDate datareg(input.get(SLF_MOV "." MOV_DATAREG).as_date());
		const bool comp = codes  != esc.date2esc(datareg);
		TString4 sezione(input.get(RMV_SEZIONE).as_string());

		if (numreg != lastmov)
		{
			lastmov = numreg;
			nrow = 0;
      if (lastcdc.full())
        fill_last_cdc(lastcdc, recset);
      lastcdc.cut(0);
      impcdc = ZERO;
		}
		if (numregrev < 0L && scod2rc(ccaus))
			numregrev = numreg;
		if (rowtype == "F")
			continue;
		if (numregrev > 0L && numreg != numregrev)
		{
			sispac_reverse_movim(numregrev, recset, firstmov, lastmov, cofi, paiv, ragsoc, esiva, annoes, comp);
			sispac_reverse_giro(numregrev, recset, firstmov, lastmov, cofi, paiv, ragsoc, esiva, annoes, comp);
			numregrev = -1L;
		}
		recset.new_rec();
		var = cofi;
		recset.set(CLI_COFI, var);
		var = paiv;
		recset.set(CLI_PAIV, var);
		var = ragsoc;
		recset.set(CLI_RAGSOC, var);
		var = esiva;
		recset.set("ESIVA", var);
		var = annoes;
		recset.set("ESCOGE", var);
		const TString & reg = input.get(SLF_MOV "." MOV_REG).as_string();
		
		if (reg.blank())
		{
			var = "P";
			treg = "01";
		}
		else
		{
			TRegistro r(reg, input.get(SLF_MOV "." MOV_ANNOIVA).as_int());
			switch (r.iva())
			{
			case iva_vendite :
				if (r.corrispettivi())
				{
					var = "S";
					treg = "04";
				}
				else
				{
					var = "V";
					treg = "03";
				}
				break;
			case iva_acquisti :
				var = "A";
				treg = "02";
				break;
			default:
				var = "";
		    treg = "01";
				break;
			}
		}
		const TString4 tipomov = var.as_string();
		recset.set("ARGOMENTO", var);
  	var = comp ? "1" : "N";
		recset.set("COMPETENZA", var);
		var = format("%07ld", numreg);
	  recset.set("NUMPART", var);
		var = format("%03ld", ++nrow);
	  recset.set("NUMINT", var);
	  recset.set("DATAOP", datareg.string(brief, '\0', full, full, amg_date));

		const TString16 codconto = bill2code(input);
		recset.set("CODCONTO", codconto);
		recset.set("TIPOREG", treg);
	  recset.set("CODREG", reg.right(2)); // in futuro campo su registro
		const long prot = input.get(SLF_MOV "." MOV_PROTIVA).as_int();
		var = format("%07ld", prot);
	  recset.set("NUMPROT", var);
		const real  * v = (real *) tipoart.objptr(lastmov - firstmov); // qui

		if (v != NULL)
			recset.set("TIPOART", *v);

		TString8 codcaus = scod2ricl("SCCAU", ccaus); 
		const TString8 codcauscf = scod2caucf(ccaus);
		const TString8 codcauscon = scod2caucon(ccaus);
		const TString4 sezcon = scod2sezcon(ccaus);
		
    const char tipocf = input.get(RMV_TIPOC).as_string()[0];
		if (tipocf >= 'C')
		{
			if (codcauscf.full())
				codcaus = codcauscf;
			else
				if (sezcon == sezione && codcauscon.full())
					codcaus = codcauscon;
		}
		else
    {
			if (sezcon == sezione && codcauscon.full())
				codcaus = codcauscon;
    }
		var = (atoi(codcaus) == 255) ? "S" : "R";   // Come da tracciato
		recset.set("TIPOMOV", var);
		recset.set("CODCOST", TVariant("000"));
		recset.set("CODCAUS", codcaus);
		recset.set("NUMDESC", TVariant("0"));

		real importo = input.get(RMV_IMPORTO).as_real();
		real ritenute = input.get(SLF_MOV "." MOV_RITFIS).as_real();
		if (ritenute != ZERO && rowtype == "T")
			importo += ritenute;

		var = "P";
		if (importo < ZERO)
		{
			importo = -importo;
			var = "N";
		}

		recset.set("SGNIMPT", var);
		importo *= CENTO;
		var = importo.string(13, 0, '0');
		recset.set("IMPORTO", var);
		recset.set("SGNCONTIMP", input.get(RMV_SEZIONE));
		const TDate datadoc(input.get(SLF_MOV "." MOV_DATADOC).as_date());
		var = datadoc.string(brief, '\0', full, full, amg_date);
		recset.set("DATADOC", var);
		recset.set("NUMDOC", input.get(SLF_MOV "." MOV_NUMDOC).as_int());

		var = get_tipo_anag2(recset);
		recset.set("TIPOANAG", var);
		recset.set("FINEREC", "\r\n");
		
    if (tipocf <= ' ' && has_module(CMAUT, CHK_DONGLE) /*&& !has_module(CAAUT, CHK_DONGLE)*/)
    {
      const int gruppo = input.get(RMV_GRUPPO).as_int();
    	const int conto =	 input.get(RMV_CONTO).as_int();
      const long sottoconto =	input.get(RMV_SOTTOCONTO).as_int();

      TString8 cdc, cms;
      if (rip.cdc(gruppo, conto, sottoconto, cdc, cms))
      {
        const real imp = recset.get("IMPORTO").as_real();
        if (lastcdc.blank() || imp > impcdc)
        {
          lastcdc = cdc;
          impcdc = imp;
        }

        analset.new_rec();
        analset.set("COFI",       recset.get("COFI"));
        analset.set("PAIV",       recset.get("PAIV"));
        analset.set("RAGSOC",     recset.get("RAGSOC"));
        analset.set("ESCOGE",     recset.get("ESCOGE"));
        analset.set("NUMPART",    recset.get("NUMPART"));
        analset.set("NUMINT",     recset.get("NUMINT"));
        analset.set("PROGINT",    "001");
        analset.set("DATAOP",     datareg);
        analset.set("CODCONTO",   recset.get("CODCONTO"));
        analset.set("SGNCONTIMP", recset.get("SGNCONTIMP"));
        analset.set("IMPORTO",    recset.get("IMPORTO"));
        analset.set("SGNIMPT",    recset.get("SGNIMPT"));
        analset.set("PERC",       "10000");
        analset.set("ANNO",       (long)datareg.year()); 
        analset.set("CODCAUS",    recset.get("CODCAUS"));
        analset.set("NUMDOC",     recset.get("NUMDOC"));
        analset.set("DATADOC",    datadoc);
        analset.set("NUMPROT",    recset.get("NUMPROT"));
        analset.set("CDCCONT",    cdc);                    // Centro di costo contabile
        analset.set("DATAOPANAL", datareg);
        analset.set("DATAFIANAL", "00000000");             // Come da mail del 01-10-2012
        analset.set("PDC",        recset.get("CODCONTO")); // Conto analitico = conto contabile
        analset.set("CDC1",       cms);                    // Centro di costo analitico  
        analset.set("FINEREC", "\r\n");
      }
    } 
    
		if (!p.addstatus(1L))
			break;
  }	
  if (lastcdc.full())
    fill_last_cdc(lastcdc, recset);

	TFilename outputname = _configfile->get("PATH", "OPZIONI");
  outputname << "\\movim";
	if (!recset.save_as(outputname))
    cantwrite_box(outputname);

  if (analset.items() > 0)
  {
    outputname = _configfile->get("PATH", "OPZIONI");
    outputname << "\\movanal";
    if (!analset.save_as(outputname))
      cantwrite_box(outputname);
  }
}

void TInvioSispac::sispac_reverse_moviva(long numreg, TIvamov_set & recset, const TString & cofi,
																				 const TString & paiv, const TString & ragsoc)
{
	TString query;
	TString key;

	query << "USE " << LF_RMOVIVA << " SELECT " << RMV_NUMREG << "==" << numreg <<
				"\nJOIN " << LF_MOV << " INTO " << MOV_NUMREG << "==" << RMV_NUMREG;

	TISAM_recordset input(query);
	TVariant var;
	for (bool ok = input.move_first(); ok ; ok = input.move_next())
  {
		recset.new_rec();
		var = cofi;
		recset.set("COFI", var);
		var = paiv;
		recset.set("PAIV", var);
		var = ragsoc;
		recset.set("RAGSOC", var);
		var = format("%07ld", input.get(RMI_NUMREG).as_int() + REG_OFFSET);
	  recset.set("NUMPART", var);
		var = format("%03ld", input.get(RMI_NUMRIG).as_int());
	  recset.set("NUMINT", var);
		
		real imponibile = input.get(RMI_IMPONIBILE).as_real();

		var = "P";
		if (imponibile < ZERO)
		{
			imponibile = -imponibile;
			var = "N";
		}

		recset.set("SGNIMPB", var);
		imponibile *= CENTO;
		var = imponibile.string(13, 0, '0');
		recset.set("IMPONIBILE", var);

		real imposta = input.get(RMI_IMPOSTA).as_real();

		var = "P";
		if (imposta < ZERO)
		{
			imposta = -imposta;
			var = "N";
		}

		recset.set("SGNIMPIVA", var);
		imposta *= CENTO;
		var = imposta.string(13, 0, '0');
		recset.set("IMPOSTA", var);
		const TString8 ccaus(input.get(SLF_MOV "." MOV_CODCAUS).as_string()); 
		TString8 codcaus = scod2caureg(ccaus); 
		
		if (input.get(RMI_TIPOC).as_string().full())
		{
			const TString8 codcauscf = scod2caucf(ccaus);
			if (codcauscf.full())
				codcaus = codcauscf;
		}
		var = codcaus;
		recset.set("CODCAUS", var);

		const TString8 civa(input.get(RMI_CODIVA).as_string()); 
		TString8 codiva = scod2ricl("SCIVA", civa); 

		var = codiva;
		recset.set("CODIVA", var);
		recset.set("FILLER", TVariant("00"));
		TVariant var1("M");

		var = "";
		if (codcaus == "00100")
		{
			var = "S";
			var1 = "S";
		}
		else
			if (codcaus == "00110")
			{
				var = "N";
				var1 = "N";
			}
			else
				if (codcaus == "00200" ||	codcaus == "00220" ||
						codcaus == "00255" ||	codcaus == "00301")
					var1 ="M";

 		recset.set("MERCIVEN", var1);
		recset.set("QUADROA", var);
		int tipodet;
		TCausale cau(ccaus, _dataini.year());
		const real percdetr = (CENTO - indetraibile_al(input.get(RMI_TIPODET).as_string(), cau, _dataini.year(), tipodet)) * CENTO;

		var = percdetr.string(5, 0, '0');
		recset.set("DETRAIB", percdetr);
		recset.set("FINEREC", "\r\n");
	}
}

void TInvioSispac::sispac_moviva()
{
	TIvamov_set recset;
	TString query;
	TString key;
	TEsercizi_contabili esc;
	long numregrev = -1L;

	key << prefix().get_codditta();

	const TRectype & ditta = cache().get(LF_NDITTE, key);
	
	key = ditta.get(NDT_TIPOA);
	key << "|" <<ditta.get_long(NDT_CODANAGR);

	const TRectype & anagr = cache().get(LF_ANAG, key);

	const TString16 paiv(anagr.get(ANA_PAIV));
	const TString16 cofi(anagr.get(ANA_COFI));
	const TString80 ragsoc(anagr.get(ANA_RAGSOC));
	const int esiva = _dataini.year() % 100 ;
	TString4 annoes; annoes << esiva << esiva ;

	query << "USE " << LF_RMOVIVA << " SELECT BETWEEN(" <<  LF_MOV << "." << MOV_DATAREG << "," << _dataini.date2ansi() << "," << _datafin.date2ansi() << ")&&("
		    << LF_MOV << "." << MOV_INVIATO << "!=\"X\")"
				<< "\nJOIN " << LF_MOV << " INTO " << MOV_NUMREG << "==" << RMV_NUMREG;

	TISAM_recordset input(query);
	TVariant var;
	int lastmov = 0;
	int nrow = 0;

	TProgind p(input.items(), TR("Esportazione Movimenti IVA"), true, true); // qui

	for (bool ok = input.move_first(); ok ; ok = input.move_next())
  {
		const TString8 ccaus(input.get(SLF_MOV "." MOV_CODCAUS).as_string()); 
		const long numreg = input.get(RMI_NUMREG).as_int();

		if (numreg != lastmov)
		{
			lastmov = numreg;
			nrow = 0;
		}
		TString16 key;

		key << numreg <<"|1";
		if (cache().get(LF_RMOV, key).empty())
			continue;

		if (scod2rc(ccaus))
			numregrev = numreg;
		if (numregrev > 0L && numreg != numregrev)
		{
			sispac_reverse_moviva(numregrev, recset, cofi, paiv, ragsoc);
			numregrev = -1L;
		}
		recset.new_rec();
		var = cofi;
		recset.set("COFI", var);
		var = paiv;
		recset.set("PAIV", var);
		var = ragsoc;
		recset.set("RAGSOC", var);
		var = format("%07ld", numreg);
	  recset.set("NUMPART", var);
		var = format("%03ld", ++nrow);
	  recset.set("NUMINT", var);
		
		real imponibile = input.get(RMI_IMPONIBILE).as_real();

		var = "P";
		if (imponibile < ZERO)
		{
			imponibile = -imponibile;
			var = "N";
		}

		recset.set("SGNIMPB", var);
		imponibile *= CENTO;
		var = imponibile.string(13, 0, '0');
		recset.set("IMPONIBILE", var);

		real imposta = input.get(RMI_IMPOSTA).as_real();

		var = "P";
		if (imposta < ZERO)
		{
			imposta = -imposta;
			var = "N";
		}

		recset.set("SGNIMPIVA", var);
		imposta *= CENTO;
		var = imposta.string(13, 0, '0');
		recset.set("IMPOSTA", var);
		TString8 codcaus = scod2ricl("SCCAU", ccaus); 
		
		if (input.get(RMI_TIPOC).as_string().full())
		{
			const TString8 codcauscf = scod2caucf(ccaus);
			if (codcauscf.full())
				codcaus = codcauscf;
		}
		var = codcaus;
		recset.set("CODCAUS", var);

		const TString8 civa(input.get(RMI_CODIVA).as_string()); 
		TString8 codiva = scod2ricl("SCIVA", civa); 

		var = codiva;
		recset.set("CODIVA", var);
		recset.set("FILLER", TVariant("00"));
		TVariant var1("N");
		TString8 codreg(input.get(SLF_MOV "." MOV_REG).as_string());

		if (codreg.full())
		{
			TRegistro reg(codreg, input.get(SLF_MOV "." MOV_ANNOES).as_int());
			if (reg.iva() == iva_vendite)
				var1 = "M";
		}

		var = "";
		if (codcaus == "00100")
		{
			var = "S";
			var1 = "S";
		}
		else
			if (codcaus == "00110")
			{
				var = "N";
				var1 = "N";
			}
			else
				if (codcaus == "00200" ||	codcaus == "00220" ||
						codcaus == "00255" ||	codcaus == "00301")
					var1 ="M";

 		recset.set("MERCIVEN", var1);
		recset.set("QUADROA", var);
		int tipodet;
		TCausale cau(ccaus, _dataini.year());
		const real percdetr = (CENTO - indetraibile_al(input.get(RMI_TIPODET).as_string(), cau, _dataini.year(), tipodet)) * CENTO;

		var = percdetr.string(5, 0, '0');
		recset.set("DETRAIB", percdetr);
		recset.set("FINEREC", "\r\n");
		p.addstatus(1L);;
		if (p.iscancelled())
			break;

  }	

	TFilename outputname = _configfile->get("PATH", "OPZIONI");
	
	outputname << "/ivamov";
	recset.save_as(outputname);
}

void TInvioSispac::sispac_intramov()
{
/*
	TIntramov_set recset;
	TString query;

	query << "USE " << LF_CLIFO
		    << "\nJOIN " << LF_COMUNI << " INTO  " << COM_STATO << "==" << CLI_STATOCF << " " << COM_COM << "==" << CLI_COMCF << "\n"
				<< "FROM " << CLI_TIPOCF << "=F\n"
				<< "TO " << CLI_TIPOCF << "=F";

	TISAM_recordset input(query);
	TVariant var;

  for (bool ok = input.move_first(); ok ; input.move_next())
  {
  }	

	TFilename outputname = _configfile->get("PATH", "OPZIONI");
	
	outputname << "intramov";
	recset.save_as(outputname); */
}

void TInvioSispac::sispac_movpart()
{
/*
	TMovpart_set recset;
	TString query;

	query << "USE " << LF_CLIFO
		    << "\nJOIN " << LF_COMUNI << " INTO  " << COM_STATO << "==" << CLI_STATOCF << " " << COM_COM << "==" << CLI_COMCF << "\n"
				<< "FROM " << CLI_TIPOCF << "=F\n"
				<< "TO " << CLI_TIPOCF << "=F";

	TISAM_recordset input(query);
	TVariant var;

  for (bool ok = input.move_first(); ok ; input.move_next())
  {
  }	

	TFilename outputname = _configfile->get("PATH", "OPZIONI");
	
	outputname << "movpart";
	recset.save_as(outputname);
	*/
}

void TInvioSispac::conferma(bool conf)
{
	TString query;

	query << "USE " << LF_MOV << "KEY 2"
		    << "\nFROM " << RMV_DATAREG << "=" << _dataini.date2ansi()
		    << "\nTO " << RMV_DATAREG << "=" << _datafin.date2ansi();

	TISAM_recordset mov(query);

	if (mov.items() > 0L)
	{
		TProgind pi(mov.items(), conf ? TR("Conferma movimenti") : TR("Ripristino movimenti"), true, true);
		TLocalisamfile cgmov(LF_MOV);
	
		for (bool ok = mov.move_first(); ok; ok = mov.move_next())
		{
			if (!pi.addstatus(1))
				break;

			const long numreg = mov.get(MOV_NUMREG).as_int();

			cgmov.put(MOV_NUMREG, numreg);
			if (cgmov.read(_isequal, _lock) == NOERR)
			{
				cgmov.put(MOV_INVIATO, conf);
				cgmov.rewrite();
			}
		}
	}
}

void TInvioSispac::invio_sispac()
{
	if (_msk->get_bool(F_CLIFOR))
	{
		sispac_cli();
		sispac_for();
	}
	if (_msk->get_bool(F_RIPRISTIN0))
		conferma(false);
	if (_msk->get_bool(F_MOVCONT))
	{
		sispac_movim();
		sispac_moviva();
		sispac_intramov();
		sispac_movpart();
		if (yesno_box(TR("Confermare il traferimento")))
		{
	  	_configfile->set("NUMEROINVIO", _msk->get(F_NUMEROINVIO),"OPZIONI");
			_configfile->set("DATA", _msk->get_date(F_DATAFIN),"OPZIONI");
			conferma();
		}
	}	
}

bool TInvioSispac::create()
{
  _msk = new TInvioSispac_mask();
	
	TFilename configname = "tc9300conf.ini";
	configname.custom_path();
	_configfile = new TConfig(configname);
	_tabelle = new TRiclassifica_cache;
  return TSkeleton_application::create();
}

bool TInvioSispac::destroy()
{ 
	delete _tabelle;
	delete _configfile;
	delete _msk;
  return TSkeleton_application::destroy();
}

void TInvioSispac::main_loop()
{
	_msk->set(F_NUMEROINVIO, _configfile->get_int("NUMEROINVIO","OPZIONI")+1);
	_msk->set(F_DATAINI, _configfile->get("DATA","OPZIONI"));
	_msk->set(F_DESTINAZIONE, _configfile->get("PATH","OPZIONI"));
  while (_msk->run() != K_QUIT)
  {                                  
  	_configfile->set("PATH", _msk->get(F_DESTINAZIONE),"OPZIONI");
  	_dataini = _msk->get_date(F_DATAINI);
  	_datafin = _msk->get_date(F_DATAFIN);
		invio_sispac();
		_msk->set(F_NUMEROINVIO, _configfile->get_int("NUMEROINVIO","OPZIONI")+1);
		_msk->set(F_DESTINAZIONE, _configfile->get("PATH","OPZIONI"));
	}	
}

int tc9300(int argc, char **argv) 
{
  TInvioSispac a;
  a.run(argc, argv, TR("Invio contabilità Sispac/Cosmo"));
  return 0;
}