#include "AnmeldungClient.h"
#include <Klient.h>
#include "Keys.h"
#include <Globals.h>

using namespace KSGClient;

// Inhalt der Anmeldung Klasse

// Konstruktor
AnmeldungClient::AnmeldungClient(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
AnmeldungClient::~AnmeldungClient()
{
	trenne(1);
	delete[] key;
}

// verbindet sich mit dem zugewiesenen Anmeldung Server
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool AnmeldungClient::verbinde()
{
	cs.lock();
	if (k)
	{
		cs.unlock();
		return 1;
	}
	k = new Network::Klient();
	int l = 0;
	char* key;
	Keys::getServerKey(&key, l, Keys::ANMELDUNG, Keys::SENDEN);
	k->setSendeKey(key, l);
	delete[] key;
	Keys::getServerKey(&key, l, Keys::ANMELDUNG, 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 Anmeldung 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 Anmeldung Server";
			k = (Network::Klient*)k->release();
			cs.unlock();
			return 0;
		}
	}
	else
	{
		err = "network error while connecting to Anmeldung Server";
		k = (Network::Klient*)k->release();
		cs.unlock();
		return 0;
	}
	cs.unlock();
	return 1;
}

// erstellt eine gruppe
//  karteId: Die Id der Karte für die die Gruppe erstellt werden soll
//  Gibt bei Erfolg die Id der Gruppe zurück. Bei misserfolg wird 0 zurückgegeben
int AnmeldungClient::gruppeErstellen(int karteId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\5", 1);
	char serverReturn = 0;
	k->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn == 1)
	{
		k->sendeEncrypted((char*)&karteId, 4);
		k->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			int gruppeId = 0;
			k->getNachrichtEncrypted((char*)&gruppeId, 4);
			cs.unlock();
			return gruppeId;
		}
	}
	if (serverReturn == 3)
	{
		char län = 0;
		k->getNachrichtEncrypted(&län, 1);
		char* message = new char[län + 1];
		message[län] = 0;
		k->getNachrichtEncrypted(message, län);
		err = message;
		delete[] message;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Betritt eine Gruppe
//  gruppeId: Die Id der Gruppe
//  mitglieder: Nach erfolgreichem Aufruf enthält diese Liste die Lister der Account Ids der Gruppenmitglieder
//  anzahl: Nach erfolgreichem Aufruf wird hier die Anzahl der Gruppenmitglieder gespeichert
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool AnmeldungClient::gruppeBetreten(int gruppeId, Framework::Array< int >* mitglieder, int* anzahl)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x6", 1);
	char serverReturn = 0;
	k->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn == 1)
	{
		k->sendeEncrypted((char*)&gruppeId, 4);
		k->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			k->getNachrichtEncrypted((char*)anzahl, 4);
			for (int i = 0; i < *anzahl; i++)
			{
				int id = 0;
				k->getNachrichtEncrypted((char*)&id, 4);
				mitglieder->add(id, i);
			}
			cs.unlock();
			return 1;
		}
	}
	if (serverReturn == 3)
	{
		char län = 0;
		k->getNachrichtEncrypted(&län, 1);
		char* message = new char[län + 1];
		message[län] = 0;
		k->getNachrichtEncrypted(message, län);
		err = message;
		delete[] message;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Verlässt eine Gruppe
//  gruppeId: Die Id der Gruppe
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool AnmeldungClient::gruppeVerlassen(int gruppeId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char serverReturn = 0;
	k->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn == 1)
	{
		k->sendeEncrypted((char*)&gruppeId, 4);
		k->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			cs.unlock();
			return 1;
		}
	}
	if (serverReturn == 3)
	{
		char län = 0;
		k->getNachrichtEncrypted(&län, 1);
		char* message = new char[län + 1];
		message[län] = 0;
		k->getNachrichtEncrypted(message, län);
		err = message;
		delete[] message;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Trägt die Gruppe in die Warteschlange für die Karte ein (nur für den Gruppen Administrator)
//  gruppeId: Die Id der Gruppe
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool AnmeldungClient::gruppeAnmelden(int gruppeId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x9", 1);
	char serverReturn = 0;
	k->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn == 1)
	{
		k->sendeEncrypted((char*)&gruppeId, 4);
		k->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			cs.unlock();
			return 1;
		}
	}
	if (serverReturn == 3)
	{
		char län = 0;
		k->getNachrichtEncrypted(&län, 1);
		char* message = new char[län + 1];
		message[län] = 0;
		k->getNachrichtEncrypted(message, län);
		err = message;
		delete[] message;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Trägt die Gruppe aus der Warteschlange für die Karte aus (nur für den Gruppen Administrator)
//  gruppeId: Die Id der Gruppe
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool AnmeldungClient::gruppeAbmelden(int gruppeId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\xA", 1);
	char serverReturn = 0;
	k->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn == 1)
	{
		k->sendeEncrypted((char*)&gruppeId, 4);
		k->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			cs.unlock();
			return 1;
		}
	}
	if (serverReturn == 3)
	{
		char län = 0;
		k->getNachrichtEncrypted(&län, 1);
		char* message = new char[län + 1];
		message[län] = 0;
		k->getNachrichtEncrypted(message, län);
		err = message;
		delete[] message;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// läht Spieler ein die Gruppe zu betreten (nur für den Gruppen Administrator)
//  accountId: Die Id des Accounts
//  gruppeId: Die Id der Gruppe
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool AnmeldungClient::gruppeSpielerEinladen(int accountId, int gruppeId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\xB", 1);
	char serverReturn = 0;
	k->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn == 1)
	{
		k->sendeEncrypted((char*)&accountId, 4);
		k->sendeEncrypted((char*)&gruppeId, 4);
		k->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			cs.unlock();
			return 1;
		}
	}
	if (serverReturn == 3)
	{
		char län = 0;
		k->getNachrichtEncrypted(&län, 1);
		char* message = new char[län + 1];
		message[län] = 0;
		k->getNachrichtEncrypted(message, län);
		err = message;
		delete[] message;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Zieht die Einladung eine Gruppe zu betreten zurück (nur für den Gruppen Administrator)
//  accountId: Die Id des Accounts
//  gruppeId: Die Id der Gruppe
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool AnmeldungClient::gruppeEinladungAbbrechen(int accountId, int gruppeId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x11", 1);
	char serverReturn = 0;
	k->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn == 1)
	{
		k->sendeEncrypted((char*)&gruppeId, 4);
		k->sendeEncrypted((char*)&accountId, 4);
		k->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			cs.unlock();
			return 1;
		}
	}
	if (serverReturn == 3)
	{
		char län = 0;
		k->getNachrichtEncrypted(&län, 1);
		char* message = new char[län + 1];
		message[län] = 0;
		k->getNachrichtEncrypted(message, län);
		err = message;
		delete[] message;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Einladung zur Gruppe ablehnen
//  gruppeId: Die Id der Gruppe
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool AnmeldungClient::gruppeEinladungAblehnen(int gruppeId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x12", 1);
	char serverReturn = 0;
	k->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn == 1)
	{
		k->sendeEncrypted((char*)&gruppeId, 4);
		k->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			cs.unlock();
			return 1;
		}
	}
	if (serverReturn == 3)
	{
		char län = 0;
		k->getNachrichtEncrypted(&län, 1);
		char* message = new char[län + 1];
		message[län] = 0;
		k->getNachrichtEncrypted(message, län);
		err = message;
		delete[] message;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// wirft Spieler aus Gruppe (nur für den Gruppen Administrator)
//  accountId: Die Id des Accounts
//  gruppeId: Die Id der Gruppe
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool AnmeldungClient::kickSpielerAusGruppe(int accountId, int gruppeId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\xC", 1);
	char serverReturn = 0;
	k->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn == 1)
	{
		k->sendeEncrypted((char*)&accountId, 4);
		k->sendeEncrypted((char*)&gruppeId, 4);
		k->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			cs.unlock();
			return 1;
		}
	}
	if (serverReturn == 3)
	{
		char län = 0;
		k->getNachrichtEncrypted(&län, 1);
		char* message = new char[län + 1];
		message[län] = 0;
		k->getNachrichtEncrypted(message, län);
		err = message;
		delete[] message;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Legt fest, ob die Spieler in der Gruppe alleine spielen wollen, oder ob weitere Spieler aus der Warteschlange hinzugefügt werden sollen bis die Karte voll ist
//  gruppeId: Die Id der Gruppe
//  spielStarte: 1:=alleine spielen, 0:=auf volles Spiel warten
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool AnmeldungClient::gruppeSpielStarten(int gruppeId, bool spielStarten)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x10", 1);
	char serverReturn = 0;
	k->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn == 1)
	{
		k->sendeEncrypted((char*)&gruppeId, 4);
		k->sendeEncrypted((char*)&spielStarten, 1);
		k->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			cs.unlock();
			return 1;
		}
	}
	if (serverReturn == 3)
	{
		char län = 0;
		k->getNachrichtEncrypted(&län, 1);
		char* message = new char[län + 1];
		message[län] = 0;
		k->getNachrichtEncrypted(message, län);
		err = message;
		delete[] message;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Sendet eine Nachricht an den Gruppen Chat
//  gruppeId: Die Id der Gruppe
//  nachricht: Die Nachricht, die gesendet werden soll
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool AnmeldungClient::gruppeNachricht(int gruppeId, const char* nachricht)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	char län = textLength(nachricht);
	if (!län)
		return 1;
	cs.lock();
	k->sendeEncrypted("\xD", 1);
	char serverReturn = 0;
	k->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn == 1)
	{
		k->sendeEncrypted((char*)&gruppeId, 4);
		k->sendeEncrypted((char*)&län, 1);
		k->sendeEncrypted(nachricht, län);
		k->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			cs.unlock();
			return 1;
		}
	}
	if (serverReturn == 3)
	{
		char län = 0;
		k->getNachrichtEncrypted(&län, 1);
		char* message = new char[län + 1];
		message[län] = 0;
		k->getNachrichtEncrypted(message, län);
		err = message;
		delete[] message;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Meldet den eingeloggten Account in der Warteschlange für eine Karte an
//  karteId: Die Id der Karte
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool AnmeldungClient::anmelden(int karteId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\xE", 1);
	char serverReturn = 0;
	k->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn == 1)
	{
		k->sendeEncrypted((char*)&karteId, 4);
		k->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			cs.unlock();
			return 1;
		}
	}
	if (serverReturn == 3)
	{
		char län = 0;
		k->getNachrichtEncrypted(&län, 1);
		char* message = new char[län + 1];
		message[län] = 0;
		k->getNachrichtEncrypted(message, län);
		err = message;
		delete[] message;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Meldet den eingeloggten Account aus der Warteschlange ab
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool AnmeldungClient::abmelden()
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\xF", 1);
	char serverReturn = 0;
	k->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn == 1)
	{
		cs.unlock();
		return 1;
	}
	if (serverReturn == 3)
	{
		char län = 0;
		k->getNachrichtEncrypted(&län, 1);
		char* message = new char[län + 1];
		message[län] = 0;
		k->getNachrichtEncrypted(message, län);
		err = message;
		delete[] message;
		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 AnmeldungClient::keepAlive()
{
	if (!k)
		return 0;
	char res = 0;
	if (!cs.tryLock())
		return 1;
	Framework::logLine((char*)"Verbindungstest zum Anmeldung Server...");
	bool ok = k->sendeEncrypted("\x13", 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 AnmeldungClient::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 Anmeldung 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 Anmeldung 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 AnmeldungClient::istVerbunden() const
{
	return k != 0;
}

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