#include <applicat.h>
#include <automask.h>
#include <config.h>
#include "fplib.h"
#include <progind.h>
#include <cfven.h>
#include <doc.h>

#include "../ve/velib05.h"
#include "../fe/felib.h"

#include "fp0.h"
#include "fp0700a.h"
#include "fp0100a.h"

/////////////////////////////////////////////////////////////////////////////////////
// TPAR_mask
/////////////////////////////////////////////////////////////////////////////////////

class TPAR_mask : public TAutomask
{
	TAssoc_array _causali;

protected:
	enum { _codnum, _tipodoc, _dastato, _astato, _tiposdi };

	void					set_filter_changed();
	void					set_pronto();
	void					connect_keys();
	void					export_paf();
	void					print_reg();
	bool					on_field_event(TOperable_field& o, TField_event e, long jolly) override;
	void					next_page(int                   p) override;
	virtual bool	on_key(KEY key) ;
	bool					check_not_empty();
	bool					check_full_fields() const;
	void					delete_paf();
	void					fill();
	void					init();
	void					force_reload_sheet();


	void load_all_fields();
	void load_sheet(const TString& tipo_sel);

	bool _filter_changed;
	bool _enable_chiave_fixer;

public:
	const TAssoc_array & causali() const { return _causali; }
	void save_all_fields();
	TPAR_mask();
	virtual ~TPAR_mask() {}

};

TPAR_mask *__mask = nullptr;


void TPAR_mask::save_all_fields()
{
	TSheet_field & scaus = sfield(F_CAUSALI_TIPO);
	// Salvo le impostazioni
	ini_set_string(CONFIG_DITTA, "fp", "dataini", get(F_DATAINI));
	ini_set_string(CONFIG_DITTA, "fp", "dataend", get(F_DATAEND));
	ini_set_string(CONFIG_DITTA, "fp", "TIPO_SDI", get(F_TIPO_SDI));
	// Salvo lo sheet
	_causali.destroy();
	FOR_EACH_SHEET_ROW_LOOP(scaus, r)
	{
		const TString & codcaus = scaus.get_str_row_cell(r, S_COD_CAUS);
		ini_set_string(CONFIG_DITTA, "fp", "CAUSALE", codcaus, r);
		_causali.add(codcaus);
	}
	for (int i = scaus.items(); ; i++)
	{
		
		if (!ini_remove(CONFIG_DITTA, "fp", "CAUSALE", i))
			break;
	}

}

void TPAR_mask::force_reload_sheet()
{
	// Mi sposto nella prima pagina, setto il flag di dirty sul filtro e mi risposto
	// Lo faccio perché eliminando la riga direttamente e chiamando la force_update() si crea un bug che cliccando sulla prima riga viene mostrata quella che c'era prima della eliminazione
	TAutomask::next_page(0);
	set_focus_field(F_DATAINI);
	_filter_changed = true;
	next_page(1);
}

void TPAR_mask::load_all_fields()
{
	set(F_DATAINI, ini_get_string(CONFIG_DITTA, "fp", "dataini"));
	set(F_DATAEND, ini_get_string(CONFIG_DITTA, "fp", "dataend"));
	set(F_TIPO_SDI, ini_get_string(CONFIG_DITTA, "fp", "TIPO_SDI"));
	const TString& tipo_sel = get(F_TIPO_SDI);
	load_sheet(tipo_sel);
}

void TPAR_mask::load_sheet(const TString& tipo_sel)
{
	TSheet_field& scaus = sfield(F_CAUSALI_TIPO);
	TCursor cur(new TRelation(LF_CAUSALI));

	const int items = cur.items();

	scaus.reset();

	for (cur.first_item(); cur.pos() < items; cur.succ_item())
	{
		const TRectype& rec = cur.curr();
		const TString& tipodocsdi = rec.get(CAU_TIPODOCSDI);
		
		if (tipodocsdi == "TD28")
		{
			int i = 0;
		}

		//COSA STA SUCCEDENDO QUI? PERCHE VA QUANDO VUOLE LUI?

		if ((tipo_sel == "T" && tipodocsdi.full()) || tipodocsdi == tipo_sel)
		{
			int r = scaus.set_row_cell(S_TIPO_SDI, tipodocsdi);
			scaus.set_row_cell(S_COD_CAUS, rec.get(CAU_CODCAUS), r);
			scaus.set_row_cell(S_DESCR, rec.get(CAU_DESCR), r);
		}
	}
	if (scaus.items() == 0)
		warning_box(TR("Attenzione non c'e' nessuna causale di regolarizzazione"));

	scaus.force_update();

}


bool caus_filter(const TRelation* r)
{
	return __mask->causali().is_key(r->lfile().get(MOV_CODCAUS));
}

void TPAR_mask::fill()
{
	const TDate dal = get(F_DATAINI);
	const TDate al = get(F_DATAEND);
	TString filter_selected = get(F_REGSEL);
	// Record di controllo per eventuali elaborazioni precedenti
	TString     hfatt, bfatt;
	TPaf_record paf0100f("PAF0100F");
	TSheet_field&  regs = sfield(F_REGS);
	TString query;
	const bool diagn = get_bool(F_DIAGN);

	enable(DLG_OK, filter_selected.empty() || filter_selected == "E" || filter_selected == "D");
	enable(DLG_PRINT, true);
	enable(DLG_SAVEREC, (is_f8() && (filter_selected == "X") || filter_selected == "D"));
	enable(DLG_ALL, true);

	regs.enable_column(S_SELECTED, filter_selected!="X" ||is_f8());


	//TAnagrafica ditta = 

		/*
			VECCHIA QUERY

			query << "USE " << LF_MOV << " KEY 3 SELECT (BETWEEN(" << MOV_DATAREG << ","
		    << dal.date2ansi() << ',' << al.date2ansi() << "))&&(REG!=\"\")"
				<< "\nFROM " << MOV_TIPO << "=C\nTO " << MOV_TIPO "=C";
		*/

		//MY QUERY

	//DA RIVEDERE QUESTA QUERY 
	query << "USE " << LF_MOV << " KEY 2\n";
	if (dal.ok()) 
		query << "FROM " << MOV_DATAREG << "=" << dal << "\n";
	if (al.ok()) 
		query << "TO " << MOV_DATAREG << "=" << al << "\n";
		

	//query << "USE " << LF_MOV << " WHERE CODCAUS IN ('A01') AND DATADOC BETWEEN " << dal.date2ansi() << " AND " << al.date2ansi();

	TISAM_recordset rec(query);
	
	rec.set_filterfunction(caus_filter);

	TProgress_monitor pi(rec.items(), nullptr);

	bool first, show, ask = !((show = (first = true)));
	int fat_no_cod = 0;
	const TDate data_inizio = get_date_start_new_fatt();

	// Disabilito la colonna del codice ufficio
	//regs.enable_column(cid2index(S_UFFICIO), false);
	regs.reset();

	// Disabilito la colonna riferimento Amministrazione
	regs.enable_column(cid2index(S_RIFAMM), false);
	regs.reset();

	TAnagrafica ditta;
	ditta.init(LF_NDITTE, prefix().get_codditta());
	
	for (bool okc = rec.move_first(); okc; okc = rec.move_next())
	{
		if (!pi.add_status())
			break;
		const TRectype& mov = rec.cursor()->curr();
		const TCli_for & cli = cached_clifor(mov.get_char(MOV_TIPO), mov.get_long(MOV_CODCF));
		bool sent = false;

		const TCausale& caus = cached_causale(mov);
		const TString& tipodocsdi = caus.tipodocsdi();
		const TString & prefisso = caus.reg().prefisso();

		if (chiave_paf_mov(mov, tipodocsdi, hfatt, bfatt))
		{
			if (paf0100f.search(nullptr, hfatt, bfatt) && paf0100f.sq_get("P1_GESTIONE") != " " &&
				paf0100f.sq_get("P1_GESTIONE") != "0" && paf0100f.sq_get("P1_ERRINT") != "*")
			{
				if (paf0100f.sq_get("P1_GESTIONE") != filter_selected)
					continue;
				sent = true;
			}
			else if (filter_selected.not_empty())
				continue;
		}
		int r = regs.set_row_cell(S_SELECTED, sent);

		regs.set_row_cell(S_ANNO, rec.get_int(MOV_ANNOES), r);
		regs.set_row_cell(S_NUMREG, rec.get_string(MOV_NUMREG), r);
		regs.set_row_cell(S_DATAREG, rec.get_date(MOV_DATAREG), r);
		regs.set_row_cell(S_TIPODOC,tipodocsdi, r);

		if (prefisso.empty())
		{
			regs.set_row_cell(S_NUMDOC, rec.get_string(MOV_NUMDOC), r);
		}
		else
		{
			const TString & numdoc = rec.get_string(MOV_NUMDOC);
			TString prefix_numdoc = prefisso;
			prefix_numdoc << "/" << numdoc;

			regs.set_row_cell(S_NUMDOC, prefix_numdoc, r);
		}

		regs.set_row_cell(S_DATADOC, rec.get_date(MOV_DATADOC), r);
		regs.set_row_cell(S_CLIENTE, rec.get_long(MOV_CODCF), r);
		regs.set_row_cell(S_RAGSOC, cli.get(CLI_RAGSOC), r);
		regs.set_row_cell(S_PIVA, cli.get(CLI_PAIV), r);

		// non c'è ?   TString cod_ind_sped = rec.get(DOC_CODINDSP).as_string();
		//TString rif = get_dest_sdi(rec.get_string(MOV_TIPO)[0], rec.get_long(MOV_CODCF), EMPTY_STRING);
		TString rif = ditta.coddest();

		// Se il codice SDI della ditta è vuoto imposto quello di default 0000000
		if (rif.empty())
		{
			rif = "0000000";
			fat_no_cod++;
		}

		regs.set_row_cell(S_UFFICIO, rif, r);
		regs.set_row_cell(S_COFI, cli.get(CLI_COFI), r);

		bool split = cli.get_bool("20." CLI_SPLITPAY);

		if (split)
		{
			const long numreg = rec.get(DOC_NUMREG).as_int();
			if (numreg > 0)
			{
				const TRectype& mov = cache().get(LF_MOV, numreg);
				split = is_split_payment(mov);
			}
		}
	}

	regs.force_update();
	regs.show();

	if (fat_no_cod > 0)
		warning_box("Non e' stato possibile recuperare il codice SDI dai dati della ditta.\nE' stato quindi impostato il valore di default.");
}

void TPAR_mask::set_filter_changed()
{
	_filter_changed = true;
}

void TPAR_mask::set_pronto()
{
	TString_array& sht = sfield(F_REGS).rows_array();
	TProgress_monitor pi(sht.items(), "Esportazione Fatture");
	FOR_EACH_ARRAY_ROW(sht, r, riga)
	{
		if (!pi.add_status())
			break;

		if (!riga->starts_with("X"))
			continue;

		static TString campo_hfatt, campo_bfatt, query;
		TDocumento doc('D', riga->get_int(xvtil_cid2index(S_ANNO)), EMPTY_STRING, riga->get_long(xvtil_cid2index(S_NUMREG)));

		if (chiave_paf_doc(doc, campo_hfatt, campo_bfatt))
		{
			// Come prima cosa controllo che effettivamente la chiave di questo doc sia in giro per il mondo
			query.cut(0) << "UPDATE PAF0100F SET P1_GESTIONE = 'P' WHERE P1_KEYHEADERFATT = '" << campo_hfatt << "' AND P1_KEYBODYFATT = '" << campo_bfatt << "'";
			fp_db().sq_set_exec(query);
		}
	}

	// Committo tutto
	fp_db().sq_commit();
	force_reload_sheet();
}

void TPAR_mask::connect_keys()
{
	TString_array& sht = sfield(F_REGS).rows_array();
	TLog_report legno("Allineamento chiavi documento");
	// Non sto a fare 8000 variabili, oggi mi sento a corto di Byte
	static TString msg_log;
	int updated = 0;

	if (sht.empty())
	{
		warning_box("Impossibile allineare le chiavi di uno sheet vuoto!");
		return;
	}

	TProgress_monitor pi(sht.items(), "Esportazione Fatture");
	FOR_EACH_ARRAY_ROW(sht, r, riga)
	{
		if (!pi.add_status())
			break;

		if (!riga->starts_with("X"))
			continue;

		TDocumento doc('D', riga->get_int(xvtil_cid2index(S_ANNO)), EMPTY_STRING, riga->get_long(xvtil_cid2index(S_NUMREG)));
		static TString campo_hfatt, campo_bfatt, query;
		if (chiave_paf_doc(doc, campo_hfatt, campo_bfatt))
		{
			// Come prima cosa controllo che effettivamente la chiave di questo doc sia in giro per il mondo
			query.cut(0) << "SELECT * FROM PAF0100F WHERE P1_KEYHEADERFATT = '" << campo_hfatt << "' AND P1_KEYBODYFATT = '" << campo_bfatt << "'";
			if (fp_db().sq_set_exec(query))
			{
				msg_log.cut(0) << "Il documento " << campo_bfatt << " è già presente nel DB, verrà saltato";
				legno.log(9000, msg_log);
				continue;
			}

			// Provo a cercare il documento nel paf07 come un vero uomo
			query.cut(0) << "SELECT P7_KEYPRGINVIO, P7_KEYHEADERFATT, P7_KEYBODYFATT FROM PAF0700F WHERE P7_KEYHEADERFATT = '" << campo_hfatt
				<< "' AND P7_TIPODOC = '" << tipo_doc_sdi(doc) << "' AND P7_DATA = '" << doc.data().date2ansi() << "' AND P7_NUMERO LIKE '%" << doc.numero() << "%'";

			if (fp_db().sq_set_exec(query, false))
			{
				bool found = false;
				// Valori nel db
				static TString db_prginv, db_hfatt, db_bfatt;
	
				// Posso avere più di un risulatato, per esempio se effettuo la fatturazione di gennaio potrei avere la fattura 1, 10 e 11 del cliente 100.
				for (bool ok = fp_db().sq_set_exec(query); ok && !found; ok = fp_db().sq_next())
				{
					db_prginv.cut(0) << fp_db().sq_get("P7_KEYPRGINVIO");
					db_hfatt.cut(0) << fp_db().sq_get("P7_KEYHEADERFATT");
					db_bfatt.cut(0) << fp_db().sq_get("P7_KEYBODYFATT");

					// Adesso che ho trovato il documento vado a verificare per scrupolo anche le righe documento
					query.cut(0) << "SELECT * FROM PAF1800F WHERE PI_KEYPRGINVIO = '" << db_prginv
						<< "' AND PI_KEYHEADERFATT = '" << db_hfatt
						<< "' AND PI_KEYBODYFATT = '" << db_bfatt << "'";

					// Setto momentaneamente a true per ciclare sotto
					found = true;
					for (bool move_ok = fp_db().sq_set_exec(query); move_ok && found; move_ok = fp_db().sq_next())
					{
						const TRiga_documento& rigadoc = doc[fp_db().sq_get_int("PI_NUMEROLINEA")];
						// Testo solo la qta, il prezzo è troppo complicato
						const real& qta = rigadoc.quantita();
						found &= !qta.is_zero() ? qta == fp_db().sq_get_real("PI_QUANTITA") : fp_db().sq_get_real("PI_QUANTITA") <= UNO;
					}
				}

				if (!found)
				{
					msg_log.cut(0) << "Il documento " << campo_bfatt << " non è presente nel DB PAF, verrà saltato";
					legno.log(9000, msg_log);
					continue;
				}
				else
				{
					query.cut(0) <<
						"UPDATE PAF0100F SET P1_KEYHEADERFATT = '" << campo_hfatt << "', P1_KEYBODYFATT = '" << campo_bfatt << "' WHERE P1_KEYPRGINVIO = '" << db_prginv << "' AND P1_KEYHEADERFATT = '" << db_hfatt << "' AND P1_KEYBODYFATT = '" << db_bfatt << "'\n" <<
						"UPDATE PAF0200F SET P2_KEYHEADERFATT = '" << campo_hfatt << "', P2_KEYBODYFATT = '" << campo_bfatt << "' WHERE P2_KEYPRGINVIO = '" << db_prginv << "' AND P2_KEYHEADERFATT = '" << db_hfatt << "' AND P2_KEYBODYFATT = '" << db_bfatt << "'\n" <<
						"UPDATE PAF0400F SET P4_KEYHEADERFATT = '" << campo_hfatt << "', P4_KEYBODYFATT = '" << campo_bfatt << "' WHERE P4_KEYPRGINVIO = '" << db_prginv << "' AND P4_KEYHEADERFATT = '" << db_hfatt << "' AND P4_KEYBODYFATT = '" << db_bfatt << "'\n" <<
						"UPDATE PAF0700F SET P7_KEYHEADERFATT = '" << campo_hfatt << "', P7_KEYBODYFATT = '" << campo_bfatt << "' WHERE P7_KEYPRGINVIO = '" << db_prginv << "' AND P7_KEYHEADERFATT = '" << db_hfatt << "' AND P7_KEYBODYFATT = '" << db_bfatt << "'\n" <<
						"UPDATE PAF0800F SET P8_KEYHEADERFATT = '" << campo_hfatt << "', P8_KEYBODYFATT = '" << campo_bfatt << "' WHERE P8_KEYPRGINVIO = '" << db_prginv << "' AND P8_KEYHEADERFATT = '" << db_hfatt << "' AND P8_KEYBODYFATT = '" << db_bfatt << "'\n" <<
						"UPDATE PAF1000F SET P0_KEYHEADERFATT = '" << campo_hfatt << "', P0_KEYBODYFATT = '" << campo_bfatt << "' WHERE P0_KEYPRGINVIO = '" << db_prginv << "' AND P0_KEYHEADERFATT = '" << db_hfatt << "' AND P0_KEYBODYFATT = '" << db_bfatt << "'\n" <<
						"UPDATE PAF1100F SET PA_KEYHEADERFATT = '" << campo_hfatt << "', PA_KEYBODYFATT = '" << campo_bfatt << "' WHERE PA_KEYPRGINVIO = '" << db_prginv << "' AND PA_KEYHEADERFATT = '" << db_hfatt << "' AND PA_KEYBODYFATT = '" << db_bfatt << "'\n" <<
						"UPDATE PAF1200F SET PB_KEYHEADERFATT = '" << campo_hfatt << "', PB_KEYBODYFATT = '" << campo_bfatt << "' WHERE PB_KEYPRGINVIO = '" << db_prginv << "' AND PB_KEYHEADERFATT = '" << db_hfatt << "' AND PB_KEYBODYFATT = '" << db_bfatt << "'\n" <<
						"UPDATE PAF1400F SET PB_KEYHEADERFATT = '" << campo_hfatt << "', PB_KEYBODYFATT = '" << campo_bfatt << "' WHERE PB_KEYPRGINVIO = '" << db_prginv << "' AND PB_KEYHEADERFATT = '" << db_hfatt << "' AND PB_KEYBODYFATT = '" << db_bfatt << "'\n" <<
						"UPDATE PAF1600F SET PF_KEYHEADERFATT = '" << campo_hfatt << "', PF_KEYBODYFATT = '" << campo_bfatt << "' WHERE PF_KEYPRGINVIO = '" << db_prginv << "' AND PF_KEYHEADERFATT = '" << db_hfatt << "' AND PF_KEYBODYFATT = '" << db_bfatt << "'\n" <<
						"UPDATE PAF1700F SET PG_KEYHEADERFATT = '" << campo_hfatt << "', PG_KEYBODYFATT = '" << campo_bfatt << "' WHERE PG_KEYPRGINVIO = '" << db_prginv << "' AND PG_KEYHEADERFATT = '" << db_hfatt << "' AND PG_KEYBODYFATT = '" << db_bfatt << "'\n" <<
						"UPDATE PAF1800F SET PI_KEYHEADERFATT = '" << campo_hfatt << "', PI_KEYBODYFATT = '" << campo_bfatt << "' WHERE PI_KEYPRGINVIO = '" << db_prginv << "' AND PI_KEYHEADERFATT = '" << db_hfatt << "' AND PI_KEYBODYFATT = '" << db_bfatt << "'\n" <<
						"UPDATE PAF1900F SET PY_KEYHEADERFATT = '" << campo_hfatt << "', PY_KEYBODYFATT = '" << campo_bfatt << "' WHERE PY_KEYPRGINVIO = '" << db_prginv << "' AND PY_KEYHEADERFATT = '" << db_hfatt << "' AND PY_KEYBODYFATT = '" << db_bfatt << "'\n" <<
						"UPDATE PAF2000F SET PJ_KEYHEADERFATT = '" << campo_hfatt << "', PJ_KEYBODYFATT = '" << campo_bfatt << "' WHERE PJ_KEYPRGINVIO = '" << db_prginv << "' AND PJ_KEYHEADERFATT = '" << db_hfatt << "' AND PJ_KEYBODYFATT = '" << db_bfatt << "'\n" <<
						"UPDATE PAF2100F SET PK_KEYHEADERFATT = '" << campo_hfatt << "', PK_KEYBODYFATT = '" << campo_bfatt << "' WHERE PK_KEYPRGINVIO = '" << db_prginv << "' AND PK_KEYHEADERFATT = '" << db_hfatt << "' AND PK_KEYBODYFATT = '" << db_bfatt << "'\n" <<
						"UPDATE PAF2200F SET PL_KEYHEADERFATT = '" << campo_hfatt << "', PL_KEYBODYFATT = '" << campo_bfatt << "' WHERE PL_KEYPRGINVIO = '" << db_prginv << "' AND PL_KEYHEADERFATT = '" << db_hfatt << "' AND PL_KEYBODYFATT = '" << db_bfatt << "'\n" <<
						"UPDATE PAF2400F SET PN_KEYHEADERFATT = '" << campo_hfatt << "', PN_KEYBODYFATT = '" << campo_bfatt << "' WHERE PN_KEYPRGINVIO = '" << db_prginv << "' AND PN_KEYHEADERFATT = '" << db_hfatt << "' AND PN_KEYBODYFATT = '" << db_bfatt << "'\n" <<
						"UPDATE PAF2500F SET PO_KEYHEADERFATT = '" << campo_hfatt << "', PO_KEYBODYFATT = '" << campo_bfatt << "' WHERE PO_KEYPRGINVIO = '" << db_prginv << "' AND PO_KEYHEADERFATT = '" << db_hfatt << "' AND PO_KEYBODYFATT = '" << db_bfatt << "'\n" <<
						"UPDATE PAF2600F SET PP_KEYHEADERFATT = '" << campo_hfatt << "', PP_KEYBODYFATT = '" << campo_bfatt << "' WHERE PP_KEYPRGINVIO = '" << db_prginv << "' AND PP_KEYHEADERFATT = '" << db_hfatt << "' AND PP_KEYBODYFATT = '" << db_bfatt << "'\n" <<
						"UPDATE PAF2700F SET PQ_KEYHEADERFATT = '" << campo_hfatt << "', PQ_KEYBODYFATT = '" << campo_bfatt << "' WHERE PQ_KEYPRGINVIO = '" << db_prginv << "' AND PQ_KEYHEADERFATT = '" << db_hfatt << "' AND PQ_KEYBODYFATT = '" << db_bfatt << "'\n" <<
						"UPDATE PAF3000F SET PT_KEYHEADERFATT = '" << campo_hfatt << "', PT_KEYBODYFATT = '" << campo_bfatt << "' WHERE PT_KEYPRGINVIO = '" << db_prginv << "' AND PT_KEYHEADERFATT = '" << db_hfatt << "' AND PT_KEYBODYFATT = '" << db_bfatt << "'\n" <<
						"UPDATE PAF3200F SET PU_KEYHEADERFATT = '" << campo_hfatt << "', PU_KEYBODYFATT = '" << campo_bfatt << "' WHERE PU_KEYPRGINVIO = '" << db_prginv << "' AND PU_KEYHEADERFATT = '" << db_hfatt << "' AND PU_KEYBODYFATT = '" << db_bfatt << "'\n" <<
						"UPDATE PAFW300F SET PW_KEYHEADERFATT = '" << campo_hfatt << "', PW_KEYBODYFATT = '" << campo_bfatt << "' WHERE PW_KEYPRGINVIO = '" << db_prginv << "' AND PW_KEYHEADERFATT = '" << db_hfatt << "' AND PW_KEYBODYFATT = '" << db_bfatt << "'\n";

					if (fp_db().sq_set_exec(query))
					{
						msg_log.cut(0) << "Il documento " << campo_bfatt << " e' stato aggiornato correttamente\nChiave precedente: " << db_bfatt << " chiave nuova: " << campo_bfatt;
						legno.log(0, msg_log);
						updated++;
					}
				}
			}
		}
	}
	if (fp_db().sq_commit())
	{
		msg_log.cut(0) << "Aggiornati " << updated << " documenti";
		legno.log(0, msg_log);
	}

	legno.preview();
	force_reload_sheet();
}

void TPAR_mask::export_paf()
{
	int      ndocs = 0;
	TSheet_field& sht = sfield(F_REGS);
	
	const bool diagn = get_bool(F_DIAGN);
	TReg_fp elab(EMPTY_STRING, !diagn);
	TReport_book book;
	bool err = false;

	const TString8& reg_fisc = get(F_REG_FISC);

	//elab.set_cache_insert(true);
	if (!sht.empty())
	{
		{
			TProgress_monitor pi(sht.items(), "Esportazione Regolarizzazioni");


			FOR_EACH_SHEET_ROW_LOOP(sht, r)
			{
			 
				if (!pi.add_status())
					break;

				if (sht.get_bool_row_cell(r, S_SELECTED))
				{
					const TString& tipo_doc_sdi = sht.get_str_row_cell(r, S_TIPODOC);
					elab.set_tipodocsdi(tipo_doc_sdi);
					elab.set_regfisc(reg_fisc);
					const long          nreg = sht.get_long_row_cell(r, S_NUMREG);

					// Verifico che il codice sdi nello sheet sia lo stesso sulla testata del documento in caso contrario lo aggiorno
					TMovimento_contabile mov(nreg);

					if (elab.reg_to_paf(mov))
						ndocs++;
					else
					{
						TString msg;

						msg.format("La registrazione numero %ld non e' stata esportata, continuare?", nreg);
						err = true;
						elab.log().log(2, msg);
						if (!yesno_box(msg))
							break;
					}
				}
			}

			if (elab.force_commit() <= 0)
			{
				TString msg;

				msg.format("Errore durante il cambiamento di stato finale, potrebbero esser rimaste delle fatture in Pronto");
				err = true;
				elab.log().log(2, msg);
				error_box(msg);
			}
		}
		elab.show_log();
		if (diagn && !err)
		{
			print_reg();
		}
	}
}

void TPAR_mask::print_reg()
{
	TSheet_field& sht = sfield(F_REGS);
	const TString &tipo_doc_sdi = get(F_TIPO_SDI);
	TReport_book book;

	//elab.set_cache_insert(true);
	if (!sht.empty())
	{
		{
			TProgress_monitor pi(sht.items(), "Stampa Regolarizzazioni");

			FOR_EACH_SHEET_ROW_LOOP(sht, r)
			{
				if (!pi.add_status())
					break;
				if (sht.get_bool_row_cell(r, S_SELECTED))
				{
					const long          nreg = sht.get_long_row_cell(r, S_NUMREG);
					TProgram_report mov_rep("fp0700a");
		    	TISAM_recordset * recset = (TISAM_recordset *)mov_rep.recordset();
					const TRectype & mov = cache().get(LF_MOV, nreg);

					recset->set_var("#NUM", nreg, true);
					recset->set_var("#TIPODOCSDI", tipo_doc_sdi, true);

					const TCausale & caus = cached_causale(mov.get(MOV_CODCAUS), mov.get_int(MOV_ANNOES));

					const TString & prefix = caus.reg().prefisso();
					if (prefix.full()) 
					{
						TString num_prefix;
						num_prefix.insert("/");
						num_prefix.insert(prefix);
						recset->set_var("#NUMPREFIX", num_prefix, true);
					}
					else 
					{
						recset->set_var("#NUMPREFIX", EMPTY_STRING, true);
					}
						
					book.add(mov_rep);
				}
			}
		}
		book.print_or_preview();
	}
}

bool TPAR_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
	const bool diagn = get_bool(F_DIAGN);
	TString filter_selected = get(F_REGSEL);
	bool ok = true;

	switch (o.dlg())
	{
	case DLG_RECALC:
		if (e == fe_button)
			next_page(1);
		break;
	case F_DATAINI:
		if (e == fe_init)
			o.set(ini_get_string(CONFIG_DITTA, "fp", "LastXML", "01-01-2019"));
		else if (e == fe_close)
			ini_set_string(CONFIG_DITTA, "fp", "LastXML", o.get());
		break;
	case F_DATAEND:
		if (e == fe_init)
			o.set(TDate(TODAY));
	case F_REGS:
		if (e == se_query_add || e == se_query_del)
			return false;
		break;
	case F_TIPO_SDI:
		if (e == fe_modify)
			load_sheet(o.get());
		break;
	case DLG_OK:
		if (e == fe_button) 
		{
			if (diagn && filter_selected == "D")
				ok = yesno_box(FR("Le fatture selezionate sono gia' state esportate in stato diagnosticato.\n Continuare?"));
			if(ok)
				export_paf();
		}
		break;
	case DLG_PRINT:
		if (e == fe_button)
			print_reg();
		break;
	case DLG_USER:
		if (e == fe_button && jolly > 0)
		{
			TSheet_field&  regs = sfield(F_REGS);
			TToken_string& row = regs.row(regs.selected());
			TMovimento_contabile       mov(regs.get_long_row_cell(regs.selected(), S_NUMREG));
		
			if (mov.edit()) // Perchè prima andava senza dovergli mettere nulla?
				fill();
		}
		break;
	case DLG_ALL:
	{
		if (e == fe_button)
		{
			TSheet_field&  regs = sfield(F_REGS);
			TString_array& sht = regs.rows_array();
			const int      items = sht.items();

			if (items > 0)
			{
				const TString4 select = *(sht.row(0).get(0)) == 'X' ? "" : "X";
				for (int i = 0; i < items; i++)
					sht.row(i).add(select, 0);
				regs.force_update();
			}
		}
	}
	break;
	case DLG_SAVEREC:
	{
		if (e == fe_button)
			delete_paf();
	}
	break;
	default: break;
	}
	if ((e == fe_modify || e >= se_enter) && jolly == 0)
	{
		if (o.dlg() >= START_MASK && o.dlg() <= END_MASK)
		{
			set_filter_changed();
		}
	}
	return true;
}

void TPAR_mask::next_page(int p)
{
	bool ok = true;
	if (_filter_changed && p != 1000)
	{
		if ((ok = _filter_changed = check_full_fields()))
		{
			save_all_fields();
			fill();
			_filter_changed = false;
		}
	}
	if (ok)
		TAutomask::next_page(p);
}

bool TPAR_mask::on_key(KEY key)
{
	const bool ok = TMask::on_key(key);

	if (ok && curr_page() == 0)
	{
		disable(DLG_OK);
		disable(DLG_PRINT);
		disable(DLG_SAVEREC);
		disable(DLG_ALL);
	}
	if (key == K_SHIFT + K_F12)
	{
		if (run_fp_psw_mask())
		{
			_enable_chiave_fixer = true;
			if (curr_page() > 0)
				force_reload_sheet();
		}
	}
	return ok;
}

bool TPAR_mask::check_not_empty()
{
	TSheet_field& sheet = sfield(F_REGS);
	TString       msg;

	if (sheet.empty())
		msg = "La tabella dei movimenti è vuota, vuoi caricarla con i filtri selezionati?";
	else if (_filter_changed)
		msg = "I filtri sono stati cambiati, vuoi ricaricare la tabella con i nuovi filtri selezionati?";

	if (msg.full() && yesno_box(msg))
	{
		next_page(1);
	}
	return sheet.full();
}

bool TPAR_mask::check_full_fields() const
{
	// Controllo ogni campo che sia valorizzato
	FOR_EACH_MASK_FIELD(*this, i, f)
	{
		if (!f->on_key(K_ENTER))
			return false;
	}
	return true;
}

void TPAR_mask::delete_paf()
{
	// Vado a riportare sui paf l'errore
	TSheet_field& sfld = sfield(F_REGS);
	TProgress_monitor pi(sfld.items(), "Cambio stato fatture");
	

	FOR_EACH_SHEET_ROW_LOOP(sfld, r)
	{
		if (!pi.add_status())
			break;

		if (sfld.get_bool_row_cell(r, S_SELECTED))
		{
			// Ricontrollo che la fattura sia presente in Campo prima di cambiare stato
			long nreg = sfld.get_long_row_cell(r, S_NUMREG);
			const TRectype & mov = cache().get(LF_MOV, nreg);
			TString hfatt, bfatt;
			const TString tipodocsdi = sfld.get_str_row_cell(r, S_TIPODOC);
			TPaf_record paf0100f("PAF0100F");

			if (chiave_paf_mov(mov, tipodocsdi, hfatt, bfatt) && paf0100f.search(nullptr, hfatt, bfatt))
			{
				TString query;

				query <<
					"DELETE FROM PAF0100F WHERE P1_KEYHEADERFATT = '" << hfatt << "' AND P1_KEYBODYFATT = '" << bfatt << "';\n" <<
					"DELETE FROM PAF0200F WHERE P2_KEYHEADERFATT = '" << hfatt << "' AND P2_KEYBODYFATT = '" << bfatt << "';\n" <<
					"DELETE FROM PAF0400F WHERE P4_KEYHEADERFATT = '" << hfatt << "' AND P4_KEYBODYFATT = '" << bfatt << "';\n" <<
					"DELETE FROM PAF0700F WHERE P7_KEYHEADERFATT = '" << hfatt << "' AND P7_KEYBODYFATT = '" << bfatt << "';\n" <<
					"DELETE FROM PAF0800F WHERE P8_KEYHEADERFATT = '" << hfatt << "' AND P8_KEYBODYFATT = '" << bfatt << "';\n" <<
					"DELETE FROM PAF1000F WHERE P0_KEYHEADERFATT = '" << hfatt << "' AND P0_KEYBODYFATT = '" << bfatt << "';\n" <<
					"DELETE FROM PAF1100F WHERE PA_KEYHEADERFATT = '" << hfatt << "' AND PA_KEYBODYFATT = '" << bfatt << "';\n" <<
					"DELETE FROM PAF1200F WHERE PB_KEYHEADERFATT = '" << hfatt << "' AND PB_KEYBODYFATT = '" << bfatt << "';\n" <<
					"DELETE FROM PAF1400F WHERE PD_KEYHEADERFATT = '" << hfatt << "' AND PD_KEYBODYFATT = '" << bfatt << "';\n" <<
					"DELETE FROM PAF1600F WHERE PF_KEYHEADERFATT = '" << hfatt << "' AND PF_KEYBODYFATT = '" << bfatt << "';\n" <<
					"DELETE FROM PAF1700F WHERE PG_KEYHEADERFATT = '" << hfatt << "' AND PG_KEYBODYFATT = '" << bfatt << "';\n" <<
					"DELETE FROM PAF1800F WHERE PI_KEYHEADERFATT = '" << hfatt << "' AND PI_KEYBODYFATT = '" << bfatt << "';\n" <<
					"DELETE FROM PAF1900F WHERE PY_KEYHEADERFATT = '" << hfatt << "' AND PY_KEYBODYFATT = '" << bfatt << "';\n" <<
					"DELETE FROM PAF2000F WHERE PJ_KEYHEADERFATT = '" << hfatt << "' AND PJ_KEYBODYFATT = '" << bfatt << "';\n" <<
					"DELETE FROM PAF2100F WHERE PK_KEYHEADERFATT = '" << hfatt << "' AND PK_KEYBODYFATT = '" << bfatt << "';\n" <<
					"DELETE FROM PAF2200F WHERE PL_KEYHEADERFATT = '" << hfatt << "' AND PL_KEYBODYFATT = '" << bfatt << "';\n" <<
					"DELETE FROM PAF2400F WHERE PN_KEYHEADERFATT = '" << hfatt << "' AND PN_KEYBODYFATT = '" << bfatt << "';\n" <<
					"DELETE FROM PAF2500F WHERE PO_KEYHEADERFATT = '" << hfatt << "' AND PO_KEYBODYFATT = '" << bfatt << "';\n" <<
					"DELETE FROM PAF2600F WHERE PP_KEYHEADERFATT = '" << hfatt << "' AND PP_KEYBODYFATT = '" << bfatt << "';\n" <<
					"DELETE FROM PAF2700F WHERE PQ_KEYHEADERFATT = '" << hfatt << "' AND PQ_KEYBODYFATT = '" << bfatt << "';\n" <<
					"DELETE FROM PAF3000F WHERE PT_KEYHEADERFATT = '" << hfatt << "' AND PT_KEYBODYFATT = '" << bfatt << "';\n" <<
					"DELETE FROM PAF3200F WHERE PU_KEYHEADERFATT = '" << hfatt << "' AND PU_KEYBODYFATT = '" << bfatt << "';\n" <<
					// PAFW3 non ha il flag di gestione
					"DELETE FROM PAFW300F WHERE PW_KEYHEADERFATT = '" << hfatt << "' AND PW_KEYBODYFATT = '" << bfatt << "';\n";

				/*
				query <<
					"UPDATE PAF0100F SET P1_GESTIONE = 'E', P1_KEYPRGINVIO = 'DELETED' WHERE P1_KEYHEADERFATT = '" << hfatt << "' AND P1_KEYBODYFATT = '" << bfatt << "';\n" <<
					"UPDATE PAF0200F SET P2_GESTIONE = 'E', P2_KEYPRGINVIO = 'DELETED' WHERE P2_KEYHEADERFATT = '" << hfatt << "' AND P2_KEYBODYFATT = '" << bfatt << "';\n" <<
					"UPDATE PAF0400F SET P4_GESTIONE = 'E', P4_KEYPRGINVIO = 'DELETED' WHERE P4_KEYHEADERFATT = '" << hfatt << "' AND P4_KEYBODYFATT = '" << bfatt << "';\n" <<
					"UPDATE PAF0700F SET P7_GESTIONE = 'E', P7_KEYPRGINVIO = 'DELETED' WHERE P7_KEYHEADERFATT = '" << hfatt << "' AND P7_KEYBODYFATT = '" << bfatt << "';\n" <<
					"UPDATE PAF0800F SET P8_GESTIONE = 'E', P8_KEYPRGINVIO = 'DELETED' WHERE P8_KEYHEADERFATT = '" << hfatt << "' AND P8_KEYBODYFATT = '" << bfatt << "';\n" <<
					"UPDATE PAF1000F SET P0_GESTIONE = 'E', P0_KEYPRGINVIO = 'DELETED' WHERE P0_KEYHEADERFATT = '" << hfatt << "' AND P0_KEYBODYFATT = '" << bfatt << "';\n" <<
					"UPDATE PAF1100F SET PA_GESTIONE = 'E', PA_KEYPRGINVIO = 'DELETED' WHERE PA_KEYHEADERFATT = '" << hfatt << "' AND PA_KEYBODYFATT = '" << bfatt << "';\n" <<
					"UPDATE PAF1200F SET PB_GESTIONE = 'E', PB_KEYPRGINVIO = 'DELETED' WHERE PB_KEYHEADERFATT = '" << hfatt << "' AND PB_KEYBODYFATT = '" << bfatt << "';\n" <<
					"UPDATE PAF1400F SET PD_GESTIONE = 'E', PD_KEYPRGINVIO = 'DELETED' WHERE PD_KEYHEADERFATT = '" << hfatt << "' AND PD_KEYBODYFATT = '" << bfatt << "';\n" <<
					"UPDATE PAF1600F SET PF_GESTIONE = 'E', PF_KEYPRGINVIO = 'DELETED' WHERE PF_KEYHEADERFATT = '" << hfatt << "' AND PF_KEYBODYFATT = '" << bfatt << "';\n" <<
					"UPDATE PAF1700F SET PG_GESTIONE = 'E', PG_KEYPRGINVIO = 'DELETED' WHERE PG_KEYHEADERFATT = '" << hfatt << "' AND PG_KEYBODYFATT = '" << bfatt << "';\n" <<
					"UPDATE PAF1800F SET PI_GESTIONE = 'E', PI_KEYPRGINVIO = 'DELETED' WHERE PI_KEYHEADERFATT = '" << hfatt << "' AND PI_KEYBODYFATT = '" << bfatt << "';\n" <<
					"UPDATE PAF1900F SET PY_GESTIONE = 'E', PY_KEYPRGINVIO = 'DELETED' WHERE PY_KEYHEADERFATT = '" << hfatt << "' AND PY_KEYBODYFATT = '" << bfatt << "';\n" <<
					"UPDATE PAF2000F SET PJ_GESTIONE = 'E', PJ_KEYPRGINVIO = 'DELETED' WHERE PJ_KEYHEADERFATT = '" << hfatt << "' AND PJ_KEYBODYFATT = '" << bfatt << "';\n" <<
					"UPDATE PAF2100F SET PK_GESTIONE = 'E', PK_KEYPRGINVIO = 'DELETED' WHERE PK_KEYHEADERFATT = '" << hfatt << "' AND PK_KEYBODYFATT = '" << bfatt << "';\n" <<
					"UPDATE PAF2200F SET PL_GESTIONE = 'E', PL_KEYPRGINVIO = 'DELETED' WHERE PL_KEYHEADERFATT = '" << hfatt << "' AND PL_KEYBODYFATT = '" << bfatt << "';\n" <<
					"UPDATE PAF2400F SET PN_GESTIONE = 'E', PN_KEYPRGINVIO = 'DELETED' WHERE PN_KEYHEADERFATT = '" << hfatt << "' AND PN_KEYBODYFATT = '" << bfatt << "';\n" <<
					"UPDATE PAF2500F SET PO_GESTIONE = 'E', PO_KEYPRGINVIO = 'DELETED' WHERE PO_KEYHEADERFATT = '" << hfatt << "' AND PO_KEYBODYFATT = '" << bfatt << "';\n" <<
					"UPDATE PAF2600F SET PP_GESTIONE = 'E', PP_KEYPRGINVIO = 'DELETED' WHERE PP_KEYHEADERFATT = '" << hfatt << "' AND PP_KEYBODYFATT = '" << bfatt << "';\n" <<
					"UPDATE PAF2700F SET PQ_GESTIONE = 'E', PQ_KEYPRGINVIO = 'DELETED' WHERE PQ_KEYHEADERFATT = '" << hfatt << "' AND PQ_KEYBODYFATT = '" << bfatt << "';\n" <<
					"UPDATE PAF3000F SET PT_GESTIONE = 'E', PT_KEYPRGINVIO = 'DELETED' WHERE PT_KEYHEADERFATT = '" << hfatt << "' AND PT_KEYBODYFATT = '" << bfatt << "';\n" <<
					"UPDATE PAF3200F SET PU_GESTIONE = 'E', PU_KEYPRGINVIO = 'DELETED' WHERE PU_KEYHEADERFATT = '" << hfatt << "' AND PU_KEYBODYFATT = '" << bfatt << "';\n" <<
					// PAFW3 non ha il flag di gestione
					"UPDATE PAFW300F SET PW_KEYPRGINVIO = 'DELETED' WHERE PW_KEYHEADERFATT = '" << hfatt << "' AND PW_KEYBODYFATT = '" << bfatt << "';\n";
					*/
				if (!fp_db().sq_set_exec(query))
				{
					TString err = "Impossibile salvare la regolarizzazione "; err << nreg << "\nVerrà saltata.";
					error_box(err);
				}
			}
			else
			{
				TString err = "Impossibile trovare la fattura "; err << nreg << "\nVerrà saltata.";
				error_box(err);
			}
		}
	}
	fp_db().sq_commit();
	force_reload_sheet();
}

TPAR_mask::TPAR_mask() : TAutomask("fp0700a"), _filter_changed(true), _enable_chiave_fixer(false)
{
	disable(DLG_OK);
	disable(DLG_PRINT);
	disable(DLG_SAVEREC);
	load_all_fields();
	const TDate data_inizio = get_date_start_new_fatt();
	__mask = this;

}

/////////////////////////////////////////////////////////////////////////////////////
// TReg2Paf
/////////////////////////////////////////////////////////////////////////////////////

class Treg2Paf : public TSkeleton_application
{

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

	Treg2Paf() {}
};

void Treg2Paf::main_loop()
{
	TPAR_mask m;

	m.set(F_DIAGN, true);
	while (m.run() == K_ENTER) {}
}

bool Treg2Paf::create()
{
	open_files(LF_TAB, LF_TABCOM, LF_TABMOD, LF_ANAG,
		LF_CLIFO, LF_CFVEN, LF_CFBAN, LF_NDITTE,
		LF_DOC, LF_RIGHEDOC, LF_CODCORR, LF_ANAMAG, 0);

	const TRectype cfven(LF_CFVEN);
	if (cfven.length(CFV_PADESTIN) != 7) // Nuova lunghezza per privati
		return error_box(TR("Database non convertito per fatturazione F.P."));

	return check_tables() && TSkeleton_application::create();
}

bool Treg2Paf::destroy()
{
	fp_db().sq_disconnect();
	return TSkeleton_application::destroy();
}

int fp0700(int argc, char* argv[])
{
	Treg2Paf d2p;
	d2p.run(argc, argv, TR("Invio Regolarizzazioni"));
	return 0;
}