#include "pg0001.h"
#include "pg0001200a.h"

#include <automask.h>
#include <progind.h>
#include <reprint.h>

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

#include "..\tc\tc0701.h"

///////////////////////////////////////////////////////////
// TClifo_recset
///////////////////////////////////////////////////////////

class TClifo_recset : public TAS400_recordset
{
	TAssoc_array _index;

protected:
  void add_field(const char* name = "Filler", int from = -1, char tipo = 'a', 
								 int len = 0, const char* def = NULL);

public:
	bool find(char tipocf, long codcf);
  virtual const TVariant& get(const char* column_name) const;
 
  TClifo_recset(const char * query);
};

void TClifo_recset::add_field(const char* name, int from, char tipo, int len, const char* def)
{
	const bool required = false;
  const TFieldtypes t = tipo == 'n' ? _longzerofld : _alfafld;
  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(name, pos, len, t, required, var);
  }
  else
    create_field(name, pos, len, t, required);
}

const TVariant& TClifo_recset::get(const char* column_name) const
{
	TFixed_string fname(column_name);

	if (fname == CLI_COFI)
	{
		TVariant& var = get_tmp_var();
		TString80 s(TAS400_recordset::get(fname).as_string());

		var.set(s.trim());
		return var;
	}
	return TAS400_recordset::get(fname);
}


TClifo_recset::TClifo_recset(const char * query)
             : TAS400_recordset(TString("AS400(213)\n") << query)
{
  const char a = 'a';
  const char n = 'n';
  const bool o = true;
  const bool f = false;
  
  add_field(CLI_TIPOCF,	   1, a,	1);	
  add_field(CLI_CODCF,		 2, n,	6);
  add_field("LIBERO",	     8, a,	10);
  add_field(CLI_RAGSOC,	  18, a,	50);
  add_field(CLI_INDCF,		68, a,	30);
  add_field(CLI_CAPCF,	  98, n,	5);
  add_field(CLI_LOCCF,	 103, a,	25);
  add_field("PROV",	     128, a,	2);
  add_field("LIBERO2",   130, a,	9);
  add_field(CLI_COFI,	   139, a,	16);
  add_field("LIBERO3",   155, a,	45);
  add_field(CLI_PAIV,	   201, a,	11);
	add_field("FINE-RECORD", 211, a, 2, "\r\n");		// terminatore record

	TString16 pos, key;

  for (bool ok = move_first(); ok; ok = move_next())
	{
		pos.format("%ld", current_row());
		key.format("%c|%ld", get(CLI_TIPOCF).as_string()[0], get(CLI_CODCF).as_int());
		
		_index.add(key, pos);
	}
}

bool TClifo_recset::find(char tipocf, long codcf)
{
	TString16 key;

	key.format("%c|%ld", tipocf, codcf);

	TString * s = (TString *) _index.objptr(key);
	long pos = 0L;
	const bool ok =	s && s->full();
  
	if (ok)
		pos = atoi(*s);
	move_to(pos);
	return ok;
}

class TMov_recset;

///////////////////////////////////////////////////////////
// TIVA_recset
///////////////////////////////////////////////////////////

class TIVA_recset : public TAS400_recordset
{

	TRecnotype _first, _last;
	long _numreg;

private:
  void add_field(const char* name = "Filler", int from = -1, char tipo = 'a', 
								 int len = 0, const char* def = NULL);

public:
	bool find(long numreg);
  virtual const TVariant& get(const char* column_name) const;
  virtual bool move_to(TRecnotype pos);

  TIVA_recset(TMov_recset & mov);
};

///////////////////////////////////////////////////////////
// TRMov_recset
///////////////////////////////////////////////////////////

class TRMov_recset : public TAS400_recordset
{
	TRecnotype _first, _last;
	long _numreg;

private:
  void add_field(const char* name = "Filler", int from = -1, char tipo = 'a', 
								 int len = 0, const char* def = NULL);


public:
	bool find(long numreg);
  virtual const TVariant& get(const char* column_name) const;
  virtual bool move_to(TRecnotype pos);

  TRMov_recset(TMov_recset & mov);
};

///////////////////////////////////////////////////////////
// TMov_recset
///////////////////////////////////////////////////////////

class TMov_recset : public TAS400_recordset
{
	bool _indetraibile;
protected:
  void add_field(const char* name = "Filler", int from = -1, char tipo = 'a', 
								 int len = 0, const char* def = NULL);

public:
	bool vendite() const { return get("TIPOR").as_int() == 2;}
	bool acquisti() const { return !vendite();}
	bool fattura() const { return get("TIPOM").as_int() == 0;}
	bool nota_credito() const { return !fattura();}
  virtual const TVariant& get(const char* column_name) const;
	bool indetraibile() const { return _indetraibile;}
 
  TMov_recset(const char * query, TArray & recsets);
};

void TMov_recset::add_field(const char* name, int from, char tipo, int len, const char* def)
{
	const bool required = false;
  const TFieldtypes t = tipo == 'n' ? _longzerofld : _alfafld;
  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(name, pos, len, t, required, var);
  }
  else
    create_field(name, pos, len, t, required);
}

const TVariant& TMov_recset::get(const char* column_name) const
{
	TString16 fname(column_name);
	TVariant& var = get_tmp_var();

	if (fname == MOV_TIPO)
	{
		var = vendite() ? "C" : "F";
		return var;
	}
	else
		if (fname == MOV_REG)
		{
			var = vendite() ? "V00" : "A00";
			return var;
		}
		else
			if (fname == MOV_CODCF)
			{
				if (vendite())
					fname = fattura() ? "S1" : "S2";
				else
					fname = fattura() ? "S2" : "S1";
			}
			else
				if (fname == MOV_CODCAUS)
				{
					((TMov_recset *)this)->_indetraibile = TAS400_recordset::get("CODCAUSO").as_int() == 4;
					int ccaus;

					if (vendite())
						ccaus = fattura() ? 1 : 2;
					else
						ccaus = fattura() ? 11 : 12;
					var.set(ccaus);
					return var;
				}

	var = TAS400_recordset::get(fname);

	if (fname == MOV_DATAREG ||	fname == MOV_DATADOC)
	{
		const TDate d(atol(var.as_string()) + 20000000L);

		var.set(d);
	}
	else
		if (fname == MOV_TOTDOC || fname == RMI_IMPONIBILE ||
				fname == RMI_IMPOSTA)
		{
			const real r = var.as_real() / CENTO;
				
			var.set(r);
		}
	return var;
}

TMov_recset::TMov_recset(const char * query, TArray & recsets)
           : TAS400_recordset(TString("AS400(543)\n") << query),
					    _indetraibile(false)
{
  const char a = 'a';
  const char n = 'n';
  
  add_field("TIPOR",	     1, n,	1);	
  add_field("L00",  	     2, a,	6);
  add_field("L01",	       8, n,	1);
  add_field("L02",	       9, n,	4);
  add_field("NUMREG",	    13, n,	7);
  add_field("L03",	      20, n,	2);
  add_field("PROG",	      22, n,	1);
  add_field("L04",	      23, n,	2);
  add_field("L05",	      25, a,	2);
  add_field(MOV_DATAREG,	27, a,	6);
  add_field("L07",				33, a,	6);
  add_field("L08",		    39, a,	1);
  add_field(MOV_PROTIVA,	40, n,	7);
  add_field(MOV_NUMDOC,	  47, n,	9);
  add_field(MOV_DATADOC,  56, a,	6);
  add_field("L09",	      62, a,	1);
  add_field("CODCAUSO" ,	63, n,	2);
  add_field(RMI_CODIVA,	  65, n,	2);
  add_field("TIPOM",	    67, n,	1);	
  add_field("L10",	      68, a,	18);
  add_field("G1",	        86, a,	2);
  add_field("C1",     	  88, a,	2);
  add_field("S1",     	  90, n,	7);
  add_field("L11",	      97, n,	6);
  add_field("G2",	       103, a,	2);
  add_field("C2",     	 105, a,	2);
  add_field("S2",     	 107, n,	7);
  add_field("L12",	     114, n,	6);
  add_field("G3",	       120, a,	2);
  add_field("C3",     	 122, a,	2);
  add_field("S3",     	 124, n,	7);
  add_field("L13",	     131, a,	152);
  add_field("ANNO",	     283, n,	4);
  add_field("NUMDOC1",   287, a,	13);
  add_field("L15",	     300, a,	18);
  add_field("CODICEE",	 318, a,	1);
  add_field("L16",	     319, a,	29);
  add_field("L17",	     348, a,	20);
  add_field("L18",	     368, a,	68);
  add_field("L19",	     131, a,	152);
  add_field("L20",	     436, n,	1);
  add_field("L21",	     437, a,	24);
  add_field("L22",	     461, a,	39);
  add_field("ANNULLATO", 500, a,	1);
  add_field("L23",	     501, a,	5);
  add_field(RMI_IMPONIBILE,	506, n,	11);
  add_field(RMI_IMPOSTA, 517, n,	9);
  add_field(MOV_TOTDOC,	 526, n,	11);
  add_field("L24",	     537, n,	5);
	add_field("FINE-RECORD", 541, a, 2, "\r\n");		// terminatore record

	bool ok;

	for (ok = move_last(); ok;)
	{
		const int p = current_row();

		if (get("ANNULLATO").as_string()[0] == 'A')
		{
			destroy(p);
			if (p <= last())
				move_to(p);
			else
				move_last();
		}
		else
			ok = move_prev();
	}
	
	long numreg = 0L;

	for (ok = move_first(); ok; ok = move_next())
	{
		if (get("PROG").as_int() == 1)
			numreg++;
		set(MOV_NUMREG, numreg);
	}

	recsets.add(new TIVA_recset(*this), LF_RMOVIVA);
	recsets.add(new TRMov_recset(*this), LF_RMOV);

	for (ok = move_last(); ok;)
	{
		const int p = current_row();

		if (get("PROG").as_int() > 1)
		{
			destroy(p);
			if (p <= last())
				move_to(p);
			else
				move_last();
		}
		else
			ok = move_prev();
	}
}

///////////////////////////////////////////////////////////
// TIVA_recset
///////////////////////////////////////////////////////////

void TIVA_recset::add_field(const char* name, int from, char tipo, int len, const char* def)
{
	const bool required = false;
  const TFieldtypes t = tipo == 'n' ? _longzerofld : _alfafld;
  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(name, pos, len, t, required, var);
  }
  else
    create_field(name, pos, len, t, required);
}

bool TIVA_recset::find(long numreg)
{
	if (numreg != _numreg)
	{
		_first = _last = -1L;

		bool ok = false;
		TRecnotype f = 0L, l = last();
		TRecnotype pos = f + (l - f) / 2;

		while (!ok && f <= l)
		{
			TAS400_recordset::move_to(pos);
			
			const long n = get(RMI_NUMREG).as_int();
			
			if (n > numreg)
				l = pos - 1;
			else
				if (n < numreg)
					f = pos + 1;
				else
				{
					f = pos;
					ok = true;
				}
			pos = f + (l - f) / 2;
		}
		if (ok)
		{
			bool ok1 = TAS400_recordset::move_to(f);

			while (ok1 && numreg == get(RMV_NUMREG).as_int())
			{
				f = current_row();
				ok1 = TAS400_recordset::move_prev();
			}
			ok1 = TAS400_recordset::move_to(f);
			while (ok1 && numreg == get(RMV_NUMREG).as_int())
			{
				l = current_row();
				ok1 = TAS400_recordset::move_next();
			}
			_first = f;
			_last = l;
			_numreg = numreg;
		}
		return ok;
	}
	return true;
}

const TVariant& TIVA_recset::get(const char* column_name) const
{
	const TFixed_string fname(column_name);

	if (fname == RMI_IMPONIBILE || fname == RMI_IMPOSTA)
	{
		TVariant& var = get_tmp_var();
	
		var.set(TAS400_recordset::get(fname).as_real() / CENTO);
		return var;
	}
	return TAS400_recordset::get(fname);
}

bool TIVA_recset::move_to(TRecnotype pos)
{
	if (_first < 0L)
		return TAS400_recordset::move_to(pos);
	if (pos == 0L)
		pos = _first;
	if (pos <= _last)
		return TAS400_recordset::move_to(pos);
	return false;
}

TIVA_recset::TIVA_recset(TMov_recset & mov)
						:TAS400_recordset("AS400(62)\n"),
						 _first(-1L), _last(-1L), _numreg(-1L)
{
  const char a = 'a';
  const char n = 'n';
	TVariant var;

  add_field(RMI_NUMREG,	     1, n,	7);	
  add_field(RMI_NUMRIG,	     8, n,	3);	
  add_field(RMI_CODIVA,	    11, n,	4);	
  add_field(RMI_IMPONIBILE, 15, n,	15);	// 18
  add_field(RMI_IMPOSTA,    30, n,	15);	// 18
  add_field(RMI_TIPODET,    45, n,	1);	
  add_field(RMI_TIPOCR,	    46, n,	1);	
  add_field(RMI_INTRA,	    47, a,	1);	
  add_field(RMI_TIPOATT,    48, n,	1);	
  add_field(RMI_TIPOC,	    49, a,	1);	
  add_field(RMI_GRUPPO,			50, n,	3);
  add_field(RMI_CONTO,			53, n,	3);	  // 18
  add_field(RMI_SOTTOCONTO, 56, n,	6);	
	TString4 fgr, fco, fso;

	for (bool ok = mov.move_first(); ok; ok = mov.move_next())
	{
		new_rec();
	  set(RMI_NUMREG,	mov.get(MOV_NUMREG));
	  set(RMI_NUMRIG,	mov.get("PROG"));

		int civa = mov.get(RMI_CODIVA).as_int();
		int ccaus = mov.get("CODCAUSO").as_int();
		const bool indetraibile = mov.indetraibile();

		civa += ccaus * 100;
		if (civa == 0)
			civa = 310;
		else
			if (indetraibile)
				set(RMI_TIPODET, "9");
		var.set(civa);
		set(RMI_CODIVA, var);
		set(RMI_IMPONIBILE, mov.TAS400_recordset::get(RMI_IMPONIBILE));
		set(RMI_IMPOSTA, mov.TAS400_recordset::get(RMI_IMPOSTA));
		if (mov.vendite())
		{
			if (mov.fattura())
			{
				fgr =	"G2";	fco =	"C2";	fso =	"S2";
			}
			else
			{
				fgr = "G1"; fco = "C1";	fso = "S1";
			}
		}
		else
		{
			if (mov.fattura())
			{
				fgr = "G1"; fco = "C1";	fso = "S1";
			}
			else
			{
				fgr =	"G2"; fco =	"C2"; fso =	"S2";
			}
		}
		set(RMI_GRUPPO,	mov.get(fgr));
		set(RMI_CONTO, mov.get(fco));
		set(RMI_SOTTOCONTO,mov.get(fso));	
	}
}

///////////////////////////////////////////////////////////
// TRMov_recset
///////////////////////////////////////////////////////////

void TRMov_recset::add_field(const char* name, int from, char tipo, int len, const char* def)
{
	const bool required = false;
  const TFieldtypes t = tipo == 'n' ? _longzerofld : _alfafld;
  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(name, pos, len, t, required, var);
  }
  else
    create_field(name, pos, len, t, required);
}

bool TRMov_recset::find(long numreg)
{
	if (numreg != _numreg)
	{
		_first = _last = -1L;

		bool ok = false;
		TRecnotype f = 0L, l= last();
		TRecnotype pos = f + (l - f) / 2;

		while (!ok && f <= l)
		{
			TAS400_recordset::move_to(pos);
			
			const long n = get(RMV_NUMREG).as_int();
			
			if (n > numreg)
				l = pos - 1;
			else
				if (n < numreg)
					f = pos + 1;
				else
				{
					f = pos;
					ok = true;
				}
			pos = f + (l - f) / 2;
		}
		if (ok)
		{
			bool ok1 = TAS400_recordset::move_to(f);

			while (ok1 && numreg == get(RMV_NUMREG).as_int())
			{
				f = current_row();
				ok1 = TAS400_recordset::move_prev();
			}
			ok1 = TAS400_recordset::move_to(f);
			while (ok1 && numreg == get(RMV_NUMREG).as_int())
			{
				l = current_row();
				ok1 =TAS400_recordset:: move_next();
			}
			_first = f;
			_last = l;
			_numreg = numreg;
		}
		return ok;
	}
	return true;
}

const TVariant& TRMov_recset::get(const char* column_name) const
{
	const TFixed_string fname(column_name);

	if (fname == RMV_IMPORTO)
	{
		TVariant& var = get_tmp_var();
	
		var.set(TAS400_recordset::get(fname).as_real() / CENTO);
		return var;
	}
	return TAS400_recordset::get(fname);
}

bool TRMov_recset::move_to(TRecnotype pos)
{
	if (_first < 0L)
		return TAS400_recordset::move_to(pos);
	if (pos == 0L)
		pos = _first;
	if (pos <= _last)
		return TAS400_recordset::move_to(pos);
	return false;
}

TRMov_recset::TRMov_recset(TMov_recset & mov)
						 :TAS400_recordset("AS400(99)\n"),
						  _first(-1L), _last(-1L), _numreg(-1L)

{
  const char a = 'a';
  const char n = 'n';
	TVariant var;
	int row = 1;
	TString4 fgr, fco, fso;
	TVariant sez, tipo;

  add_field(RMV_NUMREG,	     1, n,	7);	
  add_field(RMV_NUMRIG,	     8, n,	3);	
  add_field(RMV_SEZIONE,	  11, a,	1);	
  add_field(RMV_TIPOC,	    12, a,	1);	
  add_field(RMV_GRUPPO,			13, n,	3);
  add_field(RMV_CONTO,			16, n,	3);
  add_field(RMV_SOTTOCONTO, 19, n,	6);	
  add_field(RMV_DESCR,			25, a,	50);
  add_field(RMV_IMPORTO,    85, n,	15); // 18

	for (bool ok = mov.move_first(); ok; ok = mov.move_next())
	{
		const int prog = mov.get("PROG").as_int();

		if (prog == 1)
		{
			row = 1;

			// 1o conto cliente/fornitore solo sul primo record
			new_rec();
		  set(RMV_NUMREG,	mov.get(MOV_NUMREG));
		
			var.set(row++);
			set(RMV_NUMRIG,	var);
			if (mov.vendite())
			{
				if (mov.fattura())
				{
					fgr = "G1"; fco = "C1";	fso = "S1";
					sez = "D";
				}
				else
				{
					fgr =	"G2";	fco =	"C2";	fso =	"S2";
					sez = "A";
				}
			}
			else
			{
				if (mov.fattura())
				{
					fgr =	"G2"; fco =	"C2"; fso =	"S2";
					sez = "A";
				}
				else
				{
					fgr = "G1"; fco = "C1";	fso = "S1";
					sez = "D";
				}
			}
			set(RMV_SEZIONE, sez);
			tipo = mov.vendite() ? "C" : "F";
			set(RMV_TIPOC, tipo);
			set(RMV_GRUPPO,	mov.get(fgr));
			set(RMV_CONTO, mov.get(fco));
			set(RMV_SOTTOCONTO,mov.get(fso));	
			set(RMV_IMPORTO, mov.TAS400_recordset::get(MOV_TOTDOC));
		}
		else 
			int i = 0;

		// 2o conto costo/ricavo
		int ccaus = mov.get(MOV_CODCAUS).as_int();
		const bool indetraibile = mov.indetraibile();

		new_rec();
	  set(RMV_NUMREG,	mov.get(MOV_NUMREG));
		var.set(row++);
		set(RMV_NUMRIG,	var);
		if (mov.vendite())
		{
			sez = "A"; // trucco perchè non si può usare test_swap
			if (mov.fattura())
			{
				fgr =	"G2";	fco =	"C2";	fso =	"S2";
			}
			else
			{
				fgr = "G1"; fco = "C1";	fso = "S1";
				sez = "D";
			}
		}
		else
		{
			sez = "D";  // trucco perchè non si può usare test_swap
			if (mov.fattura())
			{
				fgr = "G1"; fco = "C1";	fso = "S1";
			}
			else
			{
				fgr =	"G2"; fco =	"C2"; fso =	"S2";
			}
		}
		set(RMV_SEZIONE, sez);
		set(RMV_GRUPPO,	mov.get(fgr));
		set(RMV_CONTO, mov.get(fco));
		set(RMV_SOTTOCONTO,mov.get(fso));	
		
		real importo = mov.TAS400_recordset::get(RMI_IMPONIBILE).as_real();
		
		if (indetraibile)
			importo += mov.TAS400_recordset::get(RMI_IMPOSTA).as_real();

		set(RMV_IMPORTO, importo);

		// 3o conto IVA
		if (!indetraibile && !mov.TAS400_recordset::get(RMI_IMPOSTA).as_real().is_zero())
		{
			new_rec();
			set(RMV_NUMREG,	mov.get(MOV_NUMREG));
			var.set(row++);
			set(RMV_NUMRIG,	var);
				if (mov.vendite())
					sez = mov.fattura() ? "A" : "D";
				else
					sez = mov.fattura() ? "D" : "A";
			set(RMV_SEZIONE, sez);
			set(RMV_GRUPPO,	mov.get("G3"));
			set(RMV_CONTO, mov.get("C3"));
			set(RMV_SOTTOCONTO,mov.get("S3"));	
			set(RMV_IMPORTO, mov.TAS400_recordset::get(RMI_IMPOSTA));
		}
		else
			int i = 0;
	}
}

///////////////////////////////////////////////////////////
// TMaestri_mask
///////////////////////////////////////////////////////////

class TMaestri_mask : public TAutomask
{
private:
  void serialize(bool bSave);
protected:
  bool on_field_event(TOperable_field& o, TField_event e, long jolly);
public:
  TMaestri_mask();
  virtual ~TMaestri_mask();
};

TMaestri_mask::TMaestri_mask() : TAutomask("pg0001200a")
{
  serialize(false);
}

TMaestri_mask::~TMaestri_mask()
{
  serialize(true);
}

bool TMaestri_mask::on_field_event(TOperable_field& f, TField_event e, long jolly)
{ 
  return TRUE;
}

HIDDEN bool browse_file_handler(TMask_field& f, KEY k)
{
  if (k == K_F9)
  {  
    FILE_SPEC fs; memset(&fs, 0, sizeof(FILE_SPEC));
    strcpy(fs.type, "");
    strcpy(fs.name, f.get());
    xvt_fsys_get_default_dir(&fs.dir);
    xvt_fsys_save_dir();
    if (xvt_dm_post_file_open(&fs, TR("Selezione file")) == FL_OK)
    {       
      TFilename n;
      xvt_fsys_convert_dir_to_str(&fs.dir, n.get_buffer(n.size()), n.size());
      n.add(fs.name);
      f.set(n);
    }
    xvt_fsys_restore_dir();
    f.set_focus();
  }
  
  return TRUE;
}

void TMaestri_mask::serialize(bool bSave)
{
  const char* defpar = "tc";
  TConfig ini(CONFIG_DITTA, defpar);
  for (int i = fields()-1; i >= 0; i--)
  {
    TMask_field& f = fld(i);
    const TFieldref* fr = f.field();
    if (fr != NULL)
    {
      if (bSave)
        fr->write(ini, defpar, f.get());
      else
        f.set(fr->read(ini, defpar));
    }
  }
}

///////////////////////////////////////////////////////////
// TMaestri_sender
///////////////////////////////////////////////////////////
class TMaestri_sender : public TTS_sender
{
	TMaestri_mask * _mask;

protected:
//	virtual bool test_swap(const TRecordset& mov) { return ((TMov_recset&)mov).nota_credito();}

protected:
	virtual TRecordset & movrecset();
	virtual TRecordset & rmovrecset(const TRecordset & mov);
	virtual TRecordset & rivarecset(const TRecordset & mov);
	virtual const TRecordset & clirecset(const char tipocf, const long codcf);
	virtual const char * decode_causale(const TRecordset& mov);
	virtual TMask & get_mask();
  virtual const char * extra_modules() const {return "ba";}

public:
	virtual void update_parameters(const TMask & m, TRecordset & mov) {}
	TMaestri_sender() : _mask(NULL) {}
};

TMaestri_sender& app() { return (TMaestri_sender&)main_app(); }

TMask & TMaestri_sender::get_mask()
{
	if (_mask == NULL)
		_mask = new TMaestri_mask;

	return * _mask;
}

const char * TMaestri_sender::decode_causale(const TRecordset& mov)
{
  const int codcaus = mov.get(MOV_CODCAUS).as_int();

	switch (codcaus)
	{
	case 1:
		return "Fattura di vendita";
	case 2:
		return "Nota di credito a cliente";
	case 11:
		return "Fattura di acquisto";
	case 12:
		return "Nota di credito da fornitore";
	default:
		break;
	}
	return "";
}

TRecordset & TMaestri_sender::movrecset()
{

	TRecordset * mov = get_recset(LF_MOV);

	if (mov == NULL)
	{
		TString query("SELECT * FROM ");
		TMask & m = get_mask();
		TFilename name = m.get(F_INPATH);

		name.add(m.get(F_INFILEM));
		query << name;

		mov = set_recset(LF_MOV, new TMov_recset(query, recsets()));
	}

	return *mov;
}

TRecordset & TMaestri_sender::rmovrecset(const TRecordset & mov)
{
	TRMov_recset * rmov = (TRMov_recset *) get_recset(LF_RMOV);
	CHECK(rmov != NULL, "Recordset righe contabili non inizializzato");
	long numreg = mov.get(MOV_NUMREG).as_int();

	rmov->find(numreg);
	return *rmov;
}

TRecordset & TMaestri_sender::rivarecset(const TRecordset & mov)
{
	TIVA_recset * rmoviva = (TIVA_recset *) get_recset(LF_RMOVIVA);
	CHECK(rmoviva != NULL, "Recordset righe IVA non inizializzato");
	long numreg = mov.get(MOV_NUMREG).as_int();

	rmoviva->find(numreg);
	return *rmoviva;
}

const TRecordset& TMaestri_sender::clirecset(const char tipocf, const long codcf)
{
	TClifo_recset * clifo = (TClifo_recset *) get_recset(LF_CLIFO);

	if (clifo == NULL)
	{
		TString query("SELECT * FROM ");
		TMask & m = get_mask();
		TFilename name = m.get(F_INPATH);

		name.add(m.get(F_INFILEA));
		query << name;

		clifo = (TClifo_recset *) set_recset(LF_CLIFO, new TClifo_recset(query));
	}

	if (!clifo->find(tipocf, codcf))
	{
		TString msg(tipocf == 'C' ? "Cliente " : "Fornitore ");

		msg << codcf << " assente"; 
		app().log(2, msg);
	}

	return *clifo;
}

int pg0001200(int argc, char* argv[])
{
  TMaestri_sender app;
  app.run(argc, argv, "Invio a TeamSystem");
  return 0;
}