#include "ShopClient.h"
#include <Klient.h>
#include "Keys.h"
#include <Datei.h>
#include <Globals.h>

using namespace KSGClient;

// Inhalt der ShopClient Klasse

// Konstruktor
ShopClient::ShopClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen)
	: ReferenceCounter()
{
	this->ip = ip;
	this->port = port;
	cId = klientId;
	k = 0;
	this->key = new char[keyLen];
	memcpy(this->key, key, keyLen);
	this->keyLen = keyLen;
}

// Destruktor
ShopClient::~ShopClient()
{
	trenne(1);
	delete[] key;
}

// verbindet sich mit dem zugewiesenen Shop Server
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ShopClient::verbinde()
{
	cs.lock();
	if (k)
	{
		cs.unlock();
		return 1;
	}
	k = new Network::Klient();
	int l = 0;
	char* key;
	Keys::getServerKey(&key, l, Keys::SHOP, Keys::SENDEN);
	k->setSendeKey(key, l);
	delete[] key;
	Keys::getServerKey(&key, l, Keys::SHOP, Keys::EMPFANGEN);
	k->setEmpfangKey(key, l);
	delete[] key;
	if (k->verbinde(port, ip))
	{
		if (k->sendeEncrypted("\1", 1))
		{
			k->sendeEncrypted((char*)&cId, 4);
			char serverReturn = 0;
			k->getNachrichtEncrypted(&serverReturn, 1);
			if (serverReturn == 3)
			{
				char byte = 0;
				k->getNachrichtEncrypted(&byte, 1);
				char* f = new char[byte + 1];
				f[byte] = 0;
				k->getNachrichtEncrypted(f, byte);
				err = "error while identifying client Shop Server returned: ";
				err += f;
				delete[]f;
				trenne(0);
				cs.unlock();
				return 0;
			}
			k->setSendeKey(this->key, this->keyLen);
			k->setEmpfangKey(this->key, this->keyLen);
		}
		else
		{
			err = "network error while sending to Shop Server";
			k = (Network::Klient*)k->release();
			cs.unlock();
			return 0;
		}
	}
	else
	{
		err = "network error while connecting to Shop Server";
		k = (Network::Klient*)k->release();
		cs.unlock();
		return 0;
	}
	cs.unlock();
	return 1;
}

// Gibt eine Liste mit Spiel Ids zurück, mit Spielen, die einen Bestimten Text im Namen haben
//  suche: Der Text, der im Namen der Spiele vorkommen soll
//  Gibt bei misserfolg 0 zurück
Framework::Array< int >* ShopClient::suchSpiele(const char* suche)
{
	char län = (char)textLength(suche);
	char ret = 0;
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\5", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted(&län, 1);
		if (län)
			k->sendeEncrypted(suche, län);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			int anz = 0;
			k->getNachrichtEncrypted((char*)&anz, 4);
			Array< int >* ret = new Array< int >();
			for (int i = 0; i < anz; i++)
			{
				int w = 0;
				k->getNachrichtEncrypted((char*)&w, 4);
				ret->add(w);
			}
			cs.unlock();
			return ret;
		}
	}
	if (ret == 3)
	{
		k->getNachrichtEncrypted(&län, 1);
		char* fehler = new char[län + 1];
		fehler[län] = 0;
		if (län)
			k->getNachrichtEncrypted(fehler, län);
		err = fehler;
		delete[] fehler;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// läd Titelbild des Spieles herunter und speichert es unter data/tmp/shop/kazfen/spiele/{id}/titelbg.ltdb
//  id: Die Id des Spiels
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ShopClient::ladeSpielTitel(int id)
{
	char ret = 0;
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\6", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&id, 4);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			Text* pf = new Text("data/tmp/shop/kaufen/spiele/");
			pf->append(id);
			pf->append("/titelbg.ltdb");
			Datei* dat = new Datei();
			dat->setDatei(pf);
			dat->erstellen();
			dat->open(Datei::Style::schreiben);
			__int64 gr = 0;
			k->getNachrichtEncrypted((char*)&gr, 8);
			char bytes[2048];
			while (gr > 0)
			{
				int län = gr > 2048 ? 2048 : (int)gr;
				k->getNachricht(bytes, län);
				dat->schreibe(bytes, län);
				gr -= län;
			}
			dat->close();
			dat->release();
		}
		if (ret == 2)
		{ // Verweis auf anderen ShopServer
			char län = 0;
			k->getNachrichtEncrypted((char*)&port, 4);
			k->getNachrichtEncrypted(&län, 1);
			char* ip = new char[län + 1];
			k->getNachrichtEncrypted(ip, län);
			ip[län] = 0;
			this->ip = ip;
			delete[] ip;
			k->trenne();
			k = (Network::Klient*)k->release();
			if (!verbinde())
			{
				err = "Fehler beim Verbinden mit zuständigen Shop Server.";
				cs.unlock();
				return 0;
			}
			cs.unlock();
			return ladeSpielTitel(id);
		}
	}
	if (ret == 3)
	{
		k->getNachrichtEncrypted(&ret, 1);
		char* fehler = new char[ret + 1];
		fehler[ret] = 0;
		if (ret)
			k->getNachrichtEncrypted(fehler, ret);
		err = fehler;
		delete[] fehler;
		cs.unlock();
		return 0;
	}
	cs.unlock();
	return 1;
}

// läd Shop Seite des Spieles herunter und speichert es unter data/tmp/shop/kazfen/spiele/{id}/seite.ksgs
//  id: Die Id des Spiels
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ShopClient::ladeSpielSeite(int id)
{
	char ret = 0;
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\7", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&id, 4);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			Text* pf = new Text("data/tmp/shop/kaufen/spiele/");
			pf->append(id);
			pf->append("/");
			int anz = 0;
			k->getNachrichtEncrypted((char*)&anz, 4);
			for (int i = 0; i < anz; i++)
			{
				char län = 0;
				k->getNachrichtEncrypted(&län, 1);
				char* name = new char[län + 1];
				name[län] = 0;
				k->getNachrichtEncrypted(name, län);
				Text* pfad = new Text(pf->getText());
				pfad->append(name);
				delete[] name;
				Datei* d = new Datei();
				d->setDatei(pfad);
				d->erstellen();
				d->open(Datei::Style::schreiben);
				__int64 gr = 0;
				k->getNachrichtEncrypted((char*)&gr, 8);
				char bytes[2048];
				while (gr > 0)
				{
					int län = gr > 2048 ? 2048 : (int)gr;
					k->getNachricht(bytes, län);
					d->schreibe(bytes, län);
					gr -= län;
				}
				d->close();
				d->release();
			}
			pf->release();
		}
		if (ret == 2)
		{ // Verweis auf anderen ShopServer
			char län = 0;
			k->getNachrichtEncrypted((char*)&port, 4);
			k->getNachrichtEncrypted(&län, 1);
			char* ip = new char[län + 1];
			k->getNachrichtEncrypted(ip, län);
			ip[län] = 0;
			this->ip = ip;
			delete[] ip;
			k->trenne();
			k = (Network::Klient*)k->release();
			if (!verbinde())
			{
				err = "Fehler beim Verbinden mit zuständigen Shop Server.";
				cs.unlock();
				return 0;
			}
			cs.unlock();
			return ladeSpielSeite(id);
		}
	}
	if (ret == 3)
	{
		k->getNachrichtEncrypted(&ret, 1);
		char* fehler = new char[ret + 1];
		fehler[ret] = 0;
		if (ret)
			k->getNachrichtEncrypted(fehler, ret);
		err = fehler;
		delete[] fehler;
		cs.unlock();
		return 0;
	}
	cs.unlock();
	return 1;
}

// Gibt den Besitz Status eines Spiels zurück (0 = nicht im Besitz, 1 = Testversion, 2 = gekauft)
//  id: Die Id des Spiels
int ShopClient::getSpielBesitzStatus(int id)
{
	char ret = 0;
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x8", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&id, 4);
		int ret = 0;
		k->getNachrichtEncrypted((char*)&ret, 4);
		cs.unlock();
		return ret;
	}
	if (ret == 3)
	{
		k->getNachrichtEncrypted(&ret, 1);
		char* fehler = new char[ret + 1];
		fehler[ret] = 0;
		if (ret)
			k->getNachrichtEncrypted(fehler, ret);
		err = fehler;
		delete[] fehler;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// gibt die Anzahl der verbleibenden Spiele der Testversion zurück
//  id: Die Id des Spiels
int ShopClient::getSpielTestversion(int id)
{
	char ret = 0;
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x9", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&id, 4);
		int ret = 0;
		k->getNachrichtEncrypted((char*)&ret, 4);
		cs.unlock();
		return ret;
	}
	if (ret == 3)
	{
		k->getNachrichtEncrypted(&ret, 1);
		char* fehler = new char[ret + 1];
		fehler[ret] = 0;
		if (ret)
			k->getNachrichtEncrypted(fehler, ret);
		err = fehler;
		delete[] fehler;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Gibt den Erwerbbarkeits Status eines Spiels zurück (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
//  id: Die Id des Spiels
int ShopClient::istSpielErwerbbar(int id)
{
	char ret = 0;
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\xA", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&id, 4);
		int ret = 0;
		k->getNachrichtEncrypted((char*)&ret, 4);
		cs.unlock();
		return ret;
	}
	if (ret == 3)
	{
		k->getNachrichtEncrypted(&ret, 1);
		char* fehler = new char[ret + 1];
		fehler[ret] = 0;
		if (ret)
			k->getNachrichtEncrypted(fehler, ret);
		err = fehler;
		delete[] fehler;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Gibt den Preis eines Spiels in Kupfer zurück
//  id: Die Id des Spiels
//  testVersion: 1:=Es wird der Preis der Testversion zurückgegeben, 0:=Es wird der Preis der Vollversion zurückgegeben
int ShopClient::getSpielPreis(int id, bool testVersion)
{
	char ret = 0;
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\xB", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&id, 4);
		k->sendeEncrypted((char*)&testVersion, 1);
		int ret = 0;
		k->getNachrichtEncrypted((char*)&ret, 4);
		cs.unlock();
		return ret;
	}
	if (ret == 3)
	{
		k->getNachrichtEncrypted(&ret, 1);
		char* fehler = new char[ret + 1];
		fehler[ret] = 0;
		if (ret)
			k->getNachrichtEncrypted(fehler, ret);
		err = fehler;
		delete[] fehler;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Kauft ein Spiel
//  id: Die Id des Spiels
//  testVersion: 1:=Es wird die Testversion erworben, 0:=Es wird die Vollversion erworben
bool ShopClient::spielErwerben(int spielId, bool testVersion)
{
	char ret = 0;
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\xC", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&spielId, 4);
		k->sendeEncrypted((char*)&testVersion, 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			cs.unlock();
			return 1;
		}
	}
	if (ret == 3)
	{
		k->getNachrichtEncrypted(&ret, 1);
		char* fehler = new char[ret + 1];
		fehler[ret] = 0;
		if (ret)
			k->getNachrichtEncrypted(fehler, ret);
		err = fehler;
		delete[] fehler;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// sucht nach Karten mit zu einem bestimmten Spiel
//  suche: Ein Text, der im Namen der Karte vorkommen soll
//  spielId: Die Id des Spiels
//  Gibt eine Liste Mit den Ids der gefundenen Karten zurück
Framework::Array< int >* ShopClient::suchKarten(const char* suche, int spielId)
{
	char län = (char)textLength(suche);
	char ret = 0;
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\xD", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&spielId, 4);
		k->sendeEncrypted(&län, 1);
		if (län)
			k->sendeEncrypted(suche, län);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			int anz = 0;
			k->getNachrichtEncrypted((char*)&anz, 4);
			Array< int >* ret = new Array< int >();
			for (int i = 0; i < anz; i++)
			{
				int w = 0;
				k->getNachrichtEncrypted((char*)&w, 4);
				ret->add(w);
			}
			cs.unlock();
			return ret;
		}
	}
	if (ret == 3)
	{
		k->getNachrichtEncrypted(&län, 1);
		char* fehler = new char[län + 1];
		fehler[län] = 0;
		if (län)
			k->getNachrichtEncrypted(fehler, län);
		err = fehler;
		delete[] fehler;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// lädt das Titelbild der Karte herunter und speichert es unter data/tmp/shop/kaufen/karten/{id}/titelbg.ltdb
//  id: Die Id der Karte
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ShopClient::ladeKarteTitel(int id)
{
	char ret = 0;
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\xE", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&id, 4);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			Text* pf = new Text("data/tmp/shop/kaufen/karten/");
			pf->append(id);
			pf->append("/titelbg.ltdb");
			Datei* dat = new Datei();
			dat->setDatei(pf);
			dat->erstellen();
			dat->open(Datei::Style::schreiben);
			__int64 gr = 0;
			k->getNachrichtEncrypted((char*)&gr, 8);
			char bytes[2048];
			while (gr > 0)
			{
				int län = gr > 2048 ? 2048 : (int)gr;
				k->getNachricht(bytes, län);
				dat->schreibe(bytes, län);
				gr -= län;
			}
			dat->close();
			dat->release();
		}
		if (ret == 2)
		{ // Verweis auf anderen ShopServer
			char län = 0;
			k->getNachrichtEncrypted((char*)&port, 4);
			k->getNachrichtEncrypted(&län, 1);
			char* ip = new char[län + 1];
			k->getNachrichtEncrypted(ip, län);
			ip[län] = 0;
			this->ip = ip;
			delete[] ip;
			k->trenne();
			k = (Network::Klient*)k->release();
			if (!verbinde())
			{
				err = "Fehler beim Verbinden mit zuständigen Shop Server.";
				cs.unlock();
				return 0;
			}
			cs.unlock();
			return ladeKarteTitel(id);
		}
	}
	if (ret == 3)
	{
		k->getNachrichtEncrypted(&ret, 1);
		char* fehler = new char[ret + 1];
		fehler[ret] = 0;
		if (ret)
			k->getNachrichtEncrypted(fehler, ret);
		err = fehler;
		delete[] fehler;
		cs.unlock();
		return 0;
	}
	cs.unlock();
	return 1;
}

// lädt die Shop Seite der Karte herunter und speichert es unter data/tmp/shop/kaufen/karten/{id}/seite.ksgs
//  id: Die Id der Karte
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ShopClient::ladeKarteSeite(int id)
{
	char ret = 0;
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\xF", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&id, 4);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			Text* pf = new Text("data/tmp/shop/kaufen/karten/");
			pf->append(id);
			pf->append("/");
			int anz = 0;
			k->getNachrichtEncrypted((char*)&anz, 4);
			for (int i = 0; i < anz; i++)
			{
				char län = 0;
				k->getNachrichtEncrypted(&län, 1);
				char* name = new char[län + 1];
				name[län] = 0;
				k->getNachrichtEncrypted(name, län);
				Text* pfad = new Text(pf->getText());
				pfad->append(name);
				delete[] name;
				Datei* d = new Datei();
				d->setDatei(pfad);
				d->erstellen();
				d->open(Datei::Style::schreiben);
				__int64 gr = 0;
				k->getNachrichtEncrypted((char*)&gr, 8);
				char bytes[2048];
				while (gr > 0)
				{
					int län = gr > 2048 ? 2048 : (int)gr;
					k->getNachricht(bytes, län);
					d->schreibe(bytes, län);
					gr -= län;
				}
				d->close();
				d->release();
			}
			pf->release();
		}
		if (ret == 2)
		{ // Verweis auf anderen ShopServer
			char län = 0;
			k->getNachrichtEncrypted((char*)&port, 4);
			k->getNachrichtEncrypted(&län, 1);
			char* ip = new char[län + 1];
			k->getNachrichtEncrypted(ip, län);
			ip[län] = 0;
			this->ip = ip;
			delete[] ip;
			k->trenne();
			k = (Network::Klient*)k->release();
			if (!verbinde())
			{
				err = "Fehler beim Verbinden mit zuständigen Shop Server.";
				cs.unlock();
				return 0;
			}
			cs.unlock();
			return ladeKarteSeite(id);
		}
	}
	if (ret == 3)
	{
		k->getNachrichtEncrypted(&ret, 1);
		char* fehler = new char[ret + 1];
		fehler[ret] = 0;
		if (ret)
			k->getNachrichtEncrypted(fehler, ret);
		err = fehler;
		delete[] fehler;
		cs.unlock();
		return 0;
	}
	cs.unlock();
	return 1;
}

// Gibt den Besitz Status einer Karte zurück (0 = nicht im Besitz, 1 = Testversion, 2 = gekauft)
//  id: Die Id der Karte
int ShopClient::getKarteBesitzStatus(int id)
{
	char ret = 0;
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x10", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&id, 4);
		int ret = 0;
		k->getNachrichtEncrypted((char*)&ret, 4);
		cs.unlock();
		return ret;
	}
	if (ret == 3)
	{
		k->getNachrichtEncrypted(&ret, 1);
		char* fehler = new char[ret + 1];
		fehler[ret] = 0;
		if (ret)
			k->getNachrichtEncrypted(fehler, ret);
		err = fehler;
		delete[] fehler;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// gibt die Anzahl der verbleibenden Spiele der Testversion zurück
//  id: Die Id der Karte
int ShopClient::getKarteTestversion(int id)
{
	char ret = 0;
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x11", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&id, 4);
		int ret = 0;
		k->getNachrichtEncrypted((char*)&ret, 4);
		cs.unlock();
		return ret;
	}
	if (ret == 3)
	{
		k->getNachrichtEncrypted(&ret, 1);
		char* fehler = new char[ret + 1];
		fehler[ret] = 0;
		if (ret)
			k->getNachrichtEncrypted(fehler, ret);
		err = fehler;
		delete[] fehler;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Gibt den Erwerbbarkeits Status einer Karte zurück (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
//  id: Die Id der Karte
int ShopClient::istKarteErwerbbar(int id)
{
	char ret = 0;
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x12", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&id, 4);
		int ret = 0;
		k->getNachrichtEncrypted((char*)&ret, 4);
		cs.unlock();
		return ret;
	}
	if (ret == 3)
	{
		k->getNachrichtEncrypted(&ret, 1);
		char* fehler = new char[ret + 1];
		fehler[ret] = 0;
		if (ret)
			k->getNachrichtEncrypted(fehler, ret);
		err = fehler;
		delete[] fehler;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Gibt den Preis einer Karte in Kupfer zurück
//  id: Die Id der Karte
//  testVersion: 1:=Es wird der Preis der Testversion zurückgegeben, 0:=Es wird der Preis der Vollversion zurückgegeben
int ShopClient::getKartePreis(int id, bool testVersion)
{
	char ret = 0;
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x13", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&id, 4);
		k->sendeEncrypted((char*)&testVersion, 1);
		int ret = 0;
		k->getNachrichtEncrypted((char*)&ret, 4);
		cs.unlock();
		return ret;
	}
	if (ret == 3)
	{
		k->getNachrichtEncrypted(&ret, 1);
		char* fehler = new char[ret + 1];
		fehler[ret] = 0;
		if (ret)
			k->getNachrichtEncrypted(fehler, ret);
		err = fehler;
		delete[] fehler;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Kauft eine Karte
//  id: Die Id der Karte
//  testVersion: 1:=Es wird die Testversion erworben, 0:=Es wird die Vollversion erworben
bool ShopClient::karteErwerben(int karteId, bool testVersion)
{
	char ret = 0;
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x14", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&karteId, 4);
		k->sendeEncrypted((char*)&testVersion, 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			cs.unlock();
			return 1;
		}
	}
	if (ret == 3)
	{
		k->getNachrichtEncrypted(&ret, 1);
		char* fehler = new char[ret + 1];
		fehler[ret] = 0;
		if (ret)
			k->getNachrichtEncrypted(fehler, ret);
		err = fehler;
		delete[] fehler;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Erhält die Verbindung aufrecht
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
bool ShopClient::keepAlive()
{
	if (!k)
		return 0;
	char res = 0;
	if (!cs.tryLock())
		return 1;
	Framework::logLine((char*)"Verbindungstest zum Shop Server...");
	bool ok = k->sendeEncrypted("\x15", 1);
	ok &= k->getNachrichtEncrypted(&res, 1);
	cs.unlock();
	if (res != 1 || !ok)
	{
		Framework::logLine((char*)"Verbindungsabbruch.");
		trenne(0);
	}
	else
		Framework::logLine((char*)"Verbindung besteht.");
	return res == 1;
}

// Trennt die Verbindung zum Server
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
bool ShopClient::trenne(bool abmelden)
{
	cs.lock();
	verbinde();
	if (!k)
	{
		cs.unlock();
		return 1;
	}
	if (abmelden)
	{
		k->sendeEncrypted("\4", 1);
		char ret = 0;
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 3)
		{ // error
			k->getNachrichtEncrypted(&ret, 1);
			char* msg = new char[ret + 1];
			msg[ret] = 0;
			if (ret)
				k->getNachrichtEncrypted(msg, ret);
			err = "error while unregister Client Login Server returned: ";
			err += msg;
			delete[] msg;
		}
	}
	k->sendeEncrypted("\3", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 3)
	{ // error
		k->getNachrichtEncrypted(&ret, 1);
		char* msg = new char[ret + 1];
		msg[ret] = 0;
		if (ret)
			k->getNachrichtEncrypted(msg, ret);
		err = "error while trenne Login Server returned: ";
		err += msg;
		delete[] msg;
	}
	k->trenne();
	k = (Network::Klient*)k->release();
	cs.unlock();
	return 1;
}

// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
bool ShopClient::istVerbunden() const
{
	return k != 0;
}

// gibt den Letzten Fehlertext zuück
//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
const char* ShopClient::getLetzterFehler() const
{
	return err;
}