#include "KESSVorschau.h"
#include "../../../../Global/Variablen.h"
#include "../../../../Global/Initialisierung.h"
#include <DateiSystem.h>
#include <Globals.h>

void kESSVorschauKSGSAktion(void* p, RCArray< KSGSVariable >* parameter, KSGSVariable** retVal)
{
	if (!p)
		return;
	((KESSVorschauKarteScript*)p)->ksgsAktion(parameter, retVal);
}

// Inhalt der KESSVorschauKarteScript Klasse aus KESSVorschau.h
// Konstruktor
KESSVorschauKarteScript::KESSVorschauKarteScript(TextFeld* zLog)
	: Thread()
{
	ksgs = Framework::getDLLRegister()->ladeDLL("KSGScript.dll", "data/bin/KSGScript.dll");
	if (ksgs)
	{
		KSGSGetZeichnung getKSGScript = (KSGSGetZeichnung)GetProcAddress(ksgs, KSGS_START_FUNKTION);
		if (getKSGScript)
		{
			fenster = getKSGScript();
			fenster->setSchriftZ(dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()));
			fenster->setSize(555, 380);
			fenster->setCallbackParam(this);
			fenster->setCallbackFunktion(kESSVorschauKSGSAktion);
			fenster->setLog(dynamic_cast<TextFeld*>(zLog->getThis()));
		}
		else
		{
			fenster = 0;
			nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
				new Text("Der Einstiegspunkt '" KSGS_START_FUNKTION "' in der DLL-Datei "
					"'data/bin/KSGScript.dll' konnte nicht gefunden werden."),
				new Text("Ok"), 0);
		}
	}
	else
	{
		fenster = 0;
		nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
			new Text("Die DLL-Datei 'data/bin/KSGScript.dll' konnte nicht geladen werden."),
			new Text("Ok"), 0);
	}
	ram = new LRahmen();
	ram->setSize(555, 380);
	ram->setFarbe(0xFFFFFFFF);
	pos = Punkt(220, 10);
	sichtbar = 0;
	besitztTestVersion = 0;
	verbleibend = 0;
	vollversionErwerbbar = 1;
	testversionErwerbbar = 1;
	vvPreis = 0;
	tvPreis = 0;
	kupfer = 0;
	alpha = 0;
	aktion = 0;
	ak = 0;
}

// Destruktor
KESSVorschauKarteScript::~KESSVorschauKarteScript()
{
	if (fenster)
	{
		fenster->reset();
		fenster->release();
	}
	ram->release();
	if (ksgs)
		Framework::getDLLRegister()->releaseDLL("KSGScript.dll");
}

// nicht constant
void KESSVorschauKarteScript::thread()
{
	sichtbar = 0;
	while (alpha)
		Sleep(100);
	if (ak == 1)
	{
		pfad += "/seite/seite.ksgs";
		if (fenster)
			fenster->setScriptDatei(pfad);
	}
	fenster->neuLaden();
	sichtbar = 1;
	ak = 0;
	run = 0;
}

void KESSVorschauKarteScript::setScriptParams(bool hatTV, int tvVerb, bool vvEn, bool tvEn, int vvK, int tvK, int k)
{
	besitztTestVersion = hatTV;
	verbleibend = tvVerb;
	vollversionErwerbbar = vvEn;
	testversionErwerbbar = tvEn;
	vvPreis = vvK;
	tvPreis = tvK;
	kupfer = k;
	if (sichtbar)
	{
		ak = 2;
		start();
	}
}

void KESSVorschauKarteScript::ladeKarteSeite(const char* pfad)
{
	if (run)
		warteAufThread(5000);
	if (run)
		ende();
	this->pfad = pfad;
	ak = 1;
	start();
}

void KESSVorschauKarteScript::ksgsAktion(RCArray< KSGSVariable >* parameter, KSGSVariable** retVal)
{
	KSGSVariable* befehl = parameter->z(0);
	if (!befehl)
		return;
	Text* b = befehl->getText();
	if (!b)
		return;
	if (b->istGleich("GetBesitzStatus"))
	{
		int besitz = (int)besitztTestVersion;
		KSGSGetVariable getKSGSVariable = (KSGSGetVariable)GetProcAddress(ksgs, KSGS_VARIABLE_FUNKTION);
		if (getKSGSVariable)
		{
			KSGSVariableDef def = { KSGS_INT, 0, 3, (Text() += besitz).getText() };
			*retVal = getKSGSVariable(fenster, &def);
		}
		else
		{
			nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
				new Text("Der Einstiegspunkt '" KSGS_VARIABLE_FUNKTION "' in der DLL-Datei "
					"'data/bin/KSGScript.dll' konnte nicht gefunden werden."),
				new Text("Ok"), 0);
		}
		b->release();
		return;
	}
	if (b->istGleich("GetPreis"))
	{
		KSGSVariable* version = parameter->z(1);
		if (!version)
		{
			nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
				new Text("Auf dieser Seite befindet sich ein Fehler im KSG-Script. "
					"Sie könnte eventuell nicht richtig funktionieren."),
				new Text("Ok"), 0);
		}
		else
		{
			bool testVersion = !version->getInt();
			int k = testVersion ? tvPreis : vvPreis;
			KSGSGetVariable getKSGSVariable = (KSGSGetVariable)GetProcAddress(ksgs, KSGS_VARIABLE_FUNKTION);
			if (getKSGSVariable)
			{
				KSGSVariableDef def = { KSGS_INT, 0, 3, (Text() += k).getText() };
				*retVal = getKSGSVariable(fenster, &def);
			}
			else
			{
				nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
					new Text("Der Einstiegspunkt '" KSGS_VARIABLE_FUNKTION "' in der DLL-Datei "
						"'data/bin/KSGScript.dll' konnte nicht gefunden werden."),
					new Text("Ok"), 0);
			}
		}
		b->release();
		return;
	}
	if (b->istGleich("GetTestVersionVerbleibend"))
	{
		KSGSGetVariable getKSGSVariable = (KSGSGetVariable)GetProcAddress(ksgs, KSGS_VARIABLE_FUNKTION);
		if (getKSGSVariable)
		{
			KSGSVariableDef def = { KSGS_INT, 0, 3, (Text() += verbleibend).getText() };
			*retVal = getKSGSVariable(fenster, &def);
		}
		else
		{
			nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
				new Text("Der Einstiegspunkt '" KSGS_VARIABLE_FUNKTION "' in der DLL-Datei "
					"'data/bin/KSGScript.dll' konnte nicht gefunden werden."),
				new Text("Ok"), 0);
		}
		b->release();
		return;
	}
	if (b->istGleich("GetErwerbbarStatus"))
	{
		int erwerbbar = ((int)testversionErwerbbar & 0x1) | (((int)vollversionErwerbbar << 1) & 0x2);
		KSGSGetVariable getKSGSVariable = (KSGSGetVariable)GetProcAddress(ksgs, KSGS_VARIABLE_FUNKTION);
		if (getKSGSVariable)
		{
			KSGSVariableDef def = { KSGS_INT, 0, 3, (Text() += erwerbbar).getText() };
			*retVal = getKSGSVariable(fenster, &def);
		}
		else
		{
			nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
				new Text("Der Einstiegspunkt '" KSGS_VARIABLE_FUNKTION "' in der DLL-Datei "
					"'data/bin/KSGScript.dll' konnte nicht gefunden werden."),
				new Text("Ok"), 0);
		}
		b->release();
		return;
	}
	if (b->istGleich("GetKupfer"))
	{
		KSGSGetVariable getKSGSVariable = (KSGSGetVariable)GetProcAddress(ksgs, KSGS_VARIABLE_FUNKTION);
		if (getKSGSVariable)
		{
			KSGSVariableDef def = { KSGS_INT, 0, 3, (Text() += kupfer).getText() };
			*retVal = getKSGSVariable(fenster, &def);
		}
		else
		{
			nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
				new Text("Der Einstiegspunkt '" KSGS_VARIABLE_FUNKTION "' in der DLL-Datei "
					"'data/bin/KSGScript.dll' konnte nicht gefunden werden."),
				new Text("Ok"), 0);
		}
		b->release();
		return;
	}
	if (b->istGleich("Kaufen"))
	{
		KSGSVariable* version = parameter->z(1);
		if (!version)
		{
			nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
				new Text("Auf dieser Seite befindet sich ein Fehler im KSG-Script. "
					"Sie könnte eventuell nicht richtig funktionieren."),
				new Text("Ok"), 0);
		}
		b->release();
		return;
	}
	if (b->istGleich("GetBild"))
	{
		KSGSVariable* pfad = parameter->z(1);
		KSGSVariable* name = parameter->z(2);
		if (!pfad || !name)
		{
			nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
				new Text("Auf dieser Seite befindet sich ein Fehler im KSG-Script. "
					"Sie könnte eventuell nicht richtig funktionieren."),
				new Text("Ok"), 0);
		}
		else
		{
			Text* pf = pfad->getText();
			Text* n = name->getText();
			if (!pf || !n)
			{
				nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
					new Text("Auf dieser Seite befindet sich ein Fehler im KSG-Script. "
						"Sie könnte eventuell nicht richtig funktionieren."),
					new Text("Ok"), 0);
			}
			else
			{
				KSGSGetVariable getKSGSVariable = (KSGSGetVariable)GetProcAddress(ksgs, KSGS_VARIABLE_FUNKTION);
				if (getKSGSVariable)
				{
					int p = n->positionVon(".ltdb/");
					if (p < 0)
						p = 0;
					else
						p += 6;
					Text nn = Text(pf->getText()) + "/" + (const char*)(n->getText() + p);
					Bild* b = bilder->get(nn);
					if (b)
					{
						KSGSVariableDef def = { KSGS_BILD, 0, 3, "" };
						KSGSVariable* ret = getKSGSVariable(fenster, &def);
						KSGSSetBild setKSGSBild = (KSGSSetBild)GetProcAddress(ksgs, KSGS_SET_BILD_FUNKTION);
						if (!setKSGSBild)
						{
							nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
								new Text("Der Einstiegspunkt '" KSGS_SET_BILD_FUNKTION "' in der DLL-Datei "
									"'data/bin/KSGScript.dll' konnte nicht gefunden werden."),
								new Text("Ok"), 0);
							b->release();
						}
						else
							setKSGSBild(ret, b);
						*retVal = ret;
					}
				}
				else
				{
					nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
						new Text("Der Einstiegspunkt '" KSGS_VARIABLE_FUNKTION "' in der DLL-Datei "
							"'data/bin/KSGScript.dll' konnte nicht gefunden werden."),
						new Text("Ok"), 0);
				}
			}
			if (pf)
				pf->release();
			if (n)
				n->release();
		}
		b->release();
		return;
	}
}

void KESSVorschauKarteScript::doPublicMausEreignis(MausEreignis& me)
{
	me.mx -= pos.x;
	me.my -= pos.y;
	if (fenster)
		fenster->doPublicMausEreignis(me);
	me.mx += pos.x;
	me.my += pos.y;
}

void KESSVorschauKarteScript::doTastaturEreignis(TastaturEreignis& te)
{
	if (fenster)
		fenster->doTastaturEreignis(te);
}

bool KESSVorschauKarteScript::tick(double zeit)
{
	bool rend = fenster ? fenster->tick(zeit) : 0;
	if (!sichtbar && alpha > 0)
	{
		if (alpha - zeit * 150 < 0)
			alpha = 0;
		else
			alpha -= (unsigned char)(zeit * 150);
		rend = 1;
	}
	if (sichtbar && alpha < 255)
	{
		if (alpha + zeit * 150 > 255)
			alpha = 255;
		else
			alpha += (unsigned char)(zeit * 150);
		rend = 1;
	}
	return rend;
}

void KESSVorschauKarteScript::render(Bild& zRObj)
{
	if (!zRObj.setDrawOptions(pos.x, pos.y, ram->getBreite(), ram->getHeight()))
		return;
	zRObj.setAlpha(alpha);
	ram->render(zRObj);
	if (fenster)
		fenster->render(zRObj);
	zRObj.releaseAlpha();
	zRObj.releaseDrawOptions();
}


// Inhalt der KESSVorschauKarte Klasse aus KESSVorschau.h
// Konstruktor
KESSVorschauKarte::KESSVorschauKarte()
	: ReferenceCounter()
{
	auswählen = initKnopf(173, 73, 22, 22, 0, "");
	auswählen->setStyle(Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Rahmen | Knopf::Style::Hintergrund | Knopf::Style::HBild | Knopf::Style::KlickBuffer);
	auswählen->setHintergrundBildZ(bilder->get("data/client/bilder/shop.ltdb/weiter.png"));
	initToolTip(auswählen, "Karte auswählen.");
	auswählen->setRahmenBreite(1);
	hintergrund = 0;
	ausgewählt = new AlphaFeld();
	ausgewählt->setPosition(1, 1);
	ausgewählt->setSize(198, 98);
	ausgewählt->setFarbe(0x0000FF00);
	ausgewählt->setStrength(10);
	ram = new LRahmen();
	ram->setPosition(10, 10);
	ram->setSize(200, 100);
	ram->setFarbe(0xFFFFFFFF);
	ausw = 0;
	rend = 0;
}

// Destruktor
KESSVorschauKarte::~KESSVorschauKarte()
{
	auswählen->release();
	if (hintergrund)
		hintergrund->release();
	ausgewählt->release();
	ram->release();
}

// nicht constant
void KESSVorschauKarte::ladeKarte(char* pfad)
{
	LTDBDatei* datei = new LTDBDatei();
	Text* bdpf = new Text(pfad);
	bdpf->append("/titelbg.ltdb");
	datei->setDatei(bdpf);
	hintergrund = datei->laden(0, new Text("auswbg.jpg"));
	datei->release();
}

bool KESSVorschauKarte::doPublicMausEreignis(MausEreignis& me)
{
	bool vera = me.verarbeitet;
	auswählen->doPublicMausEreignis(me);
	if (!vera && me.verarbeitet && me.id == ME_RLinks)
	{
		ausw = 1;
		return 1;
	}
	return 0;
}

bool KESSVorschauKarte::tick(double zeit)
{
	rend |= ausgewählt->tick(zeit);
	rend |= auswählen->tick(zeit);
	int a = (ausgewählt->getFarbe() >> 24) & 0xFF;
	if (ausw && a < 255)
	{
		if (a + 150 * zeit > 255)
			a = 255;
		else
			a += (int)(zeit * 150);
		ausgewählt->setFarbe(((a << 24) & 0xFF000000) | (ausgewählt->getFarbe() & 0xFFFFFF));
		rend = 1;
	}
	if (!ausw && a > 0)
	{
		if (a - 150 * zeit < 0)
			a = 0;
		else
			a += (int)(zeit * 150);
		ausgewählt->setFarbe(((a << 24) & 0xFF000000) | (ausgewählt->getFarbe() & 0xFFFFFF));
		rend = 1;
	}
	bool ret = rend;
	rend = 0;
	return ret;
}

void KESSVorschauKarte::render(Bild& zRObj)
{
	ram->render(zRObj);
	if (!zRObj.setDrawOptions(ram->getX(), ram->getY(), 200, 100))
		return;
	if (hintergrund)
		zRObj.drawBild(1, 1, 198, 98, *hintergrund);
	ausgewählt->render(zRObj);
	auswählen->render(zRObj);
	zRObj.releaseDrawOptions();
}


// Inhalt der KESSVorschau Klasse aus KESSVorschau.h
// Konstruktor
KESSVorschau::KESSVorschau()
	: Zeichnung()
{
	tr = new TextRenderer(dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()));
	log = initTextFeld(10, 400, 860, 90, TextFeld::Style::TextGebiet & ~TextFeld::Style::Erlaubt, "Log:\n");
	script = new KESSVorschauKarteScript(log);
	karte = new KESSVorschauKarte();
	beenden = initKnopf(10, 500, 100, 20, Knopf::Style::Sichtbar, "Zurück");
	besitztTestVersion = initAuswahlBox(10, 120, 200, 20, ABSTYLE, { "Besitzt Testversion nicht", "Besitzt Testversion" });
	spieleVerbleibend = initTextFeld(110, 150, 100, 20, TextFeld::Style::TextFeld, "0");
	spieleVerbleibend->setTastaturEreignis(_nurNummernTE);
	vvErwerbbar = initAuswahlBox(10, 180, 200, 20, ABSTYLE, { "Vollversion erwerbbar", "Vollversion nicht erwerbbar" });
	tvErwerbbar = initAuswahlBox(10, 210, 200, 20, ABSTYLE, { "Testversion erwerbbar", "Testversion nicht erwerbbar" });
	vvPreis = initTextFeld(110, 240, 100, 20, TextFeld::Style::TextFeld, "0");
	vvPreis->setTastaturEreignis(_nurNummernTE);
	tvPreis = initTextFeld(110, 270, 100, 20, TextFeld::Style::TextFeld, "0");
	tvPreis->setTastaturEreignis(_nurNummernTE);
	kupfer = initTextFeld(110, 300, 100, 20, TextFeld::Style::TextFeld, "0");
	pfad = "";
	alpha = 0;
	sichtbar = 0;
	tickVal = 0;
	aktion = 0;
	rend = 0;
}

// Destruktor
KESSVorschau::~KESSVorschau()
{
	tr->release();
	script->release();
	karte->release();
	beenden->release();
	besitztTestVersion->release();
	spieleVerbleibend->release();
	vvErwerbbar->release();
	tvErwerbbar->release();
	vvPreis->release();
	tvPreis->release();
	kupfer->release();
	log->release();
}

// nicht constant
int KESSVorschau::getAktion()
{
	int ret = aktion;
	aktion = 0;
	return ret;
}

void KESSVorschau::ladeKarte(char* pfad)
{
	karte->ladeKarte(pfad);
	this->pfad = pfad;
}

void KESSVorschau::setSichtbar(bool sicht)
{
	sichtbar = sicht;
}

void KESSVorschau::doPublicMausEreignis(MausEreignis& me)
{
	if (!sichtbar)
		return;
	bool paramUpdate = 0;
	int ausw = vvErwerbbar->getAuswahl();
	vvErwerbbar->doPublicMausEreignis(me);
	if (ausw != vvErwerbbar->getAuswahl() && me.id == ME_RLinks)
	{
		vvErwerbbar->einklappen();
		paramUpdate = 1;
	}
	ausw = tvErwerbbar->getAuswahl();
	tvErwerbbar->doPublicMausEreignis(me);
	if (ausw != tvErwerbbar->getAuswahl() && me.id == ME_RLinks)
	{
		tvErwerbbar->einklappen();
		paramUpdate = 1;
	}
	ausw = besitztTestVersion->getAuswahl();
	besitztTestVersion->doPublicMausEreignis(me);
	if (ausw != besitztTestVersion->getAuswahl() && me.id == ME_RLinks)
	{
		besitztTestVersion->einklappen();
		paramUpdate = 1;
	}
	script->doPublicMausEreignis(me);
	if (karte->doPublicMausEreignis(me))
		script->ladeKarteSeite(pfad);
	bool vera = me.verarbeitet;
	beenden->doPublicMausEreignis(me);
	if (!vera && me.verarbeitet && me.id == ME_RLinks)
		aktion = 1;
	vvPreis->doPublicMausEreignis(me);
	tvPreis->doPublicMausEreignis(me);
	kupfer->doPublicMausEreignis(me);
	spieleVerbleibend->doPublicMausEreignis(me);
	log->doPublicMausEreignis(me);
	if (paramUpdate)
	{
		script->setScriptParams(besitztTestVersion->getAuswahl() == 1, (int)*spieleVerbleibend->zText(), vvErwerbbar->getAuswahl() == 0,
			tvErwerbbar->getAuswahl() == 0, (int)*vvPreis->zText(), (int)*tvPreis->zText(), (int)*kupfer->zText());
	}
}

void KESSVorschau::doTastaturEreignis(TastaturEreignis& te)
{
	if (!sichtbar)
		return;
	if (!te.verarbeitet && te.id == TE_Release && te.taste == T_Enter)
	{
		if (spieleVerbleibend->hatStyle(TextFeld::Style::Fokus) || vvPreis->hatStyle(TextFeld::Style::Fokus) || tvPreis->hatStyle(TextFeld::Style::Fokus) || kupfer->hatStyle(TextFeld::Style::Fokus))
		{
			script->setScriptParams(besitztTestVersion->getAuswahl() == 1, (int)*spieleVerbleibend->zText(), vvErwerbbar->getAuswahl() == 0,
				tvErwerbbar->getAuswahl() == 0, (int)*vvPreis->zText(), (int)*tvPreis->zText(), (int)*kupfer->zText());
		}
	}
	script->doTastaturEreignis(te);
	spieleVerbleibend->doTastaturEreignis(te);
	vvPreis->doTastaturEreignis(te);
	tvPreis->doTastaturEreignis(te);
	kupfer->doTastaturEreignis(te);
}

bool KESSVorschau::tick(double zeit)
{
	bool ret = script->tick(zeit);
	ret |= karte->tick(zeit);
	ret |= beenden->tick(zeit);
	ret |= spieleVerbleibend->tick(zeit);
	ret |= vvPreis->tick(zeit);
	ret |= tvPreis->tick(zeit);
	ret |= kupfer->tick(zeit);
	ret |= log->tick(zeit);
	ret |= tvErwerbbar->tick(zeit);
	ret |= vvErwerbbar->tick(zeit);
	ret |= besitztTestVersion->tick(zeit);
	tickVal += zeit * 150;
	int val = 0;
	if (tickVal > 1)
		val = (int)tickVal;
	else
		return ret;
	if (sichtbar && alpha != 255)
	{
		if (alpha + val > 255)
			alpha = 255;
		else
			alpha += val;
		ret = 1;
	}
	if (!sichtbar && alpha != 0)
	{
		if (alpha - val < 0)
			alpha = 0;
		else
			alpha -= val;
		ret = 1;
	}
	return ret;
}

void KESSVorschau::render(Bild& zRObj)
{
	zRObj.setAlpha(alpha);
	script->render(zRObj);
	karte->render(zRObj);
	beenden->render(zRObj);
	spieleVerbleibend->render(zRObj);
	log->render(zRObj);
	vvPreis->render(zRObj);
	tvPreis->render(zRObj);
	kupfer->render(zRObj);
	tr->setSchriftSize(12);
	Text txt = "Test Spiele:";
	tr->renderText(10, 154, txt, zRObj, 0xFFFFFFFF);
	txt = "Voll Preis:";
	tr->renderText(10, 244, txt, zRObj, 0xFFFFFFFF);
	txt = "Test Preis:";
	tr->renderText(10, 274, txt, zRObj, 0xFFFFFFFF);
	txt = "Kupfer Besitz:";
	tr->renderText(10, 304, txt, zRObj, 0xFFFFFFFF);
	txt = "Diese Werte sind nur zum\nTesten und haben keinerlei\nEinfluss auf den Shop.";
	tr->renderText(10, 334, txt, zRObj, 0xFFFFFFFF);
	tvErwerbbar->render(zRObj);
	vvErwerbbar->render(zRObj);
	besitztTestVersion->render(zRObj);
	zRObj.releaseAlpha();
}

// constant
bool KESSVorschau::istSichtbar() const
{
	return sichtbar;
}