#include "Neuigkeiten.h"
#include "../../Global/Variablen.h"
#include "../../Global/Initialisierung.h"
#include <Punkt.h>
#include <Globals.h>
#include <InitDatei.h>

// Inhalt der NewsThread Klasse aus Neuigkeiten.h
// Konstruktor
NewsThread::NewsThread(const char* name, KSGScriptObj* obj, Neuigkeiten* n)
{
	scriptName = new Text(name);
	this->obj = obj;
	news = n;
	start();
}

// Destruktor
NewsThread::~NewsThread()
{
	scriptName->release();
	obj->release();
	news->release();
}

// nicht constant
void NewsThread::thread()
{
	if (!newsClient)
		newsClient = mainClient->createNewsServerClient();
	if (!newsClient)
	{
		news->endLaden(mainClient->getLetzterFehler());
		delete this;
		return;
	}
	if (!newsClient->verbinde())
	{
		news->endLaden(newsClient->getLetzterFehler());
		run = 0;
		delete this;
		return;
	}
	if (!newsClient->ladeSeite(scriptName->getText()))
	{
		news->endLaden(newsClient->getLetzterFehler());
		run = 0;
		delete this;
		return;
	}
	newsClient->trenne(0);
	Text* pfad = new Text("data/tmp/news/");
	pfad->append(scriptName->getText());
	pfad->append("/seite.ksgs");
	obj->setScriptDatei(pfad);
	if (!obj->neuLaden())
	{
		news->endLaden("Fehler beim laden der Seite.");
		run = 0;
		delete this;
		return;
	}
	news->endLaden(0);
	run = 0;
	delete this;
}


void KSGSRückruf(void* p, RCArray< KSGSVariable >* parameter, KSGSVariable** ret)
{
	if (!p)
		return;
	((Neuigkeiten*)p)->rückruf(parameter, ret);
}

// Inhalt der Neuigkeiten Klasse aus Neuigkeiten.h
// Konstruktor
Neuigkeiten::Neuigkeiten(Fenster* zNachLoginFenster, int x)
	: Zeichnung()
{
	bildschirmGröße = uiFactory.initParam.bildschirm->getBackBufferSize();
	pos = Punkt(x, 67);
	gr = Punkt(102, 32);
	rahmen = new LRahmen();
	rahmen->setFarbe(0xFFFFFFFF);
	rahmen->setSize(102, 32);
	alpha = 0;
	animation = 0;
	wirdGeladen = 0;
	sichtbar = 0;
	tickVal = 0;
	prozent1 = 0;
	prozent2 = 0;
	begPos = Punkt(0, 0);
	begGröße = Punkt(0, 0);
	größe1 = Punkt(102, 32);
	pos1 = Punkt(x, 67);
	größe2 = Punkt(800, 500);
	pos2 = bildschirmGröße / 2 - größe2 / 2;
	fehler = initTextFeld(5, 5, 790, 490, TextFeld::Style::Text & ~TextFeld::Style::Sichtbar, "");
	laden = (Animation2D*)ladeAnimation->dublizieren();
	laden->setSichtbar(0);
	laden->setPosition(375, 225);
	getThis();
	zNachLoginFenster->addMember(this);
	ksgsDLL = Framework::getDLLRegister()->ladeDLL("KSGScript.dll", "data/bin/KSGScript.dll");
	if (!ksgsDLL)
	{
		fehler->setText("Die DLL Datei 'data/bin/KSGScript.dll' konnte nicht geladen werden.");
		fehler->addStyle(TextFeld::Style::Sichtbar);
		script = 0;
	}
	else
	{
		KSGSGetZeichnung getKSGSZeichnung = (KSGSGetZeichnung)GetProcAddress(ksgsDLL, KSGS_START_FUNKTION);
		if (!getKSGSZeichnung)
		{
			fehler->setText("Die Funktion '" KSGS_START_FUNKTION "' konnte in der DLL Datei 'data/bin/KSGScript.dll'\nnicht gefunden werden.");
			fehler->addStyle(TextFeld::Style::Sichtbar);
			script = 0;
		}
		else
		{
			script = getKSGSZeichnung();
			script->setSize(800, 500);
			script->setBildschirmZ(dynamic_cast<Bildschirm*>(uiFactory.initParam.bildschirm->getThis()));
			script->setSchriftZ(dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()));
			script->setCallbackParam(this);
			script->setCallbackFunktion(KSGSRückruf);
			wirdGeladen = 1;
			laden->setSichtbar(1);
			getThis();
			new NewsThread("Client/Start", dynamic_cast<KSGScriptObj*>(script->getThis()), this);
		}
	}
}

// Destruktor
Neuigkeiten::~Neuigkeiten()
{
	rahmen->release();
	if (script)
	{
		script->reset();
		script->release();
	}
	if (ksgsDLL)
		Framework::getDLLRegister()->releaseDLL("KSGScript.dll");
	fehler->release();
	laden->release();
}

// nicht constant
void Neuigkeiten::setSichtbar(bool sicht)
{
	begPos = pos;
	begGröße = gr;
	animation |= (sicht ? 0x1 : 0x2);
	rend = 1;
}

void Neuigkeiten::endLaden(const char* err)
{
	laden->setSichtbar(0);
	wirdGeladen = 0;
	if (err)
	{
		fehler->setText(err);
		fehler->addStyle(TextFeld::Style::Sichtbar);
	}
	else
	{
		fehler->setText("");
		fehler->removeStyle(TextFeld::Style::Sichtbar);
	}
}

void Neuigkeiten::rückruf(RCArray< KSGSVariable >* parameter, KSGSVariable** ret)
{
	if (wirdGeladen)
		return;
	KSGSVariable* befehl = parameter->z(0);
	if (!befehl)
		return;
	Text* b = befehl->getText();
	if (!b || !b->getLength())
	{
		if (b)
			b->release();
		return;
	}
	wirdGeladen = 1;
	laden->setSichtbar(1);
	new NewsThread(b->getText(), dynamic_cast<KSGScriptObj*>(script->getThis()), dynamic_cast<Neuigkeiten*>(getThis()));
	b->release();
}

void Neuigkeiten::doPublicMausEreignis(MausEreignis& me)
{
	if (wirdGeladen)
		return;
	me.mx -= pos.x;
	me.my -= pos.y;
	if (script && sichtbar)
		script->doPublicMausEreignis(me);
	me.mx += pos.x;
	me.my += pos.y;
}

void Neuigkeiten::doTastaturEreignis(TastaturEreignis& te)
{
	if (wirdGeladen)
		return;
	if (script && sichtbar)
		script->doTastaturEreignis(te);
}

bool Neuigkeiten::tick(double z)
{
	rend |= laden->tick(z);
	rend |= fehler->tick(z);
	if (wirdGeladen)
	{
		bool ret = rend;
		rend = 0;
		return ret;
	}
	if (script && sichtbar)
		rend |= script->tick(z);
	tickVal += z * 150;
	int val = (int)tickVal;
	if (val < 1)
	{
		bool ret = rend;
		rend = 0;
		return ret;
	}
	tickVal -= val;
	if ((animation | 0x1) == animation) // Einblenden
	{
		if (prozent1 != 100)
		{
			prozent1 += val;
			if (prozent1 >= 100)
				prozent1 = 100;
			pos = begPos + (Punkt)(((Vec2< double >)(pos2 - begPos) / 100.0) * prozent1);
			gr = begGröße + (Punkt)(((Vec2< double >)(größe2 - begGröße) / 100.0) * prozent1);
		}
		else if (alpha != 255)
		{
			alpha += val * 2;
			if (alpha >= 255 || (animation | 0x2) == animation)
			{
				alpha = 255;
				animation &= ~0x1;
				sichtbar = 1;
				prozent1 = 0;
			}
		}
		rend = 1;
	}
	if ((animation | 0x2) == animation) // ausblenden
	{
		if (alpha != 0)
		{
			alpha -= val * 2;
			if (alpha < 0)
				alpha = 0;
		}
		else
		{
			prozent2 += val;
			if (prozent2 > 100)
				prozent2 = 100;
			pos = begPos + (Punkt)(((Vec2< double >)(pos1 - begPos) / 100.0) * prozent2);
			gr = begGröße + (Punkt)(((Vec2< double >)(größe1 - begGröße) / 100.0) * prozent2);
			if (prozent2 == 100)
			{
				prozent2 = 0;
				animation &= ~0x2;
				sichtbar = 0;
			}
		}
		rend = 1;
	}
	bool ret = rend;
	rend = 0;
	return ret;
}

void Neuigkeiten::render(Bild& zRObj)
{
	if (pos == pos1)
		return;
	if (!zRObj.setDrawOptions(pos.x, pos.y, gr.x, gr.y))
		return;
	rahmen->setSize(gr);
	rahmen->render(zRObj);
	int rbr = rahmen->getRBreite();
	zRObj.setAlpha((unsigned char)alpha);
	fehler->render(zRObj);
	if (script)
		script->render(zRObj);
	laden->render(zRObj);
	zRObj.releaseAlpha();
	zRObj.releaseDrawOptions();
}

// constant
bool Neuigkeiten::istAnimiert() const
{
	return animation != 0;
}

bool Neuigkeiten::istSichtbar() const
{
	return sichtbar || prozent1 != 0;
}