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

#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <inttypes.h>
#include <stdlib.h>

int flib_ipc_append_message(flib_vector *vec, const char *fmt, ...) {
	int result = -1;
	if(!log_badparams_if(!vec || !fmt)) {
		// 1 byte size prefix, 255 bytes max message length, 1 0-byte for vsnprintf
		char msgbuffer[257];

		// Format the message, leaving one byte at the start for the length
		va_list argp;
		va_start(argp, fmt);
		int msgSize = vsnprintf(msgbuffer+1, 256, fmt, argp);
		va_end(argp);

		if(!log_e_if(msgSize > 255, "Message too long (%u bytes)", (unsigned)msgSize)
				&& !log_e_if(msgSize < 0, "printf error")) {
			// Add the length prefix
			((uint8_t*)msgbuffer)[0] = msgSize;

			// Append it to the vector
			result = flib_vector_append(vec, msgbuffer, msgSize+1);
		}
	}
	return result;
}

int flib_ipc_append_mapconf(flib_vector *vec, const flib_map *map, bool mappreview) {
	int result = -1;
	flib_vector *tempvector = flib_vector_create();
	if(!log_badparams_if(!vec || !map)) {
		bool error = false;

		if(map->mapgen == MAPGEN_NAMED) {
			error |= log_e_if(!map->name, "Missing map name")
					|| flib_ipc_append_message(tempvector, "emap %s", map->name);
		}
		if(!mappreview) {
			error |= log_e_if(!map->theme, "Missing map theme")
					|| flib_ipc_append_message(tempvector, "etheme %s", map->theme);
		}
		error |= flib_ipc_append_seed(tempvector, map->seed);
		error |= flib_ipc_append_message(tempvector, "e$template_filter %i", map->templateFilter);
		error |= flib_ipc_append_message(tempvector, "e$mapgen %i", map->mapgen);

		if(map->mapgen == MAPGEN_MAZE) {
			error |= flib_ipc_append_message(tempvector, "e$maze_size %i", map->mazeSize);
		}
		if(map->mapgen == MAPGEN_DRAWN) {
			/*
			 * We have to split the drawn map data into several edraw messages here because
			 * it can be longer than the maximum message size.
			 */
			const char *edraw = "edraw ";
			int edrawlen = strlen(edraw);
			for(int offset=0; offset<map->drawDataSize; offset+=200) {
				int bytesRemaining = map->drawDataSize-offset;
				int fragmentsize = bytesRemaining < 200 ? bytesRemaining : 200;
				uint8_t messagesize = edrawlen + fragmentsize;
				error |= flib_vector_append(tempvector, &messagesize, 1);
				error |= flib_vector_append(tempvector, edraw, edrawlen);
				error |= flib_vector_append(tempvector, map->drawData+offset, fragmentsize);
			}
		}

		if(!log_e_if(error, "Error generating map config")) {
			// Message created, now we can copy everything.
			flib_constbuffer constbuf = flib_vector_as_constbuffer(tempvector);
			if(!flib_vector_append(vec, constbuf.data, constbuf.size)) {
				result = 0;
			}
		}
	}
	flib_vector_destroy(tempvector);
	return result;
}

int flib_ipc_append_seed(flib_vector *vec, const char *seed) {
	if(!log_badparams_if(!vec || !seed)) {
		return flib_ipc_append_message(vec, "eseed %s", seed);
	}
	return -1;
}

int flib_ipc_append_script(flib_vector *vec, const char *script) {
	int result = -1;
	char *copy = flib_strdupnull(script);
	if(!log_badparams_if(!vec) && copy) {
		if(!strcmp("Normal", copy)) {
			// "Normal" means no gametype script
			result = 0;
		} else {
			size_t len = strlen(copy);
			for(size_t i=0; i<len; i++) {
				if(copy[i] == ' ') {
					copy[i] = '_';
				}
			}

			result = flib_ipc_append_message(vec, "escript %s%s.lua", MULTIPLAYER_SCRIPT_PATH, copy);
		}
	}
	free(copy);
	return result;
}

uint32_t buildModFlags(const flib_cfg *scheme) {
	uint32_t result = 0;
	for(int i=0; i<scheme->meta->modCount; i++) {
		if(scheme->mods[i]) {
			int bitmaskIndex = scheme->meta->mods[i].bitmaskIndex;
			result |= (UINT32_C(1) << bitmaskIndex);
		}
	}
	return result;
}

int flib_ipc_append_gamescheme(flib_vector *vec, const flib_cfg *scheme) {
	int result = -1;
	flib_vector *tempvector = flib_vector_create();
	if(!log_badparams_if(!vec || !scheme) && tempvector) {
		const flib_cfg_meta *meta = scheme->meta;
		bool error = false;
		error |= flib_ipc_append_message(tempvector, "e$gmflags %"PRIu32, buildModFlags(scheme));
		for(int i=0; i<meta->settingCount; i++) {
			if(meta->settings[i].engineCommand) {
				int value = scheme->settings[i];
				if(meta->settings[i].maxMeansInfinity) {
					value = value>=meta->settings[i].max ? 9999 : value;
				}
				if(meta->settings[i].times1000) {
					value *= 1000;
				}
				error |= flib_ipc_append_message(tempvector, "%s %i", meta->settings[i].engineCommand, value);
			}
		}

		if(!error) {
			// Message created, now we can copy everything.
			flib_constbuffer constbuf = flib_vector_as_constbuffer(tempvector);
			if(!flib_vector_append(vec, constbuf.data, constbuf.size)) {
				result = 0;
			}
		}
	}
	flib_vector_destroy(tempvector);
	return result;
}

static int appendWeaponSet(flib_vector *vec, flib_weaponset *set) {
	return flib_ipc_append_message(vec, "eammloadt %s", set->loadout)
		|| flib_ipc_append_message(vec, "eammprob %s", set->crateprob)
		|| flib_ipc_append_message(vec, "eammdelay %s", set->delay)
		|| flib_ipc_append_message(vec, "eammreinf %s", set->crateammo);
}

int flib_ipc_append_addteam(flib_vector *vec, const flib_team *team, bool perHogAmmo, bool noAmmoStore) {
	int result = -1;
	flib_vector *tempvector = flib_vector_create();
	if(!log_badparams_if(!vec || !team) && tempvector) {
		bool error = false;

		if(!perHogAmmo && !noAmmoStore) {
			error = error
					|| appendWeaponSet(tempvector, team->hogs[0].weaponset)
					|| flib_ipc_append_message(tempvector, "eammstore");
		}

		// TODO
		char *hash = team->ownerName ? team->ownerName : "00000000000000000000000000000000";
		if(team->colorIndex<0 || team->colorIndex>=flib_teamcolor_defaults_len) {
			flib_log_e("Color index out of bounds for team %s: %i", team->name, team->colorIndex);
			error = true;
		} else {
			error |= flib_ipc_append_message(tempvector, "eaddteam %s %"PRIu32" %s", hash, flib_teamcolor_defaults[team->colorIndex], team->name);
		}

		if(team->remoteDriven) {
			error |= flib_ipc_append_message(tempvector, "erdriven");
		}

		error |= flib_ipc_append_message(tempvector, "egrave %s", team->grave);
		error |= flib_ipc_append_message(tempvector, "efort %s", team->fort);
		error |= flib_ipc_append_message(tempvector, "evoicepack %s", team->voicepack);
		error |= flib_ipc_append_message(tempvector, "eflag %s", team->flag);

		for(int i=0; i<team->bindingCount; i++) {
			error |= flib_ipc_append_message(tempvector, "ebind %s %s", team->bindings[i].binding, team->bindings[i].action);
		}

		for(int i=0; i<team->hogsInGame; i++) {
			if(perHogAmmo && !noAmmoStore) {
				error |= appendWeaponSet(tempvector, team->hogs[i].weaponset);
			}
			error |= flib_ipc_append_message(tempvector, "eaddhh %i %i %s", team->hogs[i].difficulty, team->hogs[i].initialHealth, team->hogs[i].name);
			error |= flib_ipc_append_message(tempvector, "ehat %s", team->hogs[i].hat);
		}

		if(!error) {
			// Message created, now we can copy everything.
			flib_constbuffer constbuf = flib_vector_as_constbuffer(tempvector);
			if(!flib_vector_append(vec, constbuf.data, constbuf.size)) {
				result = 0;
			}
		}
	}
	flib_vector_destroy(tempvector);
	return result;
}

static bool getGameMod(const flib_cfg *conf, const char *name) {
	for(int i=0; i<conf->meta->modCount; i++) {
		if(!strcmp(conf->meta->mods[i].name, name)) {
			return conf->mods[i];
		}
	}
	flib_log_e("Unable to find game mod %s", name);
	return false;
}

int flib_ipc_append_fullconfig(flib_vector *vec, const flib_gamesetup *setup, bool netgame) {
	int result = -1;
	flib_vector *tempvector = flib_vector_create();
	if(!log_badparams_if(!vec || !setup) && tempvector) {
		bool error = false;
		bool perHogAmmo = false;
		bool sharedAmmo = false;

		error |= flib_ipc_append_message(vec, netgame ? "TN" : "TL");
		if(setup->map) {
			error |= flib_ipc_append_mapconf(tempvector, setup->map, false);
		}
		if(setup->script) {
			error |= flib_ipc_append_script(tempvector, setup->script);
		}
		if(setup->gamescheme) {
			error |= flib_ipc_append_gamescheme(tempvector, setup->gamescheme);
			sharedAmmo = getGameMod(setup->gamescheme, "sharedammo");
			// Shared ammo has priority over per-hog ammo
			perHogAmmo = !sharedAmmo && getGameMod(setup->gamescheme, "perhogammo");
		}
		if(setup->teamlist->teams && setup->teamlist->teamCount>0) {
			int *clanColors = flib_calloc(setup->teamlist->teamCount, sizeof(int));
			if(!clanColors) {
				error = true;
			} else {
				int clanCount = 0;
				for(int i=0; !error && i<setup->teamlist->teamCount; i++) {
					flib_team *team = setup->teamlist->teams[i];
					// Find the clan index of this team (clans are identified by color).
					bool newClan = false;
					int clan = 0;
					while(clan<clanCount && clanColors[clan] != team->colorIndex) {
						clan++;
					}
					if(clan==clanCount) {
						newClan = true;
						clanCount++;
						clanColors[clan] = team->colorIndex;
					}

					// If shared ammo is active, only add an ammo store for the first team in each clan.
					bool noAmmoStore = sharedAmmo&&!newClan;
					error |= flib_ipc_append_addteam(tempvector, setup->teamlist->teams[i], perHogAmmo, noAmmoStore);
				}
			}
			free(clanColors);
		}
		error |= flib_ipc_append_message(tempvector, "!");

		if(!error) {
			// Message created, now we can copy everything.
			flib_constbuffer constbuf = flib_vector_as_constbuffer(tempvector);
			if(!flib_vector_append(vec, constbuf.data, constbuf.size)) {
				result = 0;
			}
		}
	}
	return result;
}