#include "cg2.h"
#include "applicat.h"
#include "automask.h"
#include "cg2300a.h"
#include "cg2103.h"
#include "lffiles.h"
#include "isam.h"
#include "mov.h"
#include <map>
#include "rmov.h"
#include <vector>
#include "pconti.h"

#define INI_ANNO "riep_anno"
#define INI_MESE "riep_mese"

class TCompetenze_mask : public TAutomask
{
	std::vector<int> _regs;
	std::map<TToken_string*, real> _conts;

	const char* get_ini(bool dataini) const;

	bool on_field_event(TOperable_field& o, TField_event e, long jolly) override;
	static void clear_map(const map<TToken_string*, real>& is);

	// Funzione becera di ordinamento della mappa _conts
	void sort_conts(bool sort_by_imp = true);
	static void swap_items(map<TToken_string*, real>::iterator& it, map<TToken_string*, real>::iterator& jt);
	static bool is_minor_of(TToken_string* jt, TToken_string* it);

	void fill_contc();
	void fill();

public:
	TCompetenze_mask() : TAutomask("cg2300a.msk") {  }
};

const char* TCompetenze_mask::get_ini(bool dataini) const
{
	if (dataini)
		return ini_get_string(CONFIG_DITTA, "cg", INI_ANNO, "");
	return ini_get_string(CONFIG_DITTA, "cg", INI_MESE, "");
}

bool TCompetenze_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
	switch(o.dlg())
	{
	case DLG_LINK:
		if (e == fe_button)
			if (get(F_ANNO).full() && get(F_MESE).full())
				fill();
			else if (get(F_ANNO).blank())
				message_box("Inserire un anno");
			else if (get(F_MESE).blank())
				message_box("Inserire un mese");
		break;
	case DLG_USER:
		if (e == fe_button && jolly > 0)
		{
			TSheet_field& sf = sfield(F_MOVS);
			TToken_string& row = sf.row(sf.selected());
			TRectype mov(LF_MOV);
			mov.put(MOV_NUMREG, row.get(sf.cid2index(F_NUMREG)));
			if (mov.edit())
				fill();
		}
	case F_ANNO:
		if(e == fe_init) set(F_ANNO, get_ini(true));
		break;
	case F_MESE:
		if (e == fe_init)
			set(F_MESE, get_ini(false));
		break;
	default: break;
	}
	return true;
}

void TCompetenze_mask::clear_map(const map<TToken_string*, real>& is)
{
	for(auto it = is.begin(); it != is.end(); ++it)
		delete it->first;
}

bool TCompetenze_mask::is_minor_of(TToken_string* jt, TToken_string* it)
{
	return jt->get_int(0) < it->get_int(0)
		|| (jt->get_int(0) == it->get_int(0) && jt->get_int(1) < it->get_int(1))
		|| (jt->get_int(0) == it->get_int(0) && jt->get_int(1) == it->get_int(1)
			&& jt->get_int(2) < it->get_int(2));
}

void TCompetenze_mask::swap_items(map<TToken_string*, real>::iterator& it,
	map<TToken_string*, real>::iterator& jt)
{
	TToken_string* appo = new TToken_string();
	for (int i = 0; i < it->first->items(); i++)
		appo->add(it->first->get(i), i);

	const real appo_importo = it->second;

	for (int i = 0; i < jt->first->items(); i++)
		it->first->add(jt->first->get(i), i);
	it->second = jt->second;

	for (int i = 0; i < appo->items(); i++)
		jt->first->add(appo->get(i), i);
	jt->second = appo_importo;

	delete appo;
}

void TCompetenze_mask::sort_conts(bool sort_by_imp)
{
	// Sopra cento rischia di essere leggermente lento
	if( 1 < _conts.size() && _conts.size() < 100)
		for (auto it = _conts.begin(); it != _conts.end(); ++it)
			for (auto jt = it; jt != _conts.end(); ++jt)
				if(sort_by_imp && jt->second > it->second || !sort_by_imp && is_minor_of(jt->first, it->first))
					swap_items(it, jt);
}

void TCompetenze_mask::fill_contc()
{
	TSheet_field& sf = sfield(F_CONTC);
	TLocalisamfile rmovs(LF_RMOV);

	sf.hide();
	sf.reset();

	clear_map(_conts);
	_conts.clear();
	// Per ogni registrazione
	for (int i=0; i < _regs.size(); ++i)
	{
		const int numreg = _regs[i];
		rmovs.zero();
		rmovs.put(RMV_NUMREG, numreg);
		rmovs.put(RMV_NUMRIG, 0);
		int riga = 0;
		if (rmovs.read())
		{
			// Per ogni riga della registrazione
			for (; rmovs.get_int(RMV_NUMREG) == numreg; rmovs.next())
			{
				const int				gruppo			= rmovs.get_int(RMV_GRUPPOC);
				const int				numcontc		= rmovs.get_int(RMV_CONTOC);
				const int				sottoconto	= rmovs.get_int(RMV_SOTTOCONTOC);
				const TString&	tipocc			= rmovs.get(RMV_TIPOCC);
				const real			importo(rmovs.get(RMV_IMPORTO));

				if (tipocc.blank()) // Solo se il tipo di conto di contr. e' un conto, cioe' vuoto
				{
					// Cerco se ho già la chiave
					auto it = _conts.begin();
					for (; it != _conts.end(); ++it)
					{
						if (it->first->get_int(0) == gruppo
							&& it->first->get_int(1) == numcontc
							&& it->first->get_int(2) == sottoconto)
							break;
					}

					if (it != _conts.end())
						it->second += importo;
					else
					{
						TToken_string* contr = new TToken_string();
						contr->add(gruppo);
						contr->add(numcontc);
						contr->add(sottoconto);
						_conts.insert(_conts.end(), { contr, importo });
					}
				}
			}
		}
	}

	sort_conts(get(F_ORDIN) == "X");

	real tot; tot = 0;
	for (auto it = _conts.begin(); it != _conts.end(); ++it)
	{
		TLocalisamfile pcont(LF_PCON);
		const char* gruppo = it->first->get(0);
		const char* conto = it->first->get(1);
		const char* sottoconto = it->first->get(2);
		TString tipoc = it->first->get(3);
		pcont.put(PCN_GRUPPO, gruppo);
		pcont.put(PCN_CONTO, conto);
		pcont.put(PCN_SOTTOCONTO, sottoconto);
		pcont.read();
		TToken_string& row = sf.row(-1);
		row.add(gruppo);
		row.add(conto);
		row.add(sottoconto);
		row.add(pcont.get(PCN_DESCR));
		row.add(it->second);
		tot += it->second;
	}

	sf.force_update();
	sf.show();

	set(F_TOT, tot);
}

void TCompetenze_mask::fill()
{
	const int anno = get_int(F_ANNO);
	const int mese = get_int(F_MESE);
	TSheet_field& sf = sfield(F_MOVS);
	TLocalisamfile movs(LF_MOV);

	sf.hide();
	sf.reset();
	_regs.clear();
	movs.setkey(2);

	const TDate dataini(1, mese, anno);
	TDate dataend(dataini); dataend.set_end_month();
	movs.put(MOV_DATAREG, dataini);
	if(movs.read() != NULL)
	{
		for (; movs.next() == NOERR && movs.get_date(MOV_DATAREG) <= dataend; )
		{
			const int month_liq = movs.get_int(MOV_MESELIQ);
			TDate datareg(movs.get(MOV_DATAREG));
			TDate datacomp(movs.get(MOV_DATACOMP));
			if(month_liq == 0 && datacomp < datareg || month_liq != 0 && month_liq < datareg.month())
			{
				_regs.insert(_regs.end(),movs.get_int(MOV_NUMREG));

				TToken_string& row = sf.row(-1);
				row.add(movs.get(MOV_NUMREG));
				row.add(datareg);
				row.add(movs.get(MOV_DATADOC));
				row.add(TCausale(movs.get(MOV_CODCAUS)).tipo_doc());
				row.add(month_liq);
				row.add(movs.get(MOV_NUMDOC));
				row.add(movs.get(MOV_PROTIVA));
				row.add(movs.get(MOV_DESCR));
			}
			
		}
	}
	sf.force_update();
	sf.show();

	fill_contc();
}

///////////////////////////////////////////////////////////////////////////////
// TCompetenze_app
///////////////////////////////////////////////////////////////////////////////

class TCompetenze_app : public TSkeleton_application
{
	TCompetenze_mask* _msk;
protected:
	void set_ini(bool dataini, const TString& set) const;
	void save_fields() const;

public:
	void main_loop() override;

	TCompetenze_app() : _msk() {};
};

void TCompetenze_app::set_ini(bool dataini, const TString& set) const
{
	if(!set.empty())
	{
		if (dataini)
			ini_set_string(CONFIG_DITTA, "cg", INI_ANNO, set);
		else
			ini_set_string(CONFIG_DITTA, "cg", INI_MESE, set);
	}
}

void TCompetenze_app::save_fields() const
{
	set_ini(true, _msk->get(F_ANNO));
	set_ini(false, _msk->get(F_MESE));
}

void TCompetenze_app::main_loop()
{
	_msk = new TCompetenze_mask;
	while (_msk->run() == K_ENTER) {  }
	save_fields();
}

int cg2300(int argc, char** argv)
{
	TCompetenze_app* app = new TCompetenze_app;
	app->run(argc, argv, TR("Registrazioni Competenza Precedente"));
	delete app;
	return 0;
}