#include "query.hh"
#include "config.hh"

#include <arpa/inet.h>
#include <fcntl.h>
#include <netdb.h>
#include <netinet/in.h>
#include <poll.h>
#include <sys/socket.h>

static int ApplicationType;
static char LoginData[30];

void SetQueryManagerLoginData(int Type, const char *Data){
	ApplicationType = Type;
	if(Data != NULL){
		strncpy(LoginData, Data, sizeof(LoginData));
		LoginData[sizeof(LoginData) - 1] = 0;
	}else{
		LoginData[0] = 0;
	}
}

// TQueryManagerConnection
// =============================================================================
// TODO(fusion): An initializer list executes in the same order fields are
// declared. This initialization should work as long as `BufferSize` is the
// first field declared in `TQueryManagerConnection`, which it is.
TQueryManagerConnection::TQueryManagerConnection(int QueryBufferSize) :
		BufferSize(std::max<int>(QueryBufferSize, KB(16))),
		Buffer(new uint8[this->BufferSize]),
		ReadBuffer(this->Buffer, this->BufferSize),
		WriteBuffer(this->Buffer, this->BufferSize),
		Socket(-1),
		QueryOk(false)
{
	this->connect();
}

TQueryManagerConnection::~TQueryManagerConnection(void){
	this->disconnect();
	delete[] this->Buffer;
}

bool ResolveHostNameAddress(const char *HostName, in_addr_t *OutAddr){
	// TODO(fusion): Just use `getaddrinfo`?
	int ErrorCode;
	hostent HostEnt;
	hostent *HostEntResult;
	char Buffer[2048];
	int Ret = gethostbyname_r(HostName, &HostEnt,
			Buffer, sizeof(Buffer), &HostEntResult, &ErrorCode);
	if(Ret != 0 || HostEntResult == NULL){
		return false;
	}

	if(OutAddr){
		*OutAddr = ((in_addr_t)HostEntResult->h_addr_list[0][0] << 24)
				| ((in_addr_t)HostEntResult->h_addr_list[0][1] << 16)
				| ((in_addr_t)HostEntResult->h_addr_list[0][2] <<  8)
				| ((in_addr_t)HostEntResult->h_addr_list[0][3] <<  0);
	}

	return true;
}

void TQueryManagerConnection::connect(void){
	for(int i = 0; i < NumberOfQueryManagers; i += 1){
		in_addr_t Addr = inet_addr(QUERY_MANAGER[i].Host);
		if(Addr == INADDR_NONE && !ResolveHostNameAddress(QUERY_MANAGER[i].Host, &Addr)){
			print(2, "TQueryManagerConnection::connect: Kann Rechnernamen nicht auflösen.\n");
			continue;
		}

		this->Socket = socket(AF_INET, SOCK_STREAM, 0);
		if(this->Socket == -1){
			print(2, "TQueryManagerConnection::connect: Kann Socket nicht öffnen.\n");
			continue;
		}

		struct sockaddr_in QueryManagerAddress = {};
		QueryManagerAddress.sin_family = AF_INET;
		QueryManagerAddress.sin_port = htons(QUERY_MANAGER[i].Port);
		QueryManagerAddress.sin_addr.s_addr = Addr;
		if(::connect(this->Socket, (struct sockaddr*)&QueryManagerAddress, sizeof(QueryManagerAddress)) == -1){
			print(2, "TQueryManagerConnection::connect: Kann Verbindung nicht herstellen.\n");
			this->disconnect();
			continue;
		}

		// NOTE(fusion): Make socket non-blocking AFTER connecting. This is to
		// better align the behaviour of both TQueryManagerConnection::read and
		// TQueryManagerConnection::write.
		{
			int SocketFlags = fcntl(this->Socket, F_GETFL);
			if(SocketFlags == -1 || fcntl(this->Socket, F_SETFL, (SocketFlags | O_NONBLOCK)) == -1){
				error("TQueryManagerConnection::connect: Failed to set socket as non-blocking: (%d) %s\n",
						errno, GetErrorDescription(errno));
				this->disconnect();
				continue;
			}
		}

		this->prepareQuery(0);
		this->sendByte((uint8)ApplicationType);
		this->sendString(QUERY_MANAGER[i].Password);
		if(ApplicationType == 1){
			this->sendString(LoginData);
		}

		int Status = this->executeQuery(30, false);
		if(Status != QUERY_STATUS_OK){
			print(2, "TQueryManagerConnection::connect: Anmeldung fehlgeschlagen (%d).\n", Status);
			this->disconnect();
			continue;
		}

		break;
	}

	if(!this->isConnected()){
		print(2, "TQueryManagerConnection::connect: Kein Query-Manager verfügbar.\n");
	}
}

void TQueryManagerConnection::disconnect(void){
	if(this->Socket != -1){
		if(close(this->Socket) == -1){
			error("TQueryManagerConnection::disconnect: Fehler %d beim Schließen der Socket.\n", errno);
		}
		this->Socket = -1;
	}
}

int TQueryManagerConnection::write(const uint8 *Buffer, int Size){
	int Attempts = 50;
	int BytesToWrite = Size;
	const uint8 *WritePtr = Buffer;
	while(BytesToWrite > 0){
		int BytesWritten = (int)::write(this->Socket, WritePtr, BytesToWrite);
		if(BytesWritten > 0){
			BytesToWrite -= BytesWritten;
			WritePtr += BytesWritten;
		}else if(BytesWritten == 0){
			break;
		}else if(errno != EINTR){
			if(errno != EAGAIN){
				return -errno;
			}else if(Attempts <= 0){
				return -ETIMEDOUT;
			}

			DelayThread(0, 100000);
			Attempts -= 1;
		}
	}
	return Size - BytesToWrite;
}

int TQueryManagerConnection::read(uint8 *Buffer, int Size, int Timeout){
	// NOTE(fusion): Wait until there is any inbound data then read everything
	// in one go. Data from the query manager is sent in a burst so we don't need
	// to be polling every step along the way.
	int TimeoutMS = Timeout * 1000;
	int64 Deadline = GetClockMonotonicMS() + TimeoutMS;
	while(true){
		struct pollfd pollfd = {};
		pollfd.fd = this->Socket;
		pollfd.events = POLLIN;
		pollfd.revents = 0;
		int ret = poll(&pollfd, 1, TimeoutMS);
		if(ret == 1) break;
		if(ret == 0) return -ETIMEDOUT;
		if(ret == -1 && errno != EINTR) return -errno;

		// NOTE(fusion): We should get a timeout before this turns negative, but
		// just in case... We don't want poll to block indefinitely...
		TimeoutMS = (int)(Deadline - GetClockMonotonicMS());
		if(TimeoutMS < 0){
			return -ETIMEDOUT;
		}
	}

	int Attempts = 50;
	int BytesToRead = Size;
	uint8 *ReadPtr = Buffer;
	while(BytesToRead > 0){
		int BytesRead = ::read(this->Socket, ReadPtr, BytesToRead);
		if(BytesRead > 0){
			BytesToRead -= BytesRead;
			ReadPtr += BytesRead;
		}else if(BytesRead == 0){
			break;
		}else if(errno != EINTR){
			if(errno != EAGAIN){
				return -errno;
			}else if(Attempts <= 0){
				return -ETIMEDOUT;
			}

			DelayThread(0, 100000);
			Attempts -= 1;
		}
	}
	return Size - BytesToRead;
}

void TQueryManagerConnection::prepareQuery(int QueryType){
	this->QueryOk = true;
	this->WriteBuffer.Position = 0;

	try{
		this->WriteBuffer.writeWord(0);
		this->WriteBuffer.writeByte((uint8)QueryType);
	}catch(const char *str){
		error("TQueryManagerConnection::prepareQuery: %s.\n", str);
		this->QueryOk = false;
	}
}

void TQueryManagerConnection::sendFlag(bool Flag){
	this->sendByte(Flag ? 0x01 : 0x00);
}

void TQueryManagerConnection::sendByte(uint8 Byte){
	try{
		this->WriteBuffer.writeByte(Byte);
	}catch(const char *str){
		error("TQueryManagerConnection::sendByte: %s.\n", str);
		this->QueryOk = false;
	}
}

void TQueryManagerConnection::sendWord(uint16 Word){
	try{
		this->WriteBuffer.writeWord(Word);
	}catch(const char *str){
		error("TQueryManagerConnection::sendWord: %s.\n", str);
		this->QueryOk = false;
	}
}

void TQueryManagerConnection::sendQuad(uint32 Quad){
	try{
		this->WriteBuffer.writeQuad(Quad);
	}catch(const char *str){
		error("TQueryManagerConnection::sendQuad: %s.\n", str);
		this->QueryOk = false;
	}
}

void TQueryManagerConnection::sendString(const char *String){
	try{
		this->WriteBuffer.writeString(String);
	}catch(const char *str){
		error("TQueryManagerConnection::sendString: %s.\n", str);
		this->QueryOk = false;
	}
}

void TQueryManagerConnection::sendBytes(const uint8 *Buffer, int Count){
	try{
		this->WriteBuffer.writeBytes(Buffer, Count);
	}catch(const char *str){
		error("TQueryManagerConnection::sendBytes: %s.\n", str);
		this->QueryOk = false;
	}
}

bool TQueryManagerConnection::getFlag(void){
	return this->getByte() != 0;
}

uint8 TQueryManagerConnection::getByte(void){
	uint8 Result = 0;
	try{
		Result = this->ReadBuffer.readByte();
	}catch(const char *str){
		error("TQueryManagerConnection::getByte: %s.\n", str);
	}
	return Result;
}

uint16 TQueryManagerConnection::getWord(void){
	uint16 Result = 0;
	try{
		Result = this->ReadBuffer.readWord();
	}catch(const char *str){
		error("TQueryManagerConnection::getWord: %s.\n", str);
	}
	return Result;
}

uint32 TQueryManagerConnection::getQuad(void){
	uint32 Result = 0;
	try{
		Result = this->ReadBuffer.readQuad();
	}catch(const char *str){
		error("TQueryManagerConnection::getQuad: %s.\n", str);
	}
	return Result;
}

void TQueryManagerConnection::getString(char *Buffer, int MaxLength){
	try{
		this->ReadBuffer.readString(Buffer, MaxLength);
	}catch(const char *str){
		error("TQueryManagerConnection::getString: %s.\n", str);
		if(MaxLength > 0){
			Buffer[0] = 0;
		}
	}
}

void TQueryManagerConnection::getBytes(uint8 *Buffer, int Count){
	try{
		this->ReadBuffer.readBytes(Buffer, Count);
	}catch(const char *str){
		error("TQueryManagerConnection::getBytes: %s.\n", str);
	}
}

int TQueryManagerConnection::executeQuery(int Timeout, bool AutoReconnect){
	// NOTE(fusion): `prepareQuery` will already leave two extra bytes at the
	// beginning of the buffer for writing the request's length.
	int PacketSize = this->WriteBuffer.Position;
	int PayloadSize = PacketSize - 2;
	this->WriteBuffer.Position = 0;
	if(PayloadSize < 0xFFFF){
		this->sendWord((uint16)PayloadSize);
	}else{
		PacketSize += 4;
		if(PacketSize > this->BufferSize){
			error("TQueryManagerConnection::executeQuery: Puffer zu klein.\n");
			return QUERY_STATUS_FAILED;
		}

		memmove(&this->Buffer[6], &this->Buffer[2], PayloadSize);
		this->sendWord(0xFFFF);
		this->sendQuad((uint32)PayloadSize);
	}

	if(!this->QueryOk){
		error("TQueryManagerConnection::executeQuery: Fehler beim Zusammenbauen der Anfrage.\n");
		return QUERY_STATUS_FAILED;
	}

	const int MaxAttempts = 2;
	for(int Attempt = 1; true; Attempt += 1){
		if(!this->isConnected()){
			if(!AutoReconnect){
				return QUERY_STATUS_FAILED;
			}

			// TODO(fusion): There was also a "fast" path that allocated on the
			// stack with variable length arrays. It would be a problem to mimic
			// that with `alloca` since its memory is only released at the end
			// of the function and we're in a loop.
			uint8 *TempBuffer = new uint8[PacketSize];
			memcpy(TempBuffer, this->Buffer, PacketSize);
			this->connect();
			memcpy(this->Buffer, TempBuffer, PacketSize);
			delete[] TempBuffer;

			if(!this->isConnected()){
				return QUERY_STATUS_FAILED;
			}
		}

		if(this->write(this->Buffer, PacketSize) != PacketSize){
			this->disconnect();
			if(Attempt >= MaxAttempts){
				error("TQueryManagerConnection::executeQuery: Fehler beim Abschicken der Anfrage.\n");
				return QUERY_STATUS_FAILED;
			}
			continue;
		}

		uint8 Help[4];
		int BytesRead = this->read(Help, 2, Timeout);
		if(BytesRead != 2){
			this->disconnect();
			if(BytesRead == -ETIMEDOUT || Attempt >= MaxAttempts){
				return QUERY_STATUS_FAILED;
			}
			continue;
		}

		int ResponseSize = ((int)Help[0]) | ((int)Help[1] << 8);
		if(ResponseSize == 0xFFFF){
			if(this->read(Help, 4, Timeout) != 4){
				this->disconnect();
				return QUERY_STATUS_FAILED;
			}

			ResponseSize = ((int)Help[0]) | ((int)Help[1] << 8)
					| ((int)Help[2] << 16) | ((int)Help[3] << 24);
		}

		if(ResponseSize <= 0 || ResponseSize > this->BufferSize){
			this->disconnect();
			error("TQueryManagerConnection::executeQuery: Ungültige Datengröße %d.\n", ResponseSize);
			return QUERY_STATUS_FAILED;
		}

		if(this->read(this->Buffer, ResponseSize, Timeout) != ResponseSize){
			this->disconnect();
			error("TQueryManagerConnection::executeQuery: Fehler beim Auslesen der Daten.\n");
			return QUERY_STATUS_FAILED;
		}

		this->ReadBuffer.Size = ResponseSize;
		this->ReadBuffer.Position = 0;
		int Status = this->getByte();
		if(Status == QUERY_STATUS_FAILED){
			error("TQueryManagerConnection::executeQuery: Anfrage fehlgeschlagen.\n");
		}

		return Status;
	}
}

int TQueryManagerConnection::checkAccountPassword(uint32 AccountID,
		const char *Password, const char *IPAddress){
	this->prepareQuery(10);
	this->sendQuad(AccountID);
	this->sendString(Password);
	this->sendString(IPAddress);
	int Status = this->executeQuery(30, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_ERROR){
		int ErrorCode = this->getByte();
		if(ErrorCode >= 1 && ErrorCode <= 4){
			Result = ErrorCode;
		}else{
			error("TQueryManagerConnection::checkAccountPassword: Ungültiger Fehlercode %d.\n", ErrorCode);
		}
	}
	return Result;
}

int TQueryManagerConnection::loginAdmin(uint32 AccountID, bool PrivateWorld,
		int *NumberOfCharacters, char (*Characters)[30], char (*Worlds)[30],
		uint8 (*IPAddresses)[4], uint16 *Ports, uint16 *PremiumDaysLeft){
	this->prepareQuery(12);
	this->sendQuad(AccountID);
	this->sendFlag(PrivateWorld);
	int Status = this->executeQuery(30, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		*NumberOfCharacters = this->getByte();
		for(int i = 0; i < *NumberOfCharacters; i += 1){
			this->getString(Characters[i], 30);
			this->getString(Worlds[i], 30);
			this->getBytes(IPAddresses[i], 4);
			Ports[i] = this->getWord();
		}
		*PremiumDaysLeft = this->getWord();
	}else if(Status == QUERY_STATUS_ERROR){
		int ErrorCode = this->getByte();
		if(ErrorCode == 1){
			Result = ErrorCode;
		}else{
			error("TQueryManagerConnection::loginAdmin: Ungültiger Fehlercode %d.\n", ErrorCode);
		}
	}
	return Result;
}

int TQueryManagerConnection::loadWorldConfig(int *WorldType, int *RebootTime,
		int *IPAddress, int *Port, int *MaxPlayers, int *PremiumPlayerBuffer,
		int *MaxNewbies, int *PremiumNewbieBuffer){
	this->prepareQuery(53);
	int Status = this->executeQuery(30, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		*WorldType = this->getByte();
		*RebootTime = (int)this->getByte() * 60;
		IPAddress[0] = this->getByte();
		IPAddress[1] = this->getByte();
		IPAddress[2] = this->getByte();
		IPAddress[3] = this->getByte();
		*Port = this->getWord();
		*MaxPlayers = this->getWord();
		*PremiumPlayerBuffer = this->getWord();
		*MaxNewbies = this->getWord();
		*PremiumNewbieBuffer = this->getWord();
	}
	return Result;
}

static int GetRightByName(const char *RightName){
	int Result = -1;
	if(strcmp(RightName, "PREMIUM_ACCOUNT") == 0){
		Result = PREMIUM_ACCOUNT;
	}else if(strcmp(RightName, "NOTATION") == 0){
		Result = NOTATION;
	}else if(strcmp(RightName, "NAMELOCK") == 0){
		Result = NAMELOCK;
	}else if(strcmp(RightName, "STATEMENT_REPORT") == 0){
		Result = STATEMENT_REPORT;
	}else if(strcmp(RightName, "BANISHMENT") == 0){
		Result = BANISHMENT;
	}else if(strcmp(RightName, "FINAL_WARNING") == 0){
		Result = FINAL_WARNING;
	}else if(strcmp(RightName, "IP_BANISHMENT") == 0){
		Result = IP_BANISHMENT;
	}else if(strcmp(RightName, "KICK") == 0){
		Result = KICK;
	}else if(strcmp(RightName, "HOME_TELEPORT") == 0){
		Result = HOME_TELEPORT;
	}else if(strcmp(RightName, "GAMEMASTER_BROADCAST") == 0){
		Result = GAMEMASTER_BROADCAST;
	}else if(strcmp(RightName, "ANONYMOUS_BROADCAST") == 0){
		Result = ANONYMOUS_BROADCAST;
	}else if(strcmp(RightName, "NO_BANISHMENT") == 0){
		Result = NO_BANISHMENT;
	}else if(strcmp(RightName, "ALLOW_MULTICLIENT") == 0){
		Result = ALLOW_MULTICLIENT;
	}else if(strcmp(RightName, "LOG_COMMUNICATION") == 0){
		Result = LOG_COMMUNICATION;
	}else if(strcmp(RightName, "READ_GAMEMASTER_CHANNEL") == 0){
		Result = READ_GAMEMASTER_CHANNEL;
	}else if(strcmp(RightName, "READ_TUTOR_CHANNEL") == 0){
		Result = READ_TUTOR_CHANNEL;
	}else if(strcmp(RightName, "HIGHLIGHT_HELP_CHANNEL") == 0){
		Result = HIGHLIGHT_HELP_CHANNEL;
	}else if(strcmp(RightName, "SEND_BUGREPORTS") == 0){
		Result = SEND_BUGREPORTS;
	}else if(strcmp(RightName, "NAME_INSULTING") == 0){
		Result = NAME_INSULTING;
	}else if(strcmp(RightName, "NAME_SENTENCE") == 0){
		Result = NAME_SENTENCE;
	}else if(strcmp(RightName, "NAME_NONSENSICAL_LETTERS") == 0){
		Result = NAME_NONSENSICAL_LETTERS;
	}else if(strcmp(RightName, "NAME_BADLY_FORMATTED") == 0){
		Result = NAME_BADLY_FORMATTED;
	}else if(strcmp(RightName, "NAME_NO_PERSON") == 0){
		Result = NAME_NO_PERSON;
	}else if(strcmp(RightName, "NAME_CELEBRITY") == 0){
		Result = NAME_CELEBRITY;
	}else if(strcmp(RightName, "NAME_COUNTRY") == 0){
		Result = NAME_COUNTRY;
	}else if(strcmp(RightName, "NAME_FAKE_IDENTITY") == 0){
		Result = NAME_FAKE_IDENTITY;
	}else if(strcmp(RightName, "NAME_FAKE_POSITION") == 0){
		Result = NAME_FAKE_POSITION;
	}else if(strcmp(RightName, "STATEMENT_INSULTING") == 0){
		Result = STATEMENT_INSULTING;
	}else if(strcmp(RightName, "STATEMENT_SPAMMING") == 0){
		Result = STATEMENT_SPAMMING;
	}else if(strcmp(RightName, "STATEMENT_ADVERT_OFFTOPIC") == 0){
		Result = STATEMENT_ADVERT_OFFTOPIC;
	}else if(strcmp(RightName, "STATEMENT_ADVERT_MONEY") == 0){
		Result = STATEMENT_ADVERT_MONEY;
	}else if(strcmp(RightName, "STATEMENT_NON_ENGLISH") == 0){
		Result = STATEMENT_NON_ENGLISH;
	}else if(strcmp(RightName, "STATEMENT_CHANNEL_OFFTOPIC") == 0){
		Result = STATEMENT_CHANNEL_OFFTOPIC;
	}else if(strcmp(RightName, "STATEMENT_VIOLATION_INCITING") == 0){
		Result = STATEMENT_VIOLATION_INCITING;
	}else if(strcmp(RightName, "CHEATING_BUG_ABUSE") == 0){
		Result = CHEATING_BUG_ABUSE;
	}else if(strcmp(RightName, "CHEATING_GAME_WEAKNESS") == 0){
		Result = CHEATING_GAME_WEAKNESS;
	}else if(strcmp(RightName, "CHEATING_MACRO_USE") == 0){
		Result = CHEATING_MACRO_USE;
	}else if(strcmp(RightName, "CHEATING_MODIFIED_CLIENT") == 0){
		Result = CHEATING_MODIFIED_CLIENT;
	}else if(strcmp(RightName, "CHEATING_HACKING") == 0){
		Result = CHEATING_HACKING;
	}else if(strcmp(RightName, "CHEATING_MULTI_CLIENT") == 0){
		Result = CHEATING_MULTI_CLIENT;
	}else if(strcmp(RightName, "CHEATING_ACCOUNT_TRADING") == 0){
		Result = CHEATING_ACCOUNT_TRADING;
	}else if(strcmp(RightName, "CHEATING_ACCOUNT_SHARING") == 0){
		Result = CHEATING_ACCOUNT_SHARING;
	}else if(strcmp(RightName, "GAMEMASTER_THREATENING") == 0){
		Result = GAMEMASTER_THREATENING;
	}else if(strcmp(RightName, "GAMEMASTER_PRETENDING") == 0){
		Result = GAMEMASTER_PRETENDING;
	}else if(strcmp(RightName, "GAMEMASTER_INFLUENCE") == 0){
		Result = GAMEMASTER_INFLUENCE;
	}else if(strcmp(RightName, "GAMEMASTER_FALSE_REPORTS") == 0){
		Result = GAMEMASTER_FALSE_REPORTS;
	}else if(strcmp(RightName, "KILLING_EXCESSIVE_UNJUSTIFIED") == 0){
		Result = KILLING_EXCESSIVE_UNJUSTIFIED;
	}else if(strcmp(RightName, "DESTRUCTIVE_BEHAVIOUR") == 0){
		Result = DESTRUCTIVE_BEHAVIOUR;
	}else if(strcmp(RightName, "SPOILING_AUCTION") == 0){
		Result = SPOILING_AUCTION;
	}else if(strcmp(RightName, "INVALID_PAYMENT") == 0){
		Result = INVALID_PAYMENT;
	}else if(strcmp(RightName, "TELEPORT_TO_CHARACTER") == 0){
		Result = TELEPORT_TO_CHARACTER;
	}else if(strcmp(RightName, "TELEPORT_TO_MARK") == 0){
		Result = TELEPORT_TO_MARK;
	}else if(strcmp(RightName, "TELEPORT_VERTICAL") == 0){
		Result = TELEPORT_VERTICAL;
	}else if(strcmp(RightName, "TELEPORT_TO_COORDINATE") == 0){
		Result = TELEPORT_TO_COORDINATE;
	}else if(strcmp(RightName, "LEVITATE") == 0){
		Result = LEVITATE;
	}else if(strcmp(RightName, "SPECIAL_MOVEUSE") == 0){
		Result = SPECIAL_MOVEUSE;
	}else if(strcmp(RightName, "MODIFY_GOSTRENGTH") == 0){
		Result = MODIFY_GOSTRENGTH;
	}else if(strcmp(RightName, "SHOW_COORDINATE") == 0){
		Result = SHOW_COORDINATE;
	}else if(strcmp(RightName, "RETRIEVE") == 0){
		Result = RETRIEVE;
	}else if(strcmp(RightName, "ENTER_HOUSES") == 0){
		Result = ENTER_HOUSES;
	}else if(strcmp(RightName, "OPEN_NAMEDOORS") == 0){
		// TODO(fusion): The actual name was "OPEN_NAMEDDOORS" but could be a typo?
		// Either way, it doesn't make that much of a difference since there is no
		// actual query manager outside the ones we might build ourselves.
		Result = OPEN_NAMEDOORS;
	}else if(strcmp(RightName, "INVULNERABLE") == 0){
		Result = INVULNERABLE;
	}else if(strcmp(RightName, "UNLIMITED_MANA") == 0){
		Result = UNLIMITED_MANA;
	}else if(strcmp(RightName, "KEEP_INVENTORY") == 0){
		Result = KEEP_INVENTORY;
	}else if(strcmp(RightName, "ALL_SPELLS") == 0){
		Result = ALL_SPELLS;
	}else if(strcmp(RightName, "UNLIMITED_CAPACITY") == 0){
		Result = UNLIMITED_CAPACITY;
	}else if(strcmp(RightName, "ZERO_CAPACITY") == 0){
		Result = ZERO_CAPACITY;
	}else if(strcmp(RightName, "ATTACK_EVERYWHERE") == 0){
		Result = ATTACK_EVERYWHERE;
	}else if(strcmp(RightName, "NO_ATTACK") == 0){
		Result = NO_ATTACK;
	}else if(strcmp(RightName, "NO_RUNES") == 0){
		Result = NO_RUNES;
	}else if(strcmp(RightName, "NO_LOGOUT_BLOCK") == 0){
		Result = NO_LOGOUT_BLOCK;
	}else if(strcmp(RightName, "GAMEMASTER_OUTFIT") == 0){
		Result = GAMEMASTER_OUTFIT;
	}else if(strcmp(RightName, "ILLUMINATE") == 0){
		Result = ILLUMINATE;
	}else if(strcmp(RightName, "CHANGE_PROFESSION") == 0){
		Result = CHANGE_PROFESSION;
	}else if(strcmp(RightName, "IGNORED_BY_MONSTERS") == 0){
		Result = IGNORED_BY_MONSTERS;
	}else if(strcmp(RightName, "SHOW_KEYHOLE_NUMBERS") == 0){
		Result = SHOW_KEYHOLE_NUMBERS;
	}else if(strcmp(RightName, "CREATE_OBJECTS") == 0){
		Result = CREATE_OBJECTS;
	}else if(strcmp(RightName, "CREATE_MONEY") == 0){
		Result = CREATE_MONEY;
	}else if(strcmp(RightName, "CREATE_MONSTERS") == 0){
		Result = CREATE_MONSTERS;
	}else if(strcmp(RightName, "CHANGE_SKILLS") == 0){
		Result = CHANGE_SKILLS;
	}else if(strcmp(RightName, "CLEANUP_FIELDS") == 0){
		Result = CLEANUP_FIELDS;
	}else if(strcmp(RightName, "NO_STATISTICS") == 0){
		Result = NO_STATISTICS;
	}
	return Result;
}

// NOTE(fusion): These seem to be related to forums and an admin panel.
static bool IsAdministrativeRight(const char *RightName){
	return strcmp(RightName, "CLEAR_CHARACTER_INFO") == 0
		|| strcmp(RightName, "CLEAR_GUILDS") == 0
		|| strcmp(RightName, "DELETE_GUILDS") == 0
		|| strcmp(RightName, "BOARD_REPORT") == 0
		|| strcmp(RightName, "BOARD_MODERATION") == 0
		|| strcmp(RightName, "BOARD_ANONYMOUS_EDIT") == 0
		|| strcmp(RightName, "BOARD_PRECONFIRMED") == 0
		|| strcmp(RightName, "KEEP_ACCOUNT") == 0
		|| strcmp(RightName, "INVITED") == 0
		|| strcmp(RightName, "CIPWATCH_ADMIN") == 0
		|| strcmp(RightName, "CIPWATCH_USER") == 0
		|| strcmp(RightName, "CREATECHAR_GAMEMASTER") == 0
		|| strcmp(RightName, "CREATECHAR_GOD") == 0
		|| strcmp(RightName, "CREATECHAR_TEST") == 0
		|| strcmp(RightName, "VIEW_ACCOUNT") == 0
		|| strcmp(RightName, "VIEW_GAMEMASTER_RECORD") == 0
		|| strcmp(RightName, "VIEW_CRIMINAL_RECORD") == 0
		|| strcmp(RightName, "VIEW_LOG_FILES") == 0
		|| strcmp(RightName, "MODIFY_BANISHMENT") == 0
		|| strcmp(RightName, "APPOINT_CIP") == 0
		|| strcmp(RightName, "APPOINT_SGM") == 0
		|| strcmp(RightName, "APPOINT_JGM") == 0
		|| strcmp(RightName, "APPOINT_SENATOR") == 0
		|| strcmp(RightName, "SET_ACCOUNT_RIGHTS") == 0
		|| strcmp(RightName, "SET_CHARACTER_RIGHTS") == 0
		|| strcmp(RightName, "SET_ACCOUNTGROUP_RIGHTS") == 0
		|| strcmp(RightName, "SET_CHARACTERGROUP_RIGHTS") == 0
		|| strcmp(RightName, "KEEP_CHARACTER") == 0
		|| strcmp(RightName, "EXTRA_CHARACTER") == 0;
}

// NOTE(fusion): `PlayerName` is an input and output parameter. It will contain
// the correct player name with upper and lower case letters if the operation is
// successful.
int TQueryManagerConnection::loginGame(uint32 AccountID, char *PlayerName,
		const char *Password, const char *IPAddress, bool PrivateWorld,
		bool PremiumAccountRequired, bool GamemasterRequired, uint32 *CharacterID,
		int *Sex, char *Guild, char *Rank, char *Title, int *NumberOfBuddies,
		uint32 *BuddyIDs, char (*BuddyNames)[30], uint8 *Rights,
		bool *PremiumAccountActivated){
	this->prepareQuery(20);
	this->sendQuad(AccountID);
	this->sendString(PlayerName);
	this->sendString(Password);
	this->sendString(IPAddress);
	this->sendFlag(PrivateWorld);
	this->sendFlag(PremiumAccountRequired);
	this->sendFlag(GamemasterRequired);
	int Status = this->executeQuery(120, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		*CharacterID = this->getQuad();
		this->getString(PlayerName, 30);
		*Sex = this->getByte();
		this->getString(Guild, 30);
		this->getString(Rank, 30);
		this->getString(Title, 30);
		*NumberOfBuddies = this->getByte();

		int SkipBuddies = 0;
		if(*NumberOfBuddies > 100){ // MAX_BUDDIES
			error("TQueryManagerConnection::loginGame: zu viele Buddys (%d) für %s.\n",
					*NumberOfBuddies, PlayerName);
			SkipBuddies = *NumberOfBuddies - 100;
			*NumberOfBuddies = 100;
		}

		for(int i = 0; i < *NumberOfBuddies; i += 1){
			BuddyIDs[i] = this->getQuad();
			this->getString(BuddyNames[i], 30);
		}

		if(SkipBuddies > 0){
			char BuddyName[30];
			for(int i = 0; i < SkipBuddies; i += 1){
				this->getQuad();
				this->getString(BuddyName, 30);
			}
		}

		int NumberOfRights = this->getByte();
		memset(Rights, 0, 12); // MAX_RIGHT_BYTES ?
		for(int i = 0; i < NumberOfRights; i += 1){
			char RightName[30];
			this->getString(RightName, 30);
			int Right = GetRightByName(RightName);
			if(Right != -1){
				SetBit(Rights, Right);
			}else if(!IsAdministrativeRight(RightName)){
				error("TQueryManagerConnection::loginGame: Unbekanntes Recht %s.\n", RightName);
			}
		}

		*PremiumAccountActivated = this->getFlag();
	}else if(Status == QUERY_STATUS_ERROR){
		int ErrorCode = this->getByte();
		if(ErrorCode >= 1 && ErrorCode <= 15){
			Result = ErrorCode;
		}else{
			error("TQueryManagerConnection::loginGame: Ungültiger Fehlercode %d.\n", ErrorCode);
		}
	}
	return Result;
}

int TQueryManagerConnection::logoutGame(uint32 CharacterID, int Level, const char *Profession,
		const char *Residence, time_t LastLoginTime, int TutorActivities){
	this->prepareQuery(21);
	this->sendQuad(CharacterID);
	this->sendWord(Level);
	this->sendString(Profession);
	this->sendString(Residence);
	this->sendQuad((uint32)LastLoginTime);
	this->sendWord((uint16)TutorActivities);
	int Status = this->executeQuery(120, true);
	return (Status == QUERY_STATUS_OK ? 0 : -1);
}

int TQueryManagerConnection::setNotation(uint32 GamemasterID, const char *PlayerName,
		const char *IPAddress, const char *Reason, const char *Comment, uint32 *BanishmentID){
	this->prepareQuery(26);
	this->sendQuad(GamemasterID);
	this->sendString(PlayerName);
	this->sendString(IPAddress);
	this->sendString(Reason);
	this->sendString(Comment);
	int Status = this->executeQuery(30, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		*BanishmentID = this->getQuad();
	}else if(Status == QUERY_STATUS_ERROR){
		int ErrorCode = this->getByte();
		if(ErrorCode >= 1 && ErrorCode <= 2){
			Result = ErrorCode;
		}else{
			error("TQueryManagerConnection::setNotation: Ungültiger Fehlercode %d.\n", ErrorCode);
		}
	}else{
		error("TQueryManagerConnection::setNotation: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::setNamelock(uint32 GamemasterID, const char *PlayerName,
		const char *IPAddress, const char *Reason, const char *Comment){
	this->prepareQuery(23);
	this->sendQuad(GamemasterID);
	this->sendString(PlayerName);
	this->sendString(IPAddress);
	this->sendString(Reason);
	this->sendString(Comment);
	int Status = this->executeQuery(30, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_ERROR){
		int ErrorCode = this->getByte();
		if(ErrorCode >= 1 && ErrorCode <= 4){
			Result = ErrorCode;
		}else{
			error("TQueryManagerConnection::setNamelock: Ungültiger Fehlercode %d.\n", ErrorCode);
		}
	}else if(Status != QUERY_STATUS_OK){
		error("TQueryManagerConnection::setNamelock: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::banishAccount(uint32 GamemasterID, const char *PlayerName,
		const char *IPAddress, const char *Reason, const char *Comment, bool *FinalWarning,
		int *Days, uint32 *BanishmentID){
	this->prepareQuery(25);
	this->sendQuad(GamemasterID);
	this->sendString(PlayerName);
	this->sendString(IPAddress);
	this->sendString(Reason);
	this->sendString(Comment);
	this->sendFlag(*FinalWarning);
	int Status = this->executeQuery(30, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		*BanishmentID = this->getQuad();
		*Days = this->getByte();
		*FinalWarning = this->getFlag();
		if(*Days == 0xFF){
			*Days = -1;
		}
	}else if(Status == QUERY_STATUS_ERROR){
		int ErrorCode = this->getByte();
		if(ErrorCode >= 1 && ErrorCode <= 3){
			Result = ErrorCode;
		}else{
			error("TQueryManagerConnection::banishAccount: Ungültiger Fehlercode %d.\n", ErrorCode);
		}
	}else{
		error("TQueryManagerConnection::banishAccount: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::reportStatement(uint32 ReporterID, const char *PlayerName,
		const char *Reason, const char *Comment, uint32 BanishmentID, uint32 StatementID,
		int NumberOfStatements, uint32 *StatementIDs, int *TimeStamps, uint32 *CharacterIDs,
		const char (*Channels)[30], const char (*Texts)[256]){
	this->prepareQuery(27);
	this->sendQuad(ReporterID);
	this->sendString(PlayerName);
	this->sendString(Reason);
	this->sendString(Comment);
	this->sendQuad(BanishmentID);
	this->sendQuad(StatementID);

	int NonZeroStatements = 0;
	for(int i = 0; i < NumberOfStatements; i += 1){
		if(StatementIDs[i] != 0){
			NonZeroStatements += 1;
		}
	}

	this->sendWord((uint16)NonZeroStatements);
	for(int i = 0; i < NumberOfStatements; i += 1){
		if(StatementIDs[i] != 0){
			this->sendQuad(StatementIDs[i]);
			this->sendQuad((uint32)TimeStamps[i]);
			this->sendQuad(CharacterIDs[i]);
			this->sendString(Channels[i]);
			this->sendString(Texts[i]);
		}
	}

	int Status = this->executeQuery(180, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_ERROR){
		int ErrorCode = this->getByte();
		if(ErrorCode >= 1 && ErrorCode <= 2){
			Result = ErrorCode;
		}else{
			error("TQueryManagerConnection::reportStatement: Ungültiger Fehlercode %d.\n", ErrorCode);
		}
	}else if(Status != QUERY_STATUS_OK){
		error("TQueryManagerConnection::reportStatement: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::banishIPAddress(uint32 GamemasterID, const char *PlayerName,
		const char *IPAddress, const char *Reason, const char *Comment){
	this->prepareQuery(28);
	this->sendQuad(GamemasterID);
	this->sendString(PlayerName);
	this->sendString(IPAddress);
	this->sendString(Reason);
	this->sendString(Comment);
	int Status = this->executeQuery(30, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_ERROR){
		int ErrorCode = this->getByte();
		if(ErrorCode >= 1 && ErrorCode <= 2){
			Result = ErrorCode;
		}else{
			error("TQueryManagerConnection::banishIPAddress: Ungültiger Fehlercode %d.\n", ErrorCode);
		}
	}else if(Status != QUERY_STATUS_OK){
		error("TQueryManagerConnection::banishIPAddress: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::logCharacterDeath(uint32 CharacterID, int Level,
		uint32 Offender, const char *Remark, bool Unjustified, time_t Time){
	this->prepareQuery(29);
	this->sendQuad(CharacterID);
	this->sendWord((uint16)Level);
	this->sendQuad(Offender);
	this->sendString(Remark);
	this->sendFlag(Unjustified);
	this->sendQuad((uint32)Time);
	int Status = this->executeQuery(90, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status != QUERY_STATUS_OK){
		error("TQueryManagerConnection::logCharacterDeath: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::addBuddy(uint32 AccountID, uint32 Buddy){
	this->prepareQuery(30);
	this->sendQuad(AccountID);
	this->sendQuad(Buddy);
	int Status = this->executeQuery(90, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status != QUERY_STATUS_OK){
		error("TQueryManagerConnection::addBuddy: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::removeBuddy(uint32 AccountID, uint32 Buddy){
	this->prepareQuery(31);
	this->sendQuad(AccountID);
	this->sendQuad(Buddy);
	int Status = this->executeQuery(90, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status != QUERY_STATUS_OK){
		error("TQueryManagerConnection::removeBuddy: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::decrementIsOnline(uint32 CharacterID){
	this->prepareQuery(32);
	this->sendQuad(CharacterID);
	int Status = this->executeQuery(30, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status != QUERY_STATUS_OK){
		error("TQueryManagerConnection::decrementIsOnline: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::finishAuctions(int *NumberOfAuctions, uint16 *HouseIDs,
		uint32 *CharacterIDs, char (*CharacterNames)[30], int *Bids){
	this->prepareQuery(33);
	int Status = this->executeQuery(60, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		int MaxNumberOfAuctions = *NumberOfAuctions;
		*NumberOfAuctions = this->getWord();
		if(*NumberOfAuctions > MaxNumberOfAuctions){
			error("TQueryManagerConnection::finishAuctions: zu viele Auktionen (%d>%d).\n",
					*NumberOfAuctions, MaxNumberOfAuctions);
			return -1;
		}

		for(int i = 0; i < *NumberOfAuctions; i += 1){
			HouseIDs[i] = this->getWord();
			CharacterIDs[i] = this->getQuad();
			this->getString(CharacterNames[i], 30);
			Bids[i] = (int)this->getQuad();
		}
	}else{
		error("TQueryManagerConnection::finishAuctions: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::excludeFromAuctions(uint32 CharacterID, bool Banish){
	this->prepareQuery(51);
	this->sendQuad(CharacterID);
	this->sendFlag(Banish);
	int Status = this->executeQuery(30, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status != QUERY_STATUS_OK){
		error("TQueryManagerConnection::excludeFromAuctions: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::transferHouses(int *NumberOfTransfers, uint16 *HouseIDs,
		uint32 *NewOwnerIDs, char (*NewOwnerNames)[30], int *Prices){
	this->prepareQuery(35);
	int Status = this->executeQuery(60, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		int MaxNumberOfTransfers = *NumberOfTransfers;
		*NumberOfTransfers = this->getWord();
		if(*NumberOfTransfers > MaxNumberOfTransfers){
			error("TQueryManagerConnection::transferHouses: zu viele Transfers (%d>%d).\n",
					*NumberOfTransfers, MaxNumberOfTransfers);
			return -1;
		}

		for(int i = 0; i < *NumberOfTransfers; i += 1){
			HouseIDs[i] = this->getWord();
			NewOwnerIDs[i] = this->getQuad();
			this->getString(NewOwnerNames[i], 30);
			Prices[i] = (int)this->getQuad();
		}
	}else{
		error("TQueryManagerConnection::transferHouses: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::cancelHouseTransfer(uint16 HouseID){
	this->prepareQuery(52);
	this->sendWord(HouseID);
	int Status = this->executeQuery(30, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status != QUERY_STATUS_OK){
		error("TQueryManagerConnection::cancelHouseTransfer: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::evictFreeAccounts(int *NumberOfEvictions,
		uint16 *HouseIDs, uint32 *OwnerIDs){
	this->prepareQuery(36);
	int Status = this->executeQuery(60, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		int MaxNumberOfEvictions = *NumberOfEvictions;
		*NumberOfEvictions = this->getWord();
		if(*NumberOfEvictions > MaxNumberOfEvictions){
			error("TQueryManagerConnection::evictFreeAccounts: zu viele Räumungen (%d>%d).\n",
					*NumberOfEvictions, MaxNumberOfEvictions);
			return -1;
		}

		for(int i = 0; i < *NumberOfEvictions; i += 1){
			HouseIDs[i] = this->getWord();
			OwnerIDs[i] = this->getQuad();
		}
	}else{
		error("TQueryManagerConnection::evictFreeAccounts: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::evictDeletedCharacters(int *NumberOfEvictions, uint16 *HouseIDs){
	this->prepareQuery(37);
	int Status = this->executeQuery(60, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		int MaxNumberOfEvictions = *NumberOfEvictions;
		*NumberOfEvictions = this->getWord();
		if(*NumberOfEvictions > MaxNumberOfEvictions){
			error("TQueryManagerConnection::evictDeletedCharacters: zu viele Räumungen (%d>%d).\n",
					*NumberOfEvictions, MaxNumberOfEvictions);
			return -1;
		}

		for(int i = 0; i < *NumberOfEvictions; i += 1){
			HouseIDs[i] = this->getWord();
		}
	}else{
		error("TQueryManagerConnection::evictDeletedCharacters: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::evictExGuildleaders(int NumberOfGuildhouses,
		int *NumberOfEvictions, uint16 *HouseIDs, uint32 *Guildleaders){
	this->prepareQuery(38);

	this->sendWord((uint16)NumberOfGuildhouses);
	for(int i = 0; i < NumberOfGuildhouses; i += 1){
		this->sendWord(HouseIDs[i]);
		this->sendQuad(Guildleaders[i]);
	}

	int Status = this->executeQuery(60, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		*NumberOfEvictions = this->getWord();
		for(int i = 0; i < *NumberOfEvictions; i += 1){
			HouseIDs[i] = this->getWord();
		}
	}else{
		error("TQueryManagerConnection::evictExGuildleaders: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::insertHouseOwner(uint16 HouseID, uint32 OwnerID, int PaidUntil){
	this->prepareQuery(39);
	this->sendWord(HouseID);
	this->sendQuad(OwnerID);
	this->sendQuad((uint32)PaidUntil);
	int Status = this->executeQuery(30, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status != QUERY_STATUS_OK){
		error("TQueryManagerConnection::insertHouseOwner: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::updateHouseOwner(uint16 HouseID, uint32 OwnerID, int PaidUntil){
	this->prepareQuery(40);
	this->sendWord(HouseID);
	this->sendQuad(OwnerID);
	this->sendQuad((uint32)PaidUntil);
	int Status = this->executeQuery(30, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status != QUERY_STATUS_OK){
		error("TQueryManagerConnection::updateHouseOwner: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::deleteHouseOwner(uint16 HouseID){
	this->prepareQuery(41);
	this->sendWord(HouseID);
	int Status = this->executeQuery(30, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status != QUERY_STATUS_OK){
		error("TQueryManagerConnection::deleteHouseOwner: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::getHouseOwners(int *NumberOfOwners, uint16 *HouseIDs,
		uint32 *OwnerIDs, char (*OwnerNames)[30], int *PaidUntils){
	this->prepareQuery(42);
	int Status = this->executeQuery(60, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		int MaxNumberOfOwners = *NumberOfOwners;
		*NumberOfOwners = this->getWord();
		if(*NumberOfOwners > MaxNumberOfOwners){
			error("TQueryManagerConnection::getHouseOwners: zu viele Häuser (%d>%d).\n",
					*NumberOfOwners, MaxNumberOfOwners);
			return -1;
		}

		for(int i = 0; i < *NumberOfOwners; i += 1){
			HouseIDs[i] = this->getWord();
			OwnerIDs[i] = this->getQuad();
			this->getString(OwnerNames[i], 30);
			PaidUntils[i] = (int)this->getQuad();
		}
	}else{
		error("TQueryManagerConnection::getHouseOwners: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::getAuctions(int *NumberOfAuctions, uint16 *HouseIDs){
	this->prepareQuery(43);
	int Status = this->executeQuery(120, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		int MaxNumberOfAuctions = *NumberOfAuctions;
		*NumberOfAuctions = this->getWord();
		if(*NumberOfAuctions > MaxNumberOfAuctions){
			error("TQueryManagerConnection::getAuctions: zu viele Auktionen (%d>%d).\n",
					*NumberOfAuctions, MaxNumberOfAuctions);
			return -1;
		}

		for(int i = 0; i < *NumberOfAuctions; i += 1){
			HouseIDs[i] = this->getWord();
		}
	}else{
		error("TQueryManagerConnection::getAuctions: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::startAuction(uint16 HouseID){
	this->prepareQuery(44);
	this->sendWord(HouseID);
	int Status = this->executeQuery(30, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status != QUERY_STATUS_OK){
		error("TQueryManagerConnection::startAuction: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::insertHouses(int NumberOfHouses, uint16 *HouseIDs,
		const char **Names, int *Rents, const char **Descriptions, int *Sizes,
		int *PositionsX,int *PositionsY,int *PositionsZ, char (*Towns)[30],
		bool *Guildhouses){
	this->prepareQuery(45);

	this->sendWord(NumberOfHouses);
	for(int i = 0; i < NumberOfHouses; i += 1){
		this->sendWord(HouseIDs[i]);
		this->sendString(Names[i]);
		this->sendQuad((int)Rents[i]);
		this->sendString(Descriptions[i]);
		this->sendWord((uint16)Sizes[i]);
		this->sendWord((uint16)PositionsX[i]);
		this->sendWord((uint16)PositionsY[i]);
		this->sendByte((uint8)PositionsZ[i]);
		this->sendString(Towns[i]);
		this->sendFlag(Guildhouses[i]);
	}

	int Status = this->executeQuery(60, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status != QUERY_STATUS_OK){
		error("TQueryManagerConnection::insertHouses: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::clearIsOnline(int *NumberOfAffectedPlayers){
	this->prepareQuery(46);
	int Status = this->executeQuery(120, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		*NumberOfAffectedPlayers = this->getWord();
	}else{
		error("TQueryManagerConnection::clearIsOnline: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::createPlayerlist(int NumberOfPlayers, const char **Names,
		int *Levels, const char (*Professions)[30], bool *NewRecord){
	this->prepareQuery(47);

	if(NumberOfPlayers >= 0){
		this->sendWord((uint16)NumberOfPlayers);
		for(int i = 0; i < NumberOfPlayers; i += 1){
			this->sendString(Names[i]);
			this->sendWord((uint16)Levels[i]);
			this->sendString(Professions[i]);
		}
	}else{
		this->sendWord(0xFFFF);
	}

	int Status = this->executeQuery(240, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		*NewRecord = this->getFlag();
	}else{
		error("TQueryManagerConnection::createPlayerlist: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::logKilledCreatures(int NumberOfRaces, const char **Names,
		int *KilledPlayers, int *KilledCreatures){
	this->prepareQuery(48);

	this->sendWord((uint16)NumberOfRaces);
	for(int i = 0; i < NumberOfRaces; i += 1){
		this->sendString(Names[i]);
		this->sendQuad((uint32)KilledPlayers[i]);
		this->sendQuad((uint32)KilledCreatures[i]);
	}

	int Status = this->executeQuery(240, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status != QUERY_STATUS_OK){
		error("TQueryManagerConnection::logKilledCreatures: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::loadPlayers(uint32 MinimumCharacterID, int *NumberOfPlayers,
		char (*Names)[30], uint32 *CharacterIDs){
	this->prepareQuery(50);
	this->sendQuad(MinimumCharacterID);
	int Status = this->executeQuery(900, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		// TODO(fusion): This is called to fill the player index in `InitPlayerIndex`
		// but there is no explicit parameter that limits how many results are returned
		// which could be a problem.
		*NumberOfPlayers = (int)this->getQuad();
		for(int i = 0; i < *NumberOfPlayers; i += 1){
			this->getString(Names[i], 30);
			CharacterIDs[i] = this->getQuad();
		}
	}else{
		error("TQueryManagerConnection::loadPlayers: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::getKeptCharacters(uint32 MinimumCharacterID,
		int *NumberOfPlayers, uint32 *CharacterIDs){
	this->prepareQuery(200);
	this->sendQuad(MinimumCharacterID);
	int Status = this->executeQuery(1800, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		// TODO(fusion): Same as `loadPlayers`.
		*NumberOfPlayers = (int)this->getQuad();
		for(int i = 0; i < *NumberOfPlayers; i += 1){
			CharacterIDs[i] = this->getQuad();
		}
	}else{
		error("TQueryManagerConnection::getKeptCharacters: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::getDeletedCharacters(uint32 MinimumCharacterID,
		int *NumberOfPlayers, uint32 *CharacterIDs){
	this->prepareQuery(201);
	this->sendQuad(MinimumCharacterID);
	int Status = this->executeQuery(900, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		// TODO(fusion): Same as `loadPlayers`.
		*NumberOfPlayers = (int)this->getQuad();
		for(int i = 0; i < *NumberOfPlayers; i += 1){
			CharacterIDs[i] = this->getQuad();
		}
	}else{
		error("TQueryManagerConnection::getKeptCharacters: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::deleteOldCharacter(uint32 CharacterID){
	this->prepareQuery(202);
	this->sendQuad(CharacterID);
	int Status = this->executeQuery(30, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status != QUERY_STATUS_OK){
		error("TQueryManagerConnection::deleteOldCharacter: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::getHiddenCharacters(uint32 MinimumCharacterID,
		int *NumberOfPlayers, uint32 *CharacterIDs){
	this->prepareQuery(203);
	this->sendQuad(MinimumCharacterID);
	int Status = this->executeQuery(120, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		// TODO(fusion): Same as `loadPlayers`.
		*NumberOfPlayers = (int)this->getQuad();
		for(int i = 0; i < *NumberOfPlayers; i += 1){
			CharacterIDs[i] = this->getQuad();
		}
	}else{
		error("TQueryManagerConnection::getHiddenCharacters: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::createHighscores(int NumberOfPlayers, uint32 *CharacterIDs,
		int *ExpPoints, int *ExpLevel, int *Fist, int *Club, int *Axe,
		int *Sword, int *Distance, int *Shielding, int *Magic, int *Fishing){
	this->prepareQuery(204);

	this->sendQuad((uint32)NumberOfPlayers);
	for(int i = 0; i < NumberOfPlayers; i += 1){
		this->sendQuad(CharacterIDs[i]);
		this->sendQuad((uint32)ExpPoints[i]);
		this->sendWord((uint16)ExpLevel[i]);
		this->sendWord((uint16)Fist[i]);
		this->sendWord((uint16)Club[i]);
		this->sendWord((uint16)Axe[i]);
		this->sendWord((uint16)Sword[i]);
		this->sendWord((uint16)Distance[i]);
		this->sendWord((uint16)Shielding[i]);
		this->sendWord((uint16)Magic[i]);
		this->sendWord((uint16)Fishing[i]);
	}

	int Status = this->executeQuery(120, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status != QUERY_STATUS_OK){
		error("TQueryManagerConnection::createHighscores: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::createCensus(void){
	this->prepareQuery(205);
	int Status = this->executeQuery(600, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status != QUERY_STATUS_OK){
		error("TQueryManagerConnection::createCensus: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::createKillStatistics(void){
	this->prepareQuery(206);
	int Status = this->executeQuery(300, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status != QUERY_STATUS_OK){
		error("TQueryManagerConnection::createKillStatistics: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::getPlayersOnline(int *NumberOfWorlds, char (*Names)[30], uint16 *Players){
	this->prepareQuery(207);
	int Status = this->executeQuery(120, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		*NumberOfWorlds = this->getByte();
		for(int i = 0; i < *NumberOfWorlds; i += 1){
			this->getString(Names[i], 30);
			Players[i] = this->getWord();
		}
	}else{
		error("TQueryManagerConnection::getPlayersOnline: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::getWorlds(int *NumberOfWorlds, char (*Names)[30]){
	this->prepareQuery(208);
	int Status = this->executeQuery(120, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		*NumberOfWorlds = this->getByte();
		for(int i = 0; i < *NumberOfWorlds; i += 1){
			this->getString(Names[i], 30);
		}
	}else{
		error("TQueryManagerConnection::getWorlds: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::getServerLoad(const char *World, int Period, int *Data){
	this->prepareQuery(209);
	this->sendString(World);
	this->sendByte((uint8)Period);
	int Status = this->executeQuery(360, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		// TODO(fusion): Another hardcoded constant?
		for(int i = 0; i < 600; i += 0){
			Data[i] = this->getWord();
			if(Data[i] == 0xFFFF){
				Data[i] = -1;
			}
		}
	}else{
		error("TQueryManagerConnection::getServerLoad: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::insertPaymentDataOld(uint32 PurchaseNr, uint32 ReferenceNr,
		const char *FirstName, const char *LastName, const char *Company,
		const char *Street, const char *Zip, const char *City, const char *Country,
		const char *State, const char *Phone, const char *Fax, const char *EMail,
		const char *PaymentMethod, uint32 ProductID, const char *Registrant,
		uint32 AccountID, uint32 *PaymentID){
	this->prepareQuery(210);
	this->sendQuad(PurchaseNr);
	this->sendQuad(ReferenceNr);
	this->sendString(FirstName);
	this->sendString(LastName);
	this->sendString(Company);
	this->sendString(Street);
	this->sendString(Zip);
	this->sendString(City);
	this->sendString(Country);
	this->sendString(State);
	this->sendString(Phone);
	this->sendString(Fax);
	this->sendString(EMail);
	this->sendString(PaymentMethod);
	this->sendQuad(ProductID);
	this->sendString(Registrant);
	this->sendQuad(AccountID);
	int Status = this->executeQuery(360, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		*PaymentID = this->getQuad();
	}else if(Status == QUERY_STATUS_ERROR){
		int ErrorCode = this->getByte();
		if(ErrorCode == 1){
			Result = ErrorCode;
		}else{
			error("TQueryManagerConnection::insertPaymentDataOld: Ungültiger Fehlercode %d.\n", ErrorCode);
		}
	}else{
		error("TQueryManagerConnection::insertPaymentDataOld: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::addPaymentOld(uint32 AccountID, const char *Description,
		uint32 PaymentID, int Days, int *ActionTaken){
	this->prepareQuery(211);
	this->sendQuad(AccountID);
	this->sendString(Description);
	this->sendQuad(PaymentID);
	this->sendWord((uint16)Days);
	int Status = this->executeQuery(360, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		*ActionTaken = this->getByte();
	}else if(Status == QUERY_STATUS_ERROR){
		int ErrorCode = this->getByte();
		if(ErrorCode >= 1 && ErrorCode <= 2){
			Result = ErrorCode;
		}else{
			error("TQueryManagerConnection::addPaymentOld: Ungültiger Fehlercode %d.\n", ErrorCode);
		}
	}else{
		error("TQueryManagerConnection::addPaymentOld: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::cancelPaymentOld(uint32 PurchaseNr, uint32 ReferenceNr,
		uint32 AccountID, bool *IllegalUse, char *EMailAddress){
	this->prepareQuery(212);
	this->sendQuad(PurchaseNr);
	this->sendQuad(ReferenceNr);
	this->sendQuad(AccountID);
	int Status = this->executeQuery(360, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		*IllegalUse = this->getFlag();
		this->getString(EMailAddress, 50);
	}else if(Status == QUERY_STATUS_ERROR){
		int ErrorCode = this->getByte();
		if(ErrorCode >= 1 && ErrorCode <= 2){
			Result = ErrorCode;
		}else{
			error("TQueryManagerConnection::cancelPaymentOld: Ungültiger Fehlercode %d.\n", ErrorCode);
		}
	}else{
		error("TQueryManagerConnection::cancelPaymentOld: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::insertPaymentDataNew(uint32 PurchaseNr, uint32 ReferenceNr,
		const char *FirstName, const char *LastName, const char *Company,
		const char *Street, const char *Zip, const char *City, const char *Country,
		const char *State, const char *Phone, const char *Fax, const char *EMail,
		const char *PaymentMethod, uint32 ProductID, const char *Registrant,
		const char *PaymentKey, uint32 *PaymentID){
	this->prepareQuery(213);
	this->sendWord(PurchaseNr);
	this->sendWord(ReferenceNr);
	this->sendString(FirstName);
	this->sendString(LastName);
	this->sendString(Company);
	this->sendString(Street);
	this->sendString(Zip);
	this->sendString(City);
	this->sendString(Country);
	this->sendString(State);
	this->sendString(Phone);
	this->sendString(Fax);
	this->sendString(EMail);
	this->sendString(PaymentMethod);
	this->sendWord(ProductID);
	this->sendString(Registrant);
	this->sendString(PaymentKey);
	int Status = this->executeQuery(360, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		*PaymentID = this->getQuad();
	}else if(Status == QUERY_STATUS_ERROR){
		int ErrorCode = this->getByte();
		if(ErrorCode == 1){
			Result = ErrorCode;
		}else{
			error("TQueryManagerConnection::insertPaymentDataNew: Ungültiger Fehlercode %d.\n", ErrorCode);
		}
	}else{
		error("TQueryManagerConnection::insertPaymentDataNew: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::addPaymentNew(const char *PaymentKey, uint32 PaymentID,
		int *ActionTaken, char *EMailReceiver){
	this->prepareQuery(214);
	this->sendString(PaymentKey);
	this->sendQuad(PaymentID);
	int Status = this->executeQuery(360, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		*ActionTaken = this->getByte();
		if(*ActionTaken == 5){
			this->getString(EMailReceiver, 100);
		}
	}else if(Status == QUERY_STATUS_ERROR){
		int ErrorCode = this->getByte();
		if(ErrorCode >= 1 && ErrorCode <= 3){
			Result = ErrorCode;
		}else{
			error("TQueryManagerConnection::addPaymentNew: Ungültiger Fehlercode %d.\n", ErrorCode);
		}
	}else{
		error("TQueryManagerConnection::addPaymentNew: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

int TQueryManagerConnection::cancelPaymentNew(uint32 PurchaseNr, uint32 ReferenceNr,
		const char *PaymentKey, bool *IllegalUse, bool *Present, char *EMailAddress){
	this->prepareQuery(215);
	this->sendQuad(PurchaseNr);
	this->sendQuad(ReferenceNr);
	this->sendString(PaymentKey);
	int Status = this->executeQuery(360, true);
	int Result = (Status == QUERY_STATUS_OK ? 0 : -1);
	if(Status == QUERY_STATUS_OK){
		*IllegalUse = this->getFlag();
		*Present = this->getFlag();
		this->getString(EMailAddress, 50);
	}else if(Status == QUERY_STATUS_ERROR){
		int ErrorCode = this->getByte();
		if(ErrorCode == 1){
			Result = ErrorCode;
		}else{
			error("TQueryManagerConnection::cancelPaymentNew: Ungültiger Fehlercode %d.\n", ErrorCode);
		}
	}else{
		error("TQueryManagerConnection::cancelPaymentNew: Anfrage fehlgeschlagen.\n");
	}
	return Result;
}

// TQueryManagerConnectionPool
// =============================================================================
// TODO(fusion): Same as `TQueryManagerConnection::TQueryManagerConnection`.
TQueryManagerConnectionPool::TQueryManagerConnectionPool(int Connections) :
		NumberOfConnections(std::max<int>(Connections, 1)),
		QueryManagerConnection(NULL),
		QueryManagerConnectionFree(NULL),
		FreeQueryManagerConnections(this->NumberOfConnections),
		QueryManagerConnectionMutex(1)
{
	if(Connections <= 0){
		error("TQueryManagerConnectionPool::TQueryManagerConnectionPool:"
				" Ungültige Verbindungsanzahl %d.\n", Connections);
	}
}

void TQueryManagerConnectionPool::init(void){
	this->QueryManagerConnection = new TQueryManagerConnection[this->NumberOfConnections];
	this->QueryManagerConnectionFree = new bool[this->NumberOfConnections];
	for(int i = 0; i < this->NumberOfConnections; i += 1){
		if(!this->QueryManagerConnection[i].isConnected()){
			error("TQueryManagerConnectionPool::init: Kann nicht zum Query-Manager verbinden.\n");
			throw "cannot connect to query manager";
		}

		this->QueryManagerConnectionFree[i] = true;
	}
}

void TQueryManagerConnectionPool::exit(void){
	for(int i = 0; i < this->NumberOfConnections; i += 1){
		this->FreeQueryManagerConnections.down();
	}

	delete[] this->QueryManagerConnection;
	delete[] this->QueryManagerConnectionFree;
}

TQueryManagerConnection *TQueryManagerConnectionPool::getConnection(void){
	int ConnectionIndex = -1;
	this->FreeQueryManagerConnections.down();
	this->QueryManagerConnectionMutex.down();
	for(int i = 0; i < this->NumberOfConnections; i += 1){
		if(this->QueryManagerConnectionFree[i]){
			this->QueryManagerConnectionFree[i] = false;
			ConnectionIndex = i;
			break;
		}
	}
	this->QueryManagerConnectionMutex.up();

	if(ConnectionIndex == -1){
		error("TQueryManagerConnectionPool::getConnection: Keine freie Verbindung gefunden.\n");
		return NULL;
	}

	return &this->QueryManagerConnection[ConnectionIndex];
}

void TQueryManagerConnectionPool::releaseConnection(TQueryManagerConnection *Connection){
	int ConnectionIndex = -1;
	for(int i = 0; i < this->NumberOfConnections; i += 1){
		if(&this->QueryManagerConnection[i] == Connection){
			ConnectionIndex = i;
			break;
		}
	}

	if(ConnectionIndex == -1){
		error("TQueryManagerConnectionPool::releaseConnection: Verbindung nicht gefunden.\n");
		return;
	}

	this->QueryManagerConnectionFree[ConnectionIndex] = true;
	this->FreeQueryManagerConnections.up();
}

// TQueryManagerPoolConnection
// =============================================================================
TQueryManagerPoolConnection::TQueryManagerPoolConnection(TQueryManagerConnectionPool *Pool) :
		QueryManagerConnectionPool(Pool),
		QueryManagerConnection(NULL)
{
	if(this->QueryManagerConnectionPool == NULL){
		error("TQueryManagerPoolConnection::TQueryManagerPoolConnection: Pool ist NULL.\n");
		return;
	}

	this->QueryManagerConnection = this->QueryManagerConnectionPool->getConnection();
}

TQueryManagerPoolConnection::~TQueryManagerPoolConnection(void){
	if(this->QueryManagerConnection != NULL){
		ASSERT(this->QueryManagerConnectionPool != NULL);
		this->QueryManagerConnectionPool->releaseConnection(this->QueryManagerConnection);
	}
}