#include <relapp.h>
#include <automask.h>
#include <config.h>
#include <lffiles.h>
#include <progind.h>
#include <recarray.h>		// cache()
#include <recset.h>			// TISAM_recordset
#include <rmoviva.h>
#include <utility.h>
#include <execp.h>			// TExternal_app
#include <dongle.h>			// dongle()

#include "..\cg\cglib01.h"
#include "..\cg\cglib03.h"
#include <mov.h>
#include <rmoviva.h>


#include "tf0.h"
#include "tf0200a.h"

#define CAMPI_CON_BOOLEAN F_TOTOPATT
#define CONF_MODULO				"tf"
#define LAST_DATACOMP_ATT	"LASTCOMPATT"
#define LAST_DATACOMP_PAS	"LASTCOMPPAS"
#define FLAG_ATT_MOD			"ATTDATACOMPMOD"
#define FLAG_PAS_MOD			"PASDATACOMPMOD"
#define STOP							"$$"

// ComLiqPerIva: Comunicazione Liquidazioni Periodiche IVA

/** Utilities **/

// Ritorna un cursore di tab.PRM
const TCursor getPRM(int anno)
{
	static TRelation rprm(LF_TAB);
	TRectype from(rprm.curr());		from.put("COD", "PRM");from.put("CODTAB", anno);
	TRectype to(rprm.curr());			to.put("COD"	, "PRM");to.put("CODTAB", anno);

	TCursor cprm(&rprm, "", 1, &from, &to);
	return cprm;
}

const TRectype getLIM(int anno, int mese)
{
	TString key; key << anno;
	if(mese < 10)
		key << "0";
	key << mese;
	return cache().get("LIM", key);
}

// Ritorna il record richiesto di tabcom.LIA
const TRectype getLIA(int anno)
{
	TString key; key << format("%05d", prefix().firm().codice()) << anno;	// %05d Crea un numero di 5 cifre partendo dal codice e mettendoci 0 davanti
	return cache().get("%LIA", key);
}

// Ritorna il record richiesto di tabcom.LIM
const TRectype getLAM(int anno, int mese)
{
	TString key; key << anno;
	if(mese < 10)
		key << "0";
	key << mese;
	return cache().get("LAM", key);
}

// Ritorna il record valido richiesto di tabcom.VER
const TRectype getVER(int anno, int mese)
{
	// Questa tabella ha come chiave l'inizio validità, creo un cursore e scorro finche non trovo l'ultimo periodo valido
	static TRelation rver(LF_TABCOM);
	static TRectype from(rver.curr());		from.put("COD", "VER");
	static TRectype to(rver.curr());			to.put("COD"	,	"VER");

	static TCursor cver(&rver, "", 1, &from, &to);
	
	// Costruisco il controllo sulla chiave
	TString key; key << anno;
	if(mese < 10)
		key << "0" << mese;
	else
		key << mese;
	
	TRectype row_ret(LF_TABCOM);

	for(cver = 0; cver.pos() < cver.items(); ++cver)
	{
		TRectype row_ver = cver.curr();
		if(row_ver.get("CODTAB") < key)
		{
			row_ret = row_ver;
		}
		else
			break;
	}
	return row_ret;
}

/* Scopiazzata e divisa in due da cg4304.cpp
 * Calcola solo le imposte, aggiunto controllo indetraibilità, non devono essere presi in considerazione
 * i movimenti se indetraibili
 */

int calc_inc_diff(int anno, int mese, int tipoiva, real& imposta_diff, real& imposta_xcas)
{
  CHECKD(tipoiva == 1 || tipoiva == 2, "Bad tipo iva:", tipoiva);
  int flag = 0;

  imposta_diff = imposta_xcas = ZERO;

  TString limit; limit << "ANNOLIQ=" << anno;
  if (mese < 13) limit << " MESELIQ=" << mese;
  TString query; // righe pagamento (TIPOMOV>=3) ed escluse NC!
  query << "USE IVADIFF KEY 2 SELECT (TIPOMOV>2)&&(TIPOIVA=" << tipoiva << ")"
        << "\nFROM " << limit << "\nTO " << limit;
  
  TISAM_recordset id(query);
  const TRectype& rec = id.cursor()->curr();
  for (bool ok = id.move_first(); ok; ok = id.move_next())
  {
    const real iva = rec.get_real(RMI_IMPOSTA);
    if (!iva.is_zero() && !rec.get_bool("INDETR"))  
    {
      const int tipodiff = rec.get_int("TIPODIFF");
      switch (tipodiff)
      {
      case 1: 
				imposta_diff += iva;
				break;
      case 2: 
				imposta_xcas += iva;
				break;
      default: break;
      }
      flag |= tipodiff;
    }
  }

	if (tipoiva == 2 && !rec.get_bool("INDETR"))
	{
		real perc_prorata;

		query = "USE PLM";
		query << "\nFROM CODTAB=" << anno << "\nTO CODTAB=" << anno;
		TISAM_recordset ip(query);
		const TRectype& recp = ip.cursor()->curr();
		for (bool ok = ip.move_first(); ok && perc_prorata == ZERO; ok = ip.move_next())
		{
			int m = atoi(ip.get("CODTAB").as_string().mid(10));
			real p = ip.get("R12").as_real();
			if (m == mese && p != ZERO)
				perc_prorata = p;
		}

		if (perc_prorata > ZERO)
		{
			real ind = ZERO;

			if (imposta_diff > ZERO)
			{
				ind = imposta_diff * perc_prorata / CENTO;
				ind.round(TCurrency::get_firm_dec());
				imposta_diff -= ind;
			}

			if (imposta_xcas > ZERO)
			{
				ind = imposta_xcas * perc_prorata / CENTO;
				ind.round(TCurrency::get_firm_dec());
				imposta_xcas -= ind;
			}
		}
	}

  return flag;
}

/* Funzione per determinare il credito dell'anno precedente delle dichiarazioni precedenti */
void calcola_credito_prec(real& creprec, real& creaprec, bool mensile, int anno, int mese)
{
	// Credito anno precedente
	/* Per calcolare il credito dell'anno precedente inizio a leggere i record precedenti su IVALIQ
	 * fino a quando ne trovo uno >= 0. */

	TRectype row_lia = getLIA(anno);
	if(mensile || (!mensile && ((mese - 1) % 3) == 0))
	{
		TRelation iva_liq(LF_IVALIQ);
		TRectype from(iva_liq.curr()); from.put("ANNO", anno); from.put("MESE", 1);
		// Fino al mese precedente
		TRectype to(iva_liq.curr()); to.put("ANNO", anno); to.put("MESE", mese - 1);	

		TCursor cur_liq(&iva_liq, "GENERATA!=\"G\"", 1, &from, &to);
		bool trovato = false;
		for(cur_liq = 0; cur_liq.pos() < cur_liq.items(); ++cur_liq)
		{
			TRectype row_liq = cur_liq.curr();
			if(row_liq.get_int("MESE") >= mese) break;	// Perchè li prende lo stesso?

			trovato = trovato || row_liq.get_real("CREAPREC") > ZERO;
			creprec = row_liq.get_real("IVAVERC");
		}
		/* Se non ho trovato nessun valore positivo (i negativi senza nessun positivo prima non sono validi)
		 * vado a leggere la liquidazione di quest'anno */
		if(!trovato && mese == 1)
		{
			creaprec = row_lia.get_real("R0");
		}
	}
}

class TCom_liq_per_iva_msk : public TAutomask
{
	bool _last_elab_att; // Flags per controllare se hanno cambiato il tipo di elaborazione (data competenza)
	bool _last_elab_pas;
protected:
	bool _mensile;
	// Aggiunta questa variabile per specificare se è stato impostato un tipo di liquidazione.
	// In Release sembra che durante la ricerca salta l'inizializzazione e imposta prima gli altri campi
	bool _init_liq;
	TRectype _true_data;

	void write_datacomp_mod(bool enabled, bool attive);
	virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
	void extractinator();
	void check_old_value(int field, const real& val);
public:
  TCom_liq_per_iva_msk() : TAutomask("tf0200a"), _true_data(LF_IVALIQ), _init_liq(false)
  {
		_last_elab_att = ini_get_bool(CONFIG_DITTA, CONF_MODULO, LAST_DATACOMP_ATT, false);
		_last_elab_pas = ini_get_bool(CONFIG_DITTA, CONF_MODULO, LAST_DATACOMP_PAS, false);
	  first_focus(F_ANNO);
  }
	void save_gen();
};

void TCom_liq_per_iva_msk::write_datacomp_mod(const bool enabled, bool attive)
{
	int count = 0;

	TString line;
	const TDate today(TODAY);
	TString mod; mod << user() << (enabled ? "|E|" : "|D|") << today.month() << "." << today.day();
	if (attive)
	{
		line = ini_get_string(CONFIG_DITTA, CONF_MODULO, FLAG_ATT_MOD, STOP, count);
		for (; line != STOP; line = ini_get_string(CONFIG_DITTA, CONF_MODULO, FLAG_ATT_MOD, STOP, ++count)) {}
		ini_set_string(CONFIG_DITTA, CONF_MODULO, FLAG_ATT_MOD, mod, count);

		ini_set_bool(CONFIG_DITTA, CONF_MODULO, LAST_DATACOMP_ATT, enabled);
		_last_elab_att = enabled;
	}
	else
	{
		line = ini_get_string(CONFIG_DITTA, CONF_MODULO, FLAG_PAS_MOD, STOP, count);
		for (; line != STOP; line = ini_get_string(CONFIG_DITTA, CONF_MODULO, FLAG_PAS_MOD, STOP, ++count)) {}
		ini_set_string(CONFIG_DITTA, CONF_MODULO, FLAG_PAS_MOD, mod, count);

		ini_set_bool(CONFIG_DITTA, CONF_MODULO, LAST_DATACOMP_PAS, enabled);
		_last_elab_pas = enabled;
	}
	
}

bool TCom_liq_per_iva_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
	case F_ANNO:
		if(e == fe_modify)
		{
			TString cod = get(F_CODDITTA); cod << get_int(F_ANNO);
			if(cache().get("%LIA", cod).empty())
			{
				warning_box("Attenzione anno di liquidazione non presente");
				set(F_ANNO, "");
				break;
			}
			if(cache().get("%LIA", cod, "S7") == "M")
			{
				_mensile = true;
				_init_liq = true;
				enable(F_MESE);
				disable(F_TRIMESTRE);
			}
			else
			{
				_mensile = false;
				_init_liq = true;
				disable(F_MESE);
				enable(F_TRIMESTRE);
			}
		}
		break;
	case F_MESE:
		if(e == fe_modify && _mensile && _init_liq)
			set(F_TRIMESTRE, (get_int(F_MESE) - 1) / 3 + 1);
		break;
	case F_TRIMESTRE:
		if(e == fe_init && !query_mode())
			disable(F_TRIMESTRE);
		if(e == fe_modify && !_mensile && _init_liq && query_mode())
		{
			set(F_MESE, get_int(F_TRIMESTRE) * 3);
			disable(F_TRIMESTRE);
			send_key(K_TAB, F_ANNO);
		}
		break;
	case DLG_CANCEL:
		enable(F_TRIMESTRE);
		break;
	case DLG_RECALC:
		// Vado a prendere i dati di quel mese dalla liquidazione IVA
		if(e == fe_button)
		{
			// Controllo che non ci sia già
			if(!cache().get(LF_IVALIQ, TString(get(F_ANNO)) << "|" << get(F_MESE) << "|U").empty())
			{
				if(!yesno_box("Sono già stati elaborati questi dati, si desidera ricalcolarli?"))
					break;
			}
			extractinator();
		}
		break;
	case DLG_EMAIL:
		{
			if(e == fe_button)
			{
				// Richiamo il programma di invio
				TExternal_app invio_app("tf0 -4");
				invio_app.run();
			}
		}
		break;
	case F_ATT_COMP:
		if(e == fe_init)
				set(F_ATT_COMP, _last_elab_att ? "X" : " ");
		else if(e == fe_modify)
			warning_box("Attenzione la modifica di questo valore comporta un diverso calcolo dei rigo VP2. L'utente è pregato di controllarne la correttezza.\nSi consiglia di ricalcolare e rispedire tutti periodi dell'anno");
		break;
	case F_PAS_COMP:
		if (e == fe_init)
			set(F_PAS_COMP, _last_elab_pas ? "X" : " ");
		else if (e == fe_modify)
			warning_box("Attenzione la modifica di questo valore comporta un diverso calcolo dei rigo VP3. L'utente è pregato di controllarne la correttezza.\nSi consiglia di ricalcolare e rispedire tutti periodi dell'anno");
		break;
	case DLG_SAVEREC:
		if(e == fe_button)
		{
			bool att_dt_comp = get_bool(F_ATT_COMP);
			bool pas_dt_comp = get_bool(F_PAS_COMP);
			if (att_dt_comp != _last_elab_att)
				write_datacomp_mod(att_dt_comp, true);
			if (pas_dt_comp != _last_elab_pas)
				write_datacomp_mod(pas_dt_comp, false);

		}
		if(e != fe_init && !_true_data.empty())
			_true_data.write_rewrite(TLocalisamfile(LF_IVALIQ));
	}

	if(o.dlg() >= CAMPI_CON_BOOLEAN && o.dlg() <= F_IMPNOVER && e == fe_modify) // Se l'utente modifica manualmente uno dei campi calcolati da Campo flaggo il DB
	{
		check_old_value(o.dlg(), get_real(o.dlg()));
	}

	// Controllo sull'aggiornamento di campi collegati ad altri
	if(e == fe_modify)
	{
		switch(o.dlg())
		{
		// Iva Esigibile VS Iva Detratta
		case F_IVAES :
		case F_IVAESXC :
		case F_IVAESDIFF :
		case F_IVADET :
		case F_IVADETXC :
		case F_IVADETDIFF :
			{
				real ivaes	= get_real(F_IVAES);
				real ivadet = get_real(F_IVADET);
				if((ivaes - ivadet) >= ZERO)
				{
					set(F_IVADOV, ivaes - ivadet);
					set(F_IVADOVC, ZERO);
					check_old_value(F_IVADOV, ivaes - ivadet);
					check_old_value(F_IVADOVC, "");
				}
				else
				{
					set(F_IVADOV, ZERO);
					set(F_IVADOVC, (ivaes - ivadet) * -UNO);
					check_old_value(F_IVADOV, "");
					check_old_value(F_IVADOVC, (ivaes - ivadet) * -UNO);
				}
			}
		// IVA da versare VS a credito
		case F_IVADOV :
		case F_DEBPREC :
		case F_INTLIQTRI :
		case F_IVADOVC :
		case F_CREPREC :
		case F_CREAPREC :
		case F_VEAUE :
		case F_CREIMP :
		case F_ACCDOV :
			{
				// Ricalcolo VP13 e VP14
				real debito = get_real(F_IVADOV) + get_real(F_DEBPREC) + get_real(F_INTLIQTRI);
				
				/* Se il credito anno precedente è negativo devo mantenerlo tale ma sottrarlo al credito dell'anno precedente delle dichiarazioni precedenti */
				real creaprec = get_real(F_CREAPREC);
				if(creaprec < ZERO)
				{
					real creprec = ZERO; real appcreaprec;
					calcola_credito_prec(creprec, appcreaprec, _mensile, get_int(F_ANNO), get_int(F_MESE));
					creaprec = appcreaprec + creaprec;
				}

				real credito = get_real(F_IVADOVC) + get_real(F_CREPREC) + creaprec + get_real(F_VEAUE) + get_real(F_CREIMP) + get_real(F_ACCDOV);
				if(debito - credito >= ZERO)
				{
					set(F_IVAVER, debito - credito);
					set(F_IVAVERC, ZERO);
					check_old_value(F_IVAVER, debito - credito);
					check_old_value(F_IVAVERC, "");
				}
				else
				{
					set(F_IVAVER, ZERO);
					set(F_IVAVERC, credito - debito);
					check_old_value(F_IVAVER, "");
					check_old_value(F_IVAVERC, credito - debito);
				}
			}
		break;
		}
	}
	return true;
}

// Funzione che effettivamente estrapola i dati necessari
void TCom_liq_per_iva_msk::extractinator() // Per gli amici GTFO
{
	/* Devo estrapolare più mesi, per farlo vado ciclo n volte (1 o 3) in base se stiamo parlando di trimestralità o meno
	 * I dati da prelevare saranno in PRM, LIM e %LIA
	 * In PRM e LIM troverò le informazioni suddivise per mese, mentre in %LIA ho l'anno di liquidazione
	 */
	int start = _mensile ? get_int(F_MESE) : (((get_int(F_TRIMESTRE) - 1) * 3) + 1);
	int end		= _mensile ? start : start + 2;
	int anno = get_int(F_ANNO);

	// Valori da calcolare
	real totopatt			= ZERO;
	real totopattxc		= ZERO;
	real totoppas			= ZERO;
	real totoppasxc		= ZERO;
	real ivaes				= ZERO;
	real ivaesxc			= ZERO;
	real ivaesdiff		= ZERO;
	real ivadet				= ZERO;
	real ivadetxc			= ZERO;
	real ivadetdiff		= ZERO;
	real rettifiche		= ZERO;
	real varimp				= ZERO;
	real rimborsi			= ZERO;
	real impnover			= ZERO;
	real crespec			= ZERO;
	real vereff				= ZERO;
	real ivadov				= ZERO;
	real ivadovc			= ZERO;
	real debprec			= ZERO;
	real creprec			= ZERO;
	real creaprec			= ZERO;
	real intliqtri		= ZERO;
	real accdov				= ZERO;
	real ivaver				= ZERO;
	real ivaverc			= ZERO;

	const bool att_dt_comp = get_bool(F_ATT_COMP);
	const bool pas_dt_comp = get_bool(F_PAS_COMP);
	for(; start <= end; start++)
	{
		TDate data_da(1, start, anno);
    TDate data_a;
    if (start == 12)
    {
      data_a = TDate(1, 12, anno);
      data_a.set_end_month();
    }
    else
    {
      data_a = TDate(1, start + 1, anno);
      data_a.set_end_month();
    }
		bool has_ixc = gestione_IVAxCassa(data_da);

		/****************************************************************************************************************
		 * TOTOPATT, TOTOPATTXC, TOTOPPAS, TOTOPPASXC, IVAES, IVAESXC, IVAESDIFF,
		 * IVADET , IVADETXC, IVADETDIFF
		 ****************************************************************************************************************/
		
		// Riga LIM
		const TRectype row_lim = getLIM(anno, start);

		// Controllo che la liquidazione è stata effettuata, controllo da fare solo nella 12
		if (dongle().year_assist() > 2121 && (row_lim.empty() || row_lim.get_bool("B0")) && !yesno_box("Attenzione non e' stata calcolata la liquidazione del periodo corrente, si desidera proseguire ugualmente?"))
		{
			return;
		}

		// Riga LIA
		const TRectype row_lia = getLIA(anno);
		
		TString query_iva = "USE RMOVIVA\n";  
		query_iva << "SELECT ( " << FIELD_NAME(LF_MOV, MOV_REG) << "!=\"\")&&BETWEEN( " << FIELD_NAME(LF_MOV, MOV_DATAREG) << ",#DADATAREG,#ADATAREG)"; // scritto FIELD_NAME meglio usarla
		query_iva << "\nJOIN MOV INTO " << MOV_NUMREG << "==" << MOV_NUMREG << "\n";

		TISAM_recordset cur_iva(query_iva);
		cur_iva.set_var("#DADATAREG", data_da);
		cur_iva.set_var("#ADATAREG", data_a);

		for (bool ok = cur_iva.move_first(); ok; ok = cur_iva.move_next())
		{
			TString totat, totpas, i;
			// Controllo che sia un movimento con codice non "non soggetto"
			TCodiceIVA codiva(cur_iva.get(FIELD_NAME(LF_RMOVIVA, RMI_CODIVA)).as_string());
			if (codiva.tipo() == "NS") continue;

			// Controllo che la registrazione sia di del mese che mi interessa o con flag "liquidazione periodo precedente"
			const int month_reg = cur_iva.get("23." MOV_DATAREG).as_date().month();
			const int month_liq = cur_iva.get("23." MOV_MESELIQ).as_int();
			// month_liq viene valorizzato solo se è del mese precedente o sempre? Nei record vecchi ovviamente sarà a zero ma adesso che ci mette?
			// Prendo il tipo di registro
			TRegistro reg(cur_iva.get(FIELD_NAME(LF_MOV, MOV_REG)).as_string(), anno);
			int tiporeg = reg.tipo();
			bool is_corrispettivo = reg.corrispettivi();

			// Prendiamo l'imponibile
			real imp = cur_iva.get("25.IMPONIBILE").as_real();
			real imposta = cur_iva.get("25.IMPOSTA").as_real();

      if (tiporeg == iva_acquisti)
      {
        bool pt_nel_m_prec      = month_reg == start && month_liq != month_reg && month_liq != 0;
        bool mese_succ_non_comp = month_reg != start && (month_liq == month_reg || month_liq == 0);
        if ( (!pas_dt_comp && month_reg != start)
            || (pas_dt_comp
                && (start != 12 && mese_succ_non_comp || start != 1 && pt_nel_m_prec) ) )
          continue;
      }
      else
      {
        bool pt_nel_m_prec      = month_reg == start && month_liq != month_reg && month_liq != 0;
        bool mese_succ_non_comp = month_reg != start && (month_liq == month_reg || month_liq == 0);
        if ((!att_dt_comp && month_reg != start)
          || (att_dt_comp
            && (start != 12 && mese_succ_non_comp || start != 1 && pt_nel_m_prec) ) )
          continue;
      }

			// Se è un movimento IvaXCassa o LiqDiff
			if (has_ixc && (cur_iva.get("23.IVAXCASSA").as_bool() || cur_iva.get("23.LIQDIFF").as_bool()))
			{
				if (tiporeg == iva_vendite)
					totopattxc += imp;
				else
					totoppasxc += imp;
			}
			else
			{
				if (tiporeg == iva_vendite)
				{
					// Controllo il reverse charge, non va calcolato nel totale delle operazioni attive!
					// Se non ha una riga di movimento non lo sommo
					TString key_rc = cur_iva.get("23.NUMREG").as_string(); key_rc << "|1";
					if (!cache().get(LF_RMOV, key_rc).empty())
					{
						// Controllo se è un corrispettivo non scorporato (imponibile e iva assieme)
						if (is_corrispettivo && codiva.percentuale() > ZERO && imposta == ZERO)
						{
							// Nell'imponibile è presente il totale fattura, devo calcolare l'imposta e sottrarla
							// Es iva 22% => imp : 122 = x : 100
							codiva.scorpora(imp);
						}
						totopatt += imp;
					}
				}
				else
					totoppas += imp;
			}
		}
		
		// Sommiamo i corrispettivi al registro delle vendite


		// Se ha attiva l'IVA x cassa calcolo le imposte (imponibili per comodità già calcolati sopra)
		if(has_ixc)
		{
			// IVA esigibile
			real imposta_diff, imposta_xcas;
			imposta_diff = imposta_xcas = ZERO;
			// 1 = Vendite
			calc_inc_diff(anno, start, iva_vendite, imposta_diff, imposta_xcas);
			ivaesxc = ivaesxc + imposta_xcas;
			ivaesdiff = ivaesdiff + imposta_diff;

			// IVA detraibile
			imposta_diff = imposta_xcas = ZERO;
			// 2 = Acquisti
			calc_inc_diff(anno, start, iva_acquisti, imposta_diff, imposta_xcas);
			ivadetxc = ivadetxc + imposta_xcas;
			ivadetdiff = ivadetdiff + imposta_diff;
		}

		/** Resto *****************************************************************************************************/

		TRectype row_lam = getLAM(anno, start);
		
		/* É saltato fuori che in caso di liquidazione trimestrale l'importo ivaes e ivadet
		 * viene scritto su ogni mese, quindi prendo solo quando 
		 * start == end -> iva mensile o ultimo mese della trimestrale */

		if(start == end)
		{
			ivaes		+= row_lam.get_real("R0");
			ivadet	+= row_lam.get_real("R1");
		}
		ivaes			+= ivaesxc + ivaesdiff;
		ivadet		+= ivadetxc + ivadetdiff;

		rettifiche	= rettifiche	+ row_lim.get_real("R5");
		varimp			= varimp			+ row_lim.get_real("R17");
		rimborsi		= rimborsi		+ row_lim.get_real("R1");
		impnover		= impnover		+ row_lim.get_real("R18");
		crespec			= crespec			+ row_lim.get_real("R19");
		vereff			= vereff			+ row_lim.get_real("R8");
		
		debprec	= debprec + row_lim.get_real("S2");
		
		real app_real = ZERO;

		// Credito periodo precedente e anno precedente
		calcola_credito_prec(creprec, creaprec, _mensile, anno, start);
		
		if(creaprec < ZERO)
			creaprec = ZERO;

		intliqtri		= intliqtri + row_lim.get_real("R14");
		accdov			= accdov + row_lim.get_real("R11");
	}

	// Controllo debprec
	// Calcolo prendendo dalla tabella %VER
	TRectype row_ver = getVER(anno, start);
	if(row_ver.empty() || row_ver.get_real("R5") == ZERO)
	{
		error_box("Non è stata valorizzato correttamente il campo \"Periodico\" in \"Versamenti ed interessi IVA\"");
		return;
	}
	else
	{
		if(debprec > row_ver.get_real("R5"))	// Se è maggiore di 25.82€ va azzerato
			debprec = ZERO;
	}
	// Calcolo ivadov/ivadovc
	ivadov = ivaes - ivadet;
	ivadovc = ivadet - ivaes;
	if(ivadov > ZERO)
	{
		ivadovc = ZERO;
	}
	else
	{
		ivadov = ZERO;
	}

	// Calcolo l'IVA da versare o a Credito
	if (!_mensile && get_int(F_TRIMESTRE) == 5)
	{
		ivaver = ZERO;
		ivaverc = ZERO;
	}
	else
	{
		ivaver = (ivadov + debprec + intliqtri) - (ivadovc + creprec + creaprec + get_real(F_VEAUE) + get_real(F_CREIMP) + accdov);
		ivaverc = (ivadovc + creprec + creaprec + get_real(F_VEAUE) + get_real(F_CREIMP) + accdov) - (ivadov + debprec + intliqtri);

		// Controllo quale va sotto zero e la tolgo
		if (ivaver >= ZERO)
		{
			ivaverc = ZERO;
		}
		else
		{
			ivaver = ZERO;
		}
	}

	// Sommo i totali con i totali xc
	totopatt += totopattxc;
	totoppas += totoppasxc;

	// Imposto tutti i campi
	set(F_TOTOPATT,		totopatt);
	set(F_TOTOPATTXC,	totopattxc);
	set(F_TOTOPPAS,		totoppas);
	set(F_TOTOPPASXC,	totoppasxc);
	set(F_IVAES,			ivaes);
	set(F_IVAESXC,		ivaesxc);
	set(F_IVAESDIFF,	ivaesdiff);
	set(F_IVADET,			ivadet);
	set(F_IVADETXC,		ivadetxc);
	set(F_IVADETDIFF,	ivadetdiff);
	set(F_IVADOV,			ivadov);
	set(F_IVADOVC,		ivadovc);
	set(F_DEBPREC,		debprec);
	set(F_CREPREC,		creprec);
	set(F_CREAPREC,		creaprec);
	//set(F_VEAUE,			veaue);		// Campi non calcolati, messi qua per un eventuale futuro
	//set(F_CREIMP,			creimp);
	set(F_INTLIQTRI,	intliqtri);
	set(F_ACCDOV,			accdov);
	set(F_IVAVER,			ivaver);
	set(F_IVAVERC,		ivaverc);
	set(F_RETTIFICHE,	rettifiche);
	set(F_VARIMP,			varimp);
	set(F_RIMBORSI,		rimborsi);
	set(F_IMPNOVER,		impnover);
	set(F_CRESPEC,		crespec);
	set(F_VEREFF,			vereff);

	// Preparo il record
	save_gen();
	// Azzero i booleani
	for(int i = B_TOTOPATT; i <= B_CRESPEC; i++)
	{
		set(i, "");
	}
}

void TCom_liq_per_iva_msk::save_gen()
{
	// Assegno tutti i campi
	_true_data.put("ANNO",				get(F_ANNO));
	_true_data.put("MESE",				get(F_MESE));
	_true_data.put("TRIMESTRE",		get(F_TRIMESTRE));
	_true_data.put("GENERATA",		'G');								// Segno che è generata da campo
	_true_data.put("TOTOPATT",		get(F_TOTOPATT));
	_true_data.put("TOTOPATTXC",	get(F_TOTOPATTXC));
	_true_data.put("TOTOPPAS",		get(F_TOTOPPAS));
	_true_data.put("TOTOPPASXC",	get(F_TOTOPPASXC));
	_true_data.put("IVAES",				get(F_IVAES));
	_true_data.put("IVAESXC",			get(F_IVAESXC));
	_true_data.put("IVAESDIFF",		get(F_IVAESDIFF));
	_true_data.put("IVADET",			get(F_IVADET));
	_true_data.put("IVADETXC",		get(F_IVADETXC));
	_true_data.put("IVADETDIFF",	get(F_IVADETDIFF));
	_true_data.put("IVADOV",			get(F_IVADOV));
	_true_data.put("IVADOVC",			get(F_IVADOVC));
	_true_data.put("DEBPREC",			get(F_DEBPREC));
	_true_data.put("CREPREC",			get(F_CREPREC));
	_true_data.put("CREAPREC",		get(F_CREAPREC));
	_true_data.put("VEAUE",				get(F_VEAUE));
	_true_data.put("CREIMP",			get(F_CREIMP));
	_true_data.put("INTLIQTRI",		get(F_INTLIQTRI));
	_true_data.put("ACCDOV",			get(F_ACCDOV));
	_true_data.put("IVAVER",			get(F_IVAVER));
	_true_data.put("IVAVERC",			get(F_IVAVERC));
	_true_data.put("RETTIFICHE",	get(F_RETTIFICHE));
	_true_data.put("VARIMP",			get(F_VARIMP));
	_true_data.put("RIMBORSI",		get(F_RIMBORSI));
	_true_data.put("CRESPEC",			get(F_CRESPEC));
	_true_data.put("IMPNOVER",		get(F_IMPNOVER));
	_true_data.put("VEREFF",			get(F_VEREFF));
}

void TCom_liq_per_iva_msk::check_old_value(int field, const real& val)
{
	if(_true_data.empty())
	{
		TString key; key << get(F_ANNO) << "|" << get(F_MESE) << "|G";
		_true_data = cache().get(LF_IVALIQ, key);
	}
	real true_val = ZERO;
	
	// Modo più intelligente di uno stupido switch case?
	switch(field)
	{
	case F_TOTOPATT:
		true_val = _true_data.get_real("TOTOPATT");
	break;
	case F_TOTOPATTXC:
		true_val = _true_data.get_real("TOTOPATTXC");
	break;
	case F_TOTOPPAS:
		true_val = _true_data.get_real("TOTOPPAS");
	break;
	case F_TOTOPPASXC:
		true_val = _true_data.get_real("TOTOPPASXC");
	break;
	case F_IVAES:
		true_val = _true_data.get_real("IVAES");
	break;
	case F_IVAESXC:
		true_val = _true_data.get_real("IVAESXC");
	break;
	case F_IVAESDIFF:
		true_val = _true_data.get_real("IVAESDIFF");
	break;
	case F_IVADET:
		true_val = _true_data.get_real("IVADET");
	break;
	case F_IVADETXC:
		true_val = _true_data.get_real("IVADETXC");
	break;
	case F_IVADETDIFF:
		true_val = _true_data.get_real("IVADETDIFF");
	break;
	case F_IVADOV:
		true_val = _true_data.get_real("IVADOV");
	break;
	case F_IVADOVC:
		true_val = _true_data.get_real("IVADOVC");
	break;
	case F_DEBPREC:
		true_val = _true_data.get_real("DEBPREC");
	break;
	case F_CREPREC:
		true_val = _true_data.get_real("CREPREC");
	break;
	case F_CREAPREC:
		true_val = _true_data.get_real("CREAPREC");
	break;
	case F_VEAUE:
		true_val = _true_data.get_real("VEAUE");
	break;
	case F_CREIMP:
		true_val = _true_data.get_real("CREIMP");
	break;
	case F_INTLIQTRI:
		true_val = _true_data.get_real("INTLIQTRI");
	break;
	case F_ACCDOV:
		true_val = _true_data.get_real("ACCDOV");
	break;
	case F_IVAVER:
		true_val = _true_data.get_real("IVAVER");
	break;
	case F_IVAVERC:
		true_val = _true_data.get_real("IVAVERC");
	break;
	case F_RETTIFICHE:
		true_val = _true_data.get_real("RETTIFICHE");
	break;
	case F_VARIMP:
		true_val = _true_data.get_real("VARIMP");
	break;
	case F_RIMBORSI:
		true_val = _true_data.get_real("RIMBORSI");
	break;
	case F_CRESPEC:
		true_val = _true_data.get_real("CRESPEC");
	break;
	case F_IMPNOVER:
		true_val = _true_data.get_real("IMPNOVER");
	break;
	case F_VEREFF:
		true_val = _true_data.get_real("VEREFF");
	break;
	}
	set(field + 50, true_val != val ? "X" : "");
}

class TCom_liq_per_iva_app : public TRelation_application
{
private:
	TCom_liq_per_iva_msk* _mask;
  TRelation* _rel;
protected:
	bool user_create();
	bool user_destroy();
	virtual TMask* get_mask(int mode) { return _mask; }

public:
	virtual TRelation* get_relation() const {return (TRelation*)_rel;}
};

bool TCom_liq_per_iva_app::user_create()
{
  _rel = new TRelation(LF_IVALIQ);
  _mask = new TCom_liq_per_iva_msk;
	set_search_field(F_ANNO);
  return true;
}

bool TCom_liq_per_iva_app::user_destroy()
{             
  delete _mask;
  return true;
}

int tf0200(int argc, char* argv[])
{
  TCom_liq_per_iva_app app;
  app.run(argc, argv, TR("Trasferimento dati liquidazione IVA"));
  return 0;
}