#include "netconn_internal.h"

#include "../util/logging.h"

#include "../util/util.h"

#include "../util/buffer.h"

#include "../md5/md5.h"

#include "../base64/base64.h"

#include <stdlib.h>

#include <string.h>

#include <zlib.h>

// cmdname is always given as literal from functions in this file, so it is never null.

static int sendVoid(flib_netconn *conn, const char *cmdname) {

		return -1;

	}

	return flib_netbase_sendf(conn->netBase, "%s\n\n", cmdname);

}

static int sendStr(flib_netconn *conn, const char *cmdname, const char *str) {

		return -1;

	}

	return flib_netbase_sendf(conn->netBase, "%s\n%s\n\n", cmdname, str);

}

static int sendInt(flib_netconn *conn, const char *cmdname, int param) {

		return -1;

	}

	return flib_netbase_sendf(conn->netBase, "%s\n%i\n\n", cmdname, param);

}

int flib_netconn_send_quit(flib_netconn *conn, const char *quitmsg) {

}

int flib_netconn_send_chat(flib_netconn *conn, const char *chat) {

}

int flib_netconn_send_teamchat(flib_netconn *conn, const char *chat) {

}

int flib_netconn_send_nick(flib_netconn *conn, const char *nick) {

	int result = -1;

		char *tmpName = flib_strdupnull(nick);

		if(tmpName) {

			if(!flib_netbase_sendf(conn->netBase, "%s\n%s\n\n", "NICK", nick)) {

				free(conn->playerName);

				conn->playerName = tmpName;

				tmpName = NULL;

				result = 0;

			}

		}

		free(tmpName);

	}

	return result;

}

int flib_netconn_send_password(flib_netconn *conn, const char *latin1Passwd) {

	int result = -1;

		md5_state_t md5state;

		uint8_t md5bytes[16];

		char md5hex[33];

		md5_init(&md5state);

		md5_append(&md5state, (unsigned char*)latin1Passwd, strlen(latin1Passwd));

		md5_finish(&md5state, md5bytes);

		for(int i=0;i<sizeof(md5bytes); i++) {

			// Needs to be lowercase - server checks case sensitive

			snprintf(md5hex+i*2, 3, "%02x", (unsigned)md5bytes[i]);

		}

		result = flib_netbase_sendf(conn->netBase, "%s\n%s\n\n", "PASSWORD", md5hex);

	}

	return result;

}

int flib_netconn_send_joinRoom(flib_netconn *conn, const char *room) {

}

int flib_netconn_send_createRoom(flib_netconn *conn, const char *room) {

}

int flib_netconn_send_renameRoom(flib_netconn *conn, const char *roomName) {

	return sendStr(conn, "ROOM_NAME", roomName);

}

int flib_netconn_send_leaveRoom(flib_netconn *conn) {

}

int flib_netconn_send_toggleReady(flib_netconn *conn) {

	return sendVoid(conn, "TOGGLE_READY");

}

int flib_netconn_send_addTeam(flib_netconn *conn, const flib_team *team) {

	int result = -1;

		for(int i=0; i<HEDGEHOGS_PER_TEAM; i++) {

			missingInfo |= !team->hogs[i].name || !team->hogs[i].hat;

		}

			flib_vector *vec = flib_vector_create();

			if(vec) {

				bool error = false;

				for(int i=0; i<HEDGEHOGS_PER_TEAM; i++) {

					error |= flib_vector_appendf(vec, "%s\n%s\n", team->hogs[i].name, team->hogs[i].hat);

				}

				error |= flib_vector_appendf(vec, "\n");

				}

			}

			flib_vector_destroy(vec);

		}

	}

	return result;

}

int flib_netconn_send_removeTeam(flib_netconn *conn, const char *teamname) {

}

int flib_netconn_send_engineMessage(flib_netconn *conn, const uint8_t *message, size_t size) {

	int result = -1;

		char *base64encout = NULL;

		base64_encode_alloc((const char*)message, size, &base64encout);

		if(base64encout) {

			result = flib_netbase_sendf(conn->netBase, "EM\n%s\n\n", base64encout);

		}

		free(base64encout);

	}

	return result;

}

int flib_netconn_send_teamHogCount(flib_netconn *conn, const char *teamname, int hogcount) {

	}

}

	}

}

int flib_netconn_send_weaponset(flib_netconn *conn, const flib_weaponset *weaponset) {

	}

}

int flib_netconn_send_map(flib_netconn *conn, const flib_map *map) {

		return -1;

	}

	bool error = false;

	if(map->seed) {

		error |= flib_netconn_send_mapSeed(conn, map->seed);

	}

	error |= flib_netconn_send_mapTemplate(conn, map->templateFilter);

	if(map->theme) {

		error |= flib_netconn_send_mapTheme(conn, map->theme);

	}

	error |= flib_netconn_send_mapGen(conn, map->mapgen);

	error |= flib_netconn_send_mapMazeSize(conn, map->mazeSize);

	if(map->name) {

		error |= flib_netconn_send_mapName(conn, map->name);

	}

	if(map->drawData && map->drawDataSize>0) {

		error |= flib_netconn_send_mapDrawdata(conn, map->drawData, map->drawDataSize);

	}

	return error;

}

int flib_netconn_send_mapName(flib_netconn *conn, const char *mapName) {

}

int flib_netconn_send_mapGen(flib_netconn *conn, int mapGen) {

}

int flib_netconn_send_mapTemplate(flib_netconn *conn, int templateFilter) {

}

int flib_netconn_send_mapMazeSize(flib_netconn *conn, int mazeSize) {

}

int flib_netconn_send_mapSeed(flib_netconn *conn, const char *seed) {

}

int flib_netconn_send_mapTheme(flib_netconn *conn, const char *theme) {

}

int flib_netconn_send_mapDrawdata(flib_netconn *conn, const uint8_t *drawData, size_t size) {

	int result = -1;

		uLongf zippedSize = compressBound(size);

		uint8_t *zipped = flib_malloc(zippedSize+4); // 4 extra bytes for header

		if(zipped) {

			// Create the QCompress size header (uint32 big endian)

			zipped[0] = (size>>24) & 0xff;

			zipped[1] = (size>>16) & 0xff;

			zipped[2] = (size>>8) & 0xff;

			zipped[3] = (size) & 0xff;

			if(compress(zipped+4, &zippedSize, drawData, size) != Z_OK) {

				flib_log_e("Error compressing drawn map data.");

			} else {

				char *base64encout = NULL;

				base64_encode_alloc((const char*)zipped, zippedSize+4, &base64encout);

				if(!base64encout) {

					flib_log_e("Error base64-encoding drawn map data.");

				} else {

					result = flib_netbase_sendf(conn->netBase, "CFG\nDRAWNMAP\n%s\n\n", base64encout);

				}

				free(base64encout);

			}

		}

		free(zipped);

	}

	return result;

}

int flib_netconn_send_script(flib_netconn *conn, const char *scriptName) {

}

int flib_netconn_send_scheme(flib_netconn *conn, const flib_cfg *scheme) {

	int result = -1;

		flib_vector *vec = flib_vector_create();

		if(vec) {

			bool error = false;

			error |= flib_vector_appendf(vec, "CFG\nSCHEME\n%s\n", scheme->name);

			for(int i=0; i<scheme->meta->modCount; i++) {

				error |= flib_vector_appendf(vec, "%s\n", scheme->mods[i] ? "true" : "false");

			}

			for(int i=0; i<scheme->meta->settingCount; i++) {

				error |= flib_vector_appendf(vec, "%i\n", scheme->settings[i]);

			}

			error |= flib_vector_appendf(vec, "\n");

			if(!error) {

				result = flib_netbase_send_raw(conn->netBase, flib_vector_data(vec), flib_vector_size(vec));

			}

		}

		flib_vector_destroy(vec);

	}

	return result;

}

int flib_netconn_send_roundfinished(flib_netconn *conn, bool withoutError) {

}

int flib_netconn_send_ban(flib_netconn *conn, const char *playerName) {

	return sendStr(conn, "BAN", playerName);

}

int flib_netconn_send_kick(flib_netconn *conn, const char *playerName) {

	return sendStr(conn, "KICK", playerName);

}

int flib_netconn_send_playerInfo(flib_netconn *conn, const char *playerName) {

	return sendStr(conn, "INFO", playerName);

}

int flib_netconn_send_playerFollow(flib_netconn *conn, const char *playerName) {

	return sendStr(conn, "FOLLOW", playerName);

}

int flib_netconn_send_startGame(flib_netconn *conn) {

	return sendVoid(conn, "START_GAME");

}

int flib_netconn_send_toggleRestrictJoins(flib_netconn *conn) {

	return sendVoid(conn, "TOGGLE_RESTRICT_JOINS");

}

int flib_netconn_send_toggleRestrictTeams(flib_netconn *conn) {

	return sendVoid(conn, "TOGGLE_RESTRICT_TEAMS");

}

int flib_netconn_send_clearAccountsCache(flib_netconn *conn) {

	return sendVoid(conn, "CLEAR_ACCOUNTS_CACHE");

}

int flib_netconn_send_setServerVar(flib_netconn *conn, const char *name, const char *value) {

		return -1;

	}

	return flib_netbase_sendf(conn->netBase, "%s\n%s\n%s\n\n", "SET_SERVER_VAR", name, value);

}

int flib_netconn_send_getServerVars(flib_netconn *conn) {

	return sendVoid(conn, "GET_SERVER_VAR");

}