#include <stdio.h>

#include <unistd.h>

#include <dlfcn.h>

#include <math.h>

#include "gdc.h"

#include "GameConfigs.h"

#include "MemoryUtils.h"

MemoryUtils mu;

char *game = NULL;

char *engine = NULL;

char *binary = NULL;

int main(int argc, char **argv)

{

	char *gamedata = NULL;

	bool debug = false;

	opterr = 0;

	int opt;

	while ((opt = getopt(argc, argv, "b:de:f:g:")) != -1)

		switch (opt)

		{

			case 'd':

				debug = true;

				break;

			case 'g':

				game = optarg;

				break;

			case 'e':

				engine = optarg;

				break;

			case 'f':

				gamedata = optarg;

				break;

			case 'b':

				binary = optarg;

				break;

			case '?':

				printf("Usage: ./gdc -g <game> -e <engine> -f <gamedata file> -b <binary>\n");

				return 0;

			default:

				printf("WHAT\n");

				return 0;

		}

	if (!game || !engine || !gamedata || !binary)

	{

		printf("Usage: ./gdc -g <game> -e <engine> -f <gamedata file> -b <binary>\n");

		return 0;

	}

	printf("Game: %s\nEngine: %s\nGamedata: %s\nBinary: %s\n", game, engine, gamedata, binary);

	void *handle = dlopen(binary, RTLD_LAZY);

	if (!handle)

	{

		printf("Couldn't open %s (%s)\n", binary, dlerror());

		return 0;

	}

	CGameConfig gc;

	char err[512];

	if (!gc.EnterFile(gamedata, err, sizeof(err)))

	{

		printf("%s: %s\n", gamedata, err);

		return 0;

	}

	CGameConfig symbols;

	if (!symbols.EnterFile("symbols.txt", err, sizeof(err)))

	{

		printf("symbols.txt: %s\n", err);

		return 0;

	}

	if (debug)

		for (map<const char*, const char*, cmp_str>::iterator it = symbols.m_Keys.begin(); it != symbols.m_Keys.end(); it++)

			printf("%s - %s\n", it->first, it->second);

	const char *vtsym = symbols.GetKeyValue("vtsym");

	if (!vtsym)

	{

		printf("Couldn't find vtsym\n");

		return 0;

	}

#if 0

	void *lolwhat = (void*)1;

	void *handle = lolwhat;

	handle = dlopen(binary, RTLD_LAZY);

	if (!handle)

	{

		printf("Couldn't open %s\n", binary);

		return 0;

	}

#endif

	void **vt = (void**) mu.ResolveSymbol(handle, vtsym);

	if (!vt)

	{

		printf("Couldn't find vtable %s\n", vtsym);

		dlclose(handle);

		return 0;

	}

	for (list<Offset>::iterator it = gc.m_Offsets.begin(); it != gc.m_Offsets.end(); it++)

	{

		if (debug) printf("DEBUG %s - l: %d w: %d\n", it->name, it->lin, it->win);

//		else

		{

			const char *symbol = symbols.GetKeyValue(it->name);

			if (symbol)

			{

				int offset = findVFunc(handle, vt, symbol);

				if (offset == it->lin) printf("%s - good\n", it->name);

				else printf("%s - l: %d w: %d\n", it->name, offset, offset + it->lin - it->win);

			}

			else printf("%s - no Linux symbol, skipping\n", it->name);

		}

	}

	printf("\nWindows offsets are wild guesses!\n\n");

	for (list<Sig>::iterator it = gc.m_Sigs.begin(); it != gc.m_Sigs.end(); it++)

	{

		if (debug) printf("DEBUG %s - %s - l: %s\n", it->name, it->lib == Server ? "server" : "engine", it->lin);

//		else

		{

			if (it->lib != Server)

			{

				printf("%s - isn't server, skipping\n", it->name);

				continue;

			}

			const char *symbol = it->lin;

			if (!symbol) 

			{

				printf("%s - no Linux symbol, skipping\n", it->name);

				continue;

			}

			if (symbol[0] != '@')

			{

				printf("%s - didn't start with '@', skipping\n", it->name);

				continue;

			}

			void *addr = mu.ResolveSymbol(handle, symbol + 1);

			if (addr) printf("%s - good\n", it->name);

			else printf("%s - %s not found\n", it->name, it->lin);

		}

	}

	return 0;

}

/* 

   takes a mangled member function symbol and returns the position where the function name and parameters start

   01234567890123456789012345678

   _ZN9CTFPlayer12ForceRespawnEv

                ^13            ^28

*/

void findFuncPos(const char *sym, int &func, int &params)

{

	int i = 0;

	while ((sym[i] < '0') || (sym[i] > '9')) i++;

	int classLen = atoi(sym + i);

	func = i + (int)ceil(log10(classLen)) + classLen;

	int funcLen = atoi(sym + func);

	params = func + (int)ceil(log10(funcLen)) + funcLen;

}

int findVFunc(void *handle, void **vt, const char *symbol)

{

	int offset = 1;

	//int overloads = 0;

	int funcPos, paramPos;

	findFuncPos(symbol, funcPos, paramPos);

	for (int i = 0; i < 1000; i++)

	{

		void *pFunc = vt[i];

		const char *s;

//		Dl_info info;

//		if (!mu.ResolveAddr(pFunc, &info)) continue;

		if (!(s = mu.ResolveAddr(handle, pFunc))) continue;

//		if ((i > 1) && (strncmp(info.dli_sname, "_ZTI", 4) == 0)) break;

		if ((i > 1) && (strncmp(s, "_ZTI", 4) == 0)) break;

		int tempFuncPos, tempParamPos;

//		findFuncPos(info.dli_sname, tempFuncPos, tempParamPos);

		findFuncPos(s, tempFuncPos, tempParamPos);

#if 0

		if (strncmp(info.dli_sname[tempFuncPos], symbol[funcPos], paramPos - funcPos) == 0)

		{

			overloads++;

			if (firstOverload == -1) firstOverload = i - 1;

			if (strncmp(info.dli_sname[tempParamPos], symbol[paramPos], strlen(symbol) - paramPos) == 0)

			{

				offset = i;

				matchingOverload = overloads;

			}

		}

#else

//		if (strcmp(info.dli_sname + tempFuncPos, symbol + funcPos) == 0)

		if (strcmp(s + tempFuncPos, symbol + funcPos) == 0)

		{

			offset = i;

			break;

		}

#endif

	}

	return offset - 2;

}

unsigned int strncopy(char *dest, const char *src, size_t count)

{

	if (!count)

	{

		return 0;

	}

	char *start = dest;

	while ((*src) && (--count))

	{

		*dest++ = *src++;

	}

	*dest = '\0';

	return (dest - start);

}

size_t UTIL_Format(char *buffer, size_t maxlength, const char *fmt, ...)

{

	va_list ap;

	va_start(ap, fmt);

	size_t len = vsnprintf(buffer, maxlength, fmt, ap);

	va_end(ap);

	if (len >= maxlength)

	{

		buffer[maxlength - 1] = '\0';

		return (maxlength - 1);

	}

	else

	{

		return len;

	}

}