#include "lilib01.h"
#include <recarray.h>
#include <utility.h>

#define SOLUZIONE_UNICA 1
#define FINO_A_PLAFOND	2

void TLi_manager::elabTipiStati()
{
	if(tipi.blank() && stati.blank())
	{
		for(int i = 0; i < tipidoc.items(); i++)
		{
			TString app("");
			tipidoc.get(i, app);
			TToken_string statidoc(ini_get_string(CONFIG_DITTA, "li", app), ',');
			for(int j = statidoc.get_int(0); j <= statidoc.get_int(1); j++)
			{
				tipi.add(app);
				stati.add(j);
			}
		}
	}
}


const TToken_string& TLi_manager::getUse(TDocumento& d, const bool write)
{
	static TToken_string& ret = get_tmp_string();
	TAssoc_array tabIva = d.tabella_iva(true);

	real plaUtil = ZERO;

	for (TRiepilogo_iva * totali = (TRiepilogo_iva *) tabIva.get(); totali != NULL; totali = (TRiepilogo_iva *) tabIva.get())
	{
		if(checkIva(totali->cod_iva().codice()))	// Se l'iva del documento è diversa non mi interessa
		{
			plaUtil += totali->imp_orig();
		}
	}

	if(plaUtil > ZERO)
	{
		if(d.is_nota_credito())
		{
			ret.cut(0) << incrPlaf(d, plaUtil, write);
		}
		else
		{
			ret.cut(0) << consPlaf(plaUtil, write);
			if(ret.starts_with("ERRORE"))
				ret << " al documento " << d.numerazione() <<  " n." << d.numero() << "\nTotale plafond da consumare: " << plaUtil.string() << "\nTotale rimasto: " << getPlafond().string();
		}
	}

	return ret;
}

const TToken_string& TLi_manager::consPlaf(real& plafUsed, const bool write) 
{
	static TToken_string used("", ','); used.cut(0);
	if(!validPlafond || plafUsed > getPlafond())
	{
		used << "ERRORE NEL CALCOLO DEL PLAFOND";
		return used;
	}
	
	bool close = false;
	TToken_string thisPlaf("", ',');
	while(plafUsed > ZERO)
	{
		// Calcolo quanto plafond ho usato
		TString thisNumprot = plafondi.begin()->first;
		real thisAmount = plafondi.begin()->second;
		
		real thisUtilizzato;

		if(plafUsed >= thisAmount)
		{
			close = true;
			thisUtilizzato = thisAmount;

			// Rimuovo il plafond dalla lista,
			plafondi.erase(thisNumprot);

			if(write)
			{
				// lo chiudo
				changeStato(thisNumprot, true);
			}
			
			// e diminuisco tutto
			plafond -= thisAmount;
			plafUsed -= thisAmount;
		}
		else
		{
			close = false;
			thisUtilizzato = plafUsed;
			
			// e diminuisco tutto
			plafond -= plafUsed;
			plafondi[thisNumprot] -= plafUsed;
			plafUsed = ZERO;
		}
		
		// Segno di aver usato il plafond
		static TToken_string u; u.cut(0);
		u.add(thisNumprot, _planno);
		u.add(thisUtilizzato.string(), _plimporto);
		u.add(close? "X" : "", _plchiusura);
		used.add(u);
	}
	// Controllo di avere ancora plafond rimanente
	if(plafond <= ZERO)
		validPlafond = false;
	
	// Tolgo la virgola finale
	used.cut(used.len()-1);

	return used;
}

/* Aggiungo al plafond quello che trovo */
const TToken_string& TLi_manager::incrPlaf(TDocumento& d, real impNC, const bool write)
{
	static TToken_string used("", ','); used.cut(0);
	// Controllo se questa nota credito si riferisce a un singolo documento, in quel caso aggiorno faccio un aggiornamento sulle lettere di intento
	// Se si rifà a più documenti o non è specificato salta, meglio stare bassi
	if(d.get("NUMDOCRIF").blank() || d.get("CODNUMRIF").blank() || d.get("ANNORIF").blank() || iniDicInt.year() != d.get_int("ANNORIF"))
	{
		return used;
	}

	TDocumento ds('D', d.get_int("ANNORIF"), d.get("CODNUMRIF"), d.get_int("NUMDOCRIF"));
	TToken_string lePlafs(ds.get("PLAFOND"), ',');	// [ANNO|NUMPROT|UTILIZZATO],... 

	// Se il documento di riferimento non ha nulla inserito nel plafond esco, non mi interessa
	if(lePlafs.items() == 0)
		return used;

	// Controllo se non ho già ricevuto la quantità da stornare di plafond nella nota credito
	if(impNC == ZERO)
	{
		// In caso negativo la calcolo
		TAssoc_array tabIva = d.tabella_iva(true);
		for (TRiepilogo_iva * totali = (TRiepilogo_iva *) tabIva.get(); totali != NULL; totali = (TRiepilogo_iva *) tabIva.get())
		{
			if(checkIva(totali->cod_iva().codice()))
			{
				impNC += totali->imp_orig();
			}
		}
	}

	// Controllo se ho del plafond da stornare
	if(impNC <= ZERO)
		return used;

	bool open = false;
	TToken_string thisPlaf("", '|');
	for(int i = lePlafs.items() - 1; i >= 0 && impNC > ZERO; i--)
	{
		lePlafs.get(i, thisPlaf);

		// Importo utilizzato del plafond
		real importoPlaf = thisPlaf.get(_plimporto);
		// Importo già riaccreditato da altre NC
		real importoNC = thisPlaf.get(_plNC);
		// Importo possibile di plafond da stornare
		real rimanente = importoPlaf - importoNC;

		if(rimanente == ZERO) 
			// This isn't the plafond you're looking for
			continue;

		if(rimanente < impNC)
		{
			impNC -= rimanente;
		}
		else 
		{
			rimanente = impNC;
			impNC = ZERO;
		}

		// Salvo la quantità utilizzata nelle TToken_string
		thisPlaf.add(rimanente, _plNC);
		lePlafs.add(thisPlaf, i);

		// Aggiungo a plafond
		static TString key; key.cut(0) << thisPlaf.get(_planno) << "|" << thisPlaf.get(_plnumprot);

		if(plafondi.find(key) != plafondi.end())
		{
			open = false;
			// Incremento!
			plafondi[key] += rimanente;
		}
		else
		{
			// Va aggiunto ex novo!
			// Calcolo l'importo delle righe che rientrano nel plafond 
			open = true;
			plafondi.insert(std::pair<TString,real>(key, rimanente));
			
			// Se devo scrivere abilito il plafond
			if(write)
			{
				changeStato(key, false);
			}
		}	
		// Segno di aver usato il plafond
		static TToken_string u; u.cut(0);
		u.add(key, _planno);
		u.add(rimanente.string(), _plimporto);
		u.add(open? "X" : "", _plchiusura);
		used.add(u);
	}
	
	// Rigiro used, nelle note credito sono invertiti i plafond
	static TToken_string usedApp("", ','); usedApp.cut(0);
	for(int i = used.items(); i > 0; i--)
		usedApp.add(used.get(used.items()-i), i-1);

	// Sovrascrivo il documento
	ds.put("PLAFOND", lePlafs);
	ds.rewrite();

	// Tolgo la virgola finale
	used.cut(used.len()-1);

	// Succedono cose in memoria, devo rimediare così
	return usedApp;
}
/*
void TLi_manager::stornaDoc(const TDocumento& d, const bool write)
{
	// Devo ricaricare le righe sui plafond che ho
	TToken_string plafs(d.get("PLAFOND"), ',');
	for(int i = 0; i < plafs.items(); i++)
	{
		TToken_string thisPlafond = plafs.get(i);
		static TString key; key.cut(0) << thisPlafond.get(_planno) << "|" << thisPlafond.get(_plnumprot);
		real thisImporto = thisPlafond.get(_plimporto);
		TString asd = thisImporto.string();
		if(d.is_nota_credito())
		{
			if(plafondi.find(key) != plafondi.end())
			{
				if(thisImporto < plafondi[key])
				{
					// Sottraggo
					plafondi[key] -= thisImporto;
				}
				else
				{
					if(DEBUG_ENABLED)
					{
						if(thisImporto > plafondi[key])
							error_box("Importo maggiore del plafond rimanente");
					}
					plafondi.erase(key);
				}
			}
			else if(DEBUG_ENABLED)
			{
				error_box("Houston abbiamo un problema...perchè non trovo questo plafond attivo!?");
			}
		}
		else
		{
			if(plafondi.find(key) != plafondi.end())
			{
				//Sommo
				plafondi[key] += thisImporto;
			}
			else
			{
				// Aggiungo ai plafond
				plafondi.insert(std::pair<TString, real>(key, thisImporto));
				// Se devo scrivere abilito il plafond
				if(write)
				{
					changeStato(key, false);
				}
			}
		}
	}
}

// Storna i documenti dopo a quello che riceve
void TLi_manager::stornaDocs(const TDocumento& d, const bool write)
{
	TLista_documenti din;               // Legge tutti i documenti di input

	// Trovo tutti i documenti che mi interessano
	din.read('D', tipocf, codcli, iniDicInt.year(), tipi, stati, d.data(), finDicInt);
	
	for(int i = 0; i < din.items(); i++)
	{
		if(d.numero() < din[i].numero())
		{
			stornaDoc(din[i], write);
		}
	}
}
*/
const TToken_string& TLi_manager::stornaDoc(const TDocumento& d, real impDC, const bool write)
{
	static TToken_string used("", ','); used.cut(0);
	// True se devo stornare tutto il Doc
	bool totale = impDC.is_zero();
	bool ok = true;
	// Devo ricaricare le righe sui plafond che ho
	TToken_string plafs(d.get("PLAFOND"), ',');
	for(int i = 0; i < plafs.items() && impDC > ZERO; i++)
	{
		TToken_string thisPlafond = plafs.get(i);
		static TString key; key.cut(0) << thisPlafond.get(_planno) << "|" << thisPlafond.get(_plnumprot);
		real thisImporto = thisPlafond.get(_plimporto);
		if(totale)
		{
			if(thisImporto >= impDC)
			{
				thisImporto = impDC;
				// Controllo se vado a stornare solo una parte o tutto, nel primo caso cambio la Token, nel secondo elimino normalmente
				if(thisImporto > impDC)
				{
					thisPlafond.add(impDC, _plimporto);
					plafs.add(thisPlafond, i);
				}
				else
					plafs.destroy(i);
				impDC = ZERO;
			}
			else
			{
				impDC -= thisImporto;
				plafs.destroy(i);
			}
		}
		TString asd = thisImporto.string();
		if(d.is_nota_credito())
		{
			if(plafondi.find(key) != plafondi.end())
			{
				if(thisImporto < plafondi[key])
				{
					// Sottraggo
					plafondi[key] -= thisImporto;
				}
				else
				{
					// Errore
					used.cut(0) << "ERRORE: Non è presente abbastanza plafond rimanente per stornare la Nota Credito";
					return used;
				}
			}
			else
			{
				// Errore
				if(DEBUG_ENABLED)
					error_box("Houston abbiamo un problema...perchè non trovo questo plafond attivo!?");
				used.cut(0) << "ERRORE: La lettera d'intento a cui si rifà questa Nota Credito non è aperta";
				return used;
			}
		}
		else
		{
			if(plafondi.find(key) != plafondi.end())
			{
				//Sommo
				plafondi[key] += thisImporto;
			}
			else
			{
				// Aggiungo ai plafond
				plafondi.insert(std::pair<TString, real>(key, thisImporto));
				// Se devo scrivere abilito il plafond
				if(write)
				{
					changeStato(key, false);
				}
			}
		}
	}
	used.cut(0) << plafs;
	return used;
}

// Where did you come from Cotton Eye Joe!

/*
bool TLi_manager::recalcAfter(const TDocumento& d, TLog_report& lerr)
{
	TLista_documenti din;               // Legge tutti i documenti di input
	bool ok = true;
	int first = -1;
	// Trovo tutti i documenti che mi interessano
	din.read('D', tipocf, codcli, iniDicInt.year(), tipi, stati, d.data(), finDicInt);
	
	for(int i = 0; i < din.items() && ok; i++)
	{
		if(d.numero() < din[i].numero())
		{
			if(first == -1) first = i;
			const TToken_string& use = getUse(din[i], true);
			if(use.starts_with("ERRORE"))
			{
				ok = false;
				lerr.log(2, use);
			}
			else
				din[i].put("PLAFOND", use);
		}
	}
	if(ok)
	{
		// Se va tutto bene scrivo tutti i documenti
		for(; first < din.items(); first++)
			din[first].rewrite();
	}
	return ok;
}
*/
/* Faccio un analisi di tutti i plafond aperti e li sommo salvandomeli in plafonds */

void TLi_manager::elabPlafond()
{
	TRelation letint(LF_LETINT);
	TRectype filtro(letint.curr());
	filtro.add("CODCLI", codcli);
	filtro.add("ANNO", iniDicInt.year());

	// Creo un cursore ordinato e prelevo la prima riga non chiusa
	TCursor c_dicint(&letint, "", 2, &filtro, &filtro);

	validPlafond = false;

	if(c_dicint.items() > 0)
	{
		// Cerco finchè non arrivo alla fine o non trovo una soluzione
		for(c_dicint = 0; c_dicint.pos() < c_dicint.items() && !soluzione; ++c_dicint)
		{
			TRectype row = c_dicint.curr();
			// Esco se raggiungo una data successiva al nostro documento
			if(row.get_date("DAL") > finDicInt)
				break;

			if(!row.get_bool("CHIUSA"))
			{
				if(row.get_int("TIPOOP") != FINO_A_PLAFOND && row.get_int("TIPOOP") != SOLUZIONE_UNICA)	break;

				if(row.get_int("TIPOOP") == SOLUZIONE_UNICA)
				{
					// Faccio un controllo in più per bloccare un utente con plafond di diverso tipo
					if(validPlafond)
					{
						// ERRORE! Esiste già un plafond e ho trovato una soluzione unica!
						validPlafond = false;
						plafondi.clear();
						plafond = -UNO;
						return;
					}
					soluzione = true;
				}
				if(!validPlafond)
					iniDicInt = row.get_date("DAL");
				
				// Aggiungo il plafond trovato all'elenco dei plafond
				static TString key;
				key.cut(0) << row.get("ANNO") << "|" << row.get("NUMPROT");
				plafondi.insert(std::pair<TString,real>(key, row.get_real("IMPORTO")));

				// Aggiungo il valore del plafond al totale
				plafond += row.get_real("IMPORTO");
				validPlafond = true;
			}
		}
	}
	if(!validPlafond)
		plafond = -UNO;
}

const real TLi_manager::getPlaRes()
{
	return elabPlaRes();
}

const real TLi_manager::getPlaRes(TToken_string tipi, TToken_string stati)
{
	return elabPlaRes(tipi, stati);
}

const real TLi_manager::elabPlaRes(TToken_string t, TToken_string s, TDate ad)
{
	if(elabPR)
		return plafond;
	else
		elabPR = true;

	if(t.full() && s.full())
	{
		tipi = t;
		stati = s;
	}
	if(!ad.ok())
		ad = finDicInt;
	plafond = -UNO;
	if(!validPlafond)
		return plafond;

	TLista_documenti din;               // Legge tutti i documenti di input

	// Trovo tutti i documenti che mi interessano e sottraggo l'imponibile al plafond
	din.read('D', tipocf, codcli, iniDicInt.year(), tipi, stati, iniDicInt, ad);
	
	for(int i = 0; i < din.items(); i++)
	{
		TToken_string plaf(din[i].get("PLAFOND"), ',');
		for(int j = 0; j < plaf.items(); j++)
		{
			TToken_string thePla(plaf.get(j));
			static TString key; key.cut(0) << thePla.get(_planno) << "|" << thePla.get(_plnumprot);
			static TString chiusura; chiusura.cut(0) << thePla.get(_plchiusura);	// La get ritorna un const char*
			if(din[i].tipo().nota_credito())
			{
				if(plafondi.find(key) != plafondi.end())
				{
					if(DEBUG_ENABLED && chiusura == "X" && yesno_box("Attenzione! La lettera con codice %s riferito alla nota credito %s, %d l'ho trovata ma dovevo aprirla adesso!\n Che faccio, azzero?", key, din[i].numerazione(), din[i].numero()))
					{
						plafondi[key] = ZERO;
					}
					plafondi[key] += static_cast<real>(thePla.get(_plimporto));
				}
				else
				{
					// Va aggiunto ex novo!
					if(DEBUG_ENABLED && chiusura != "X" && yesno_box("Attenzione! La lettera con codice %s riferito alla nota credito %s, %d non l'ho trovata ma doveva già essere aperta!\n Che faccio, annullo?", key, din[i].numerazione(), din[i].numero()))
					{
						validPlafond =  false;
						return plafond;
					}
					// Calcolo l'importo delle righe che rientrano nel plafond 
					plafondi.insert(std::pair<TString,real>(key, static_cast<real>(thePla.get(_plimporto))));
				}	
			}
			else
			{
				if(plafondi.find(key) != plafondi.end())
				{
					if(chiusura == "X")
					{
						if(DEBUG_ENABLED && plafondi[key] != static_cast<real>(thePla.get(_plimporto)) && 
							!yesno_box(TR("Questa lettera di intento è incongruente,\nTotale attivo: %s\nTotale da disattivare: %s\nContinuare?"), plafondi[key].string(), thePla.get(_plimporto)))
						{
							validPlafond = false;
							return plafond;
						}
						plafondi.erase(key);
					}
					else
					{
						plafondi[key] -= static_cast<real>(thePla.get(_plimporto));
					}
				}
			}
		}
	}

	// Calcolo il totale da mappa scansionata
	plafond = ZERO;
	for(auto it = plafondi.begin(); it != plafondi.end(); ++it)
		plafond += it->second;

	return plafond;
}

 

const real TLi_manager::elabUtil(TToken_string tipi, TToken_string stati, TDate ad)
{
	if(!validPlafond)
		return -UNO;
	if(tipi.items() == 0) 
		return ZERO;

	real utilizzato = ZERO;

	TLista_documenti din;               // Legge tutti i documenti di input

	// Trovo tutti i documenti che mi interessano e sottraggo l'imponibile al plafond
	din.read('D', tipocf, codcli, iniDicInt.year(), tipi, stati, iniDicInt, ad);
	
	for(int i = 0; i < din.items(); i++)
	{
		TAssoc_array tabIva = din[i].tabella_iva(true);
		for (TRiepilogo_iva * totali = (TRiepilogo_iva *) tabIva.get(); totali != NULL; totali = (TRiepilogo_iva *) tabIva.get())
		{
			if(checkIva(totali->cod_iva().codice()))
			{
				utilizzato += cache().get("%TIP", din[i].tipo().codice()).get_bool("B7") ? -totali->imp_orig() : totali->imp_orig();
			}
		}
		
		// Nel caso il plafond trovato fosse una soluzione unica e ho già trovato dei documenti vuol dire che il plafond non è più valido
		if(soluzione) 
		{
			utilizzato = -UNO; 
			break;
		}
	}

	return utilizzato;
}

bool TLi_manager::testPlafond(TLista_documenti& dout, TLog_report& lerr)
{
	bool err = false;
	static TToken_string& use = get_tmp_string();
	// Faccio un ragionamento identico a getPlaRes, ma in input ho la lista di documenti appena elaborati
	for(int i = 0; i < dout.items() && !err; i++)
	{
		use.cut(0) << getUse(dout[i], true);
		if(use.starts_with("ERRORE"))
		{
			TString msgerr;
			msgerr << "Superata dichiarazione di intento cliente N." << dout[i].codcf() << "\n" << use;
			lerr.log(2, msgerr);
			revertModifiche();
			clearModifiche();
			err = true;
		}
		else
		{
			dout[i].put("PLAFOND", use);
		}
	}

	return err;
}

/* Per scelte implementative non ha una accuratezza del 100% */
bool	TLi_manager::checkUtilizzo(TDocumento& d, real impNC)
{
	TLista_documenti din;
	bool ok;
	TToken_string lePlafs(d.get("PLAFOND"), ',');

	// Se me lo passa la funzione evito di calcolarlo
	if(impNC.is_zero())
	{
		for (TRiepilogo_iva * totali = (TRiepilogo_iva *) d.tabella_iva(true).get(); totali != NULL; totali = (TRiepilogo_iva *) d.tabella_iva(true).get())
			if(checkIva(totali->cod_iva().codice()))	// Se l'iva del documento è diversa non mi interessa
				impNC += totali->imp_orig();
	}

	/* Per sapere se non ho usato il plafond di questa NC controllo innanzitutto se c'è ne abbastanza 
	 * rimasto per coprire la NC, non è il controllo della vita ma toglie già un po' di calcoli	*/
	ok = getPlaRes() > impNC;

	// Sucessivamente vado in dettaglio a verificare se sono sempre maggiori (getPlaRes() mi carica anche la variabile "plafondi" per gli altri calcoli)
	for(int i = 0; i < lePlafs.items() && ok; i++)
	{
		TToken_string thisPlaf(lePlafs.get(i));
		static TString key; key.cut(0) << thisPlaf.get(_planno) << "|" << thisPlaf.get(_plnumprot);
		if(plafondi.find(key) != plafondi.end())
		{
			ok = plafondi[key] > static_cast<real>(lePlafs.get(_plimporto));
		}
		else
			ok = false;
	}

	return ok;
}

void TLi_manager::changeStato(const TString& key, const bool stato)
{
	TRectype Jean_Baptiste_Le_Rond_dAlembert = cache().get(LF_LETINT, key);	// Che nome di classe!
	Jean_Baptiste_Le_Rond_dAlembert.put("CHIUSA", stato);
	Jean_Baptiste_Le_Rond_dAlembert.rewrite(TLocalisamfile(LF_LETINT));

	TString skey; skey << key << "|" << stato ? "" : "X";	// Ottimizzazione portami via...
	modifiche.insert(std::pair<int, TString>(modifiche.size()+1, skey));
}

void TLi_manager::revertModifiche()
{
	if(!hasModifiche())
		return;
	TLocalisamfile baguette(LF_LETINT);

	for(auto it = modifiche.begin(); it != modifiche.end(); ++it)
	{
		TToken_string key = it->second;
		TRectype Jean_Baptiste_Le_Rond_dAlembert = cache().get(LF_LETINT, key.get(0));	// Che nome di classe!
		Jean_Baptiste_Le_Rond_dAlembert.put("CHIUSA", key.get(1));
		Jean_Baptiste_Le_Rond_dAlembert.rewrite(baguette);
	}
	clearModifiche();
}

TLi_manager::TLi_manager(const char t, const long c, TDate iniDic, TDate finDic) 
	: tipocf (t), codcli(c), iniDicInt(iniDic), finDicInt(finDic),
	tipidoc(ini_get_string(CONFIG_DITTA, "li", "TIPIDOC")),
	codivaDef(ini_get_string(CONFIG_DITTA, "li", "CODIVA")),
	codivaAlt(ini_get_string(CONFIG_DITTA, "li", "CODIVALT")),
	plafond(ZERO), validPlafond(false), soluzione(false), elabPR(false)
{
	elabTipiStati();
	elabPlafond();
}

TLi_manager::TLi_manager(const char t, const long c, TDate finDic)
	: tipocf (t), codcli(c), finDicInt(finDic),
	tipidoc(ini_get_string(CONFIG_DITTA, "li", "TIPIDOC")),
	codivaDef(ini_get_string(CONFIG_DITTA, "li", "CODIVA")),
	codivaAlt(ini_get_string(CONFIG_DITTA, "li", "CODIVALT")),
	plafond(ZERO), validPlafond(false), soluzione(false), elabPR(false)
{
	iniDicInt.set_day(01);
	iniDicInt.set_month(01);
	iniDicInt.set_year(finDic.year());
	elabTipiStati();
	elabPlafond();
}