#include <stdio.h>

#include <unistd.h>

#include <dlfcn.h>

#include <fcntl.h>

#include <math.h>

#include "gdc.h"

#include "GameConfigs.h"

#include "MemoryUtils.h"

MemoryUtils mu;

char *game = NULL;

char *engine = NULL;

char *game_binary = NULL;

char *engine_binary = NULL;

char *wgame_binary = NULL;

char *wengine_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:x:w:y:")) != -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':

				game_binary = optarg;

				break;

			case 'x':

				engine_binary = optarg;

				break;

			case 'w':

				wgame_binary = optarg;

				break;

			case 'y':

				wengine_binary = optarg;

				break;

			case '?':

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

				return 0;

			default:

				printf("WHAT\n");

				return 0;

		}

	if (!game || !engine || !gamedata || !game_binary || !engine_binary || !wgame_binary || !wengine_binary)

	{

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

		return 0;

	}

	printf("Game: %s\n", game);

	if (debug)

	{

		printf("Engine: %s\nGame binary: %s\nEngine binary: %s\nWin game binary: %s\nWin engine binary: %s\n",

			engine, game_binary, engine_binary, wgame_binary, wengine_binary

			);

	}

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

	void *ghandle;

	ghandle = dlopen(game_binary, RTLD_LAZY);

	if (!ghandle)

	{

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

			return 0;

	}

	void *ehandle;

	ehandle = dlopen(engine_binary, RTLD_LAZY);

	if (!ehandle)

	{

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

			return 0;

	}

	int wgfile = open(wgame_binary, O_RDONLY);

	if (wgfile == -1)

	{

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

		return 0;

	}

	int wefile = open(wengine_binary, O_RDONLY);

	if (wefile == -1)

	{

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

		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;

	}

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

	if (!vtsym)

	{

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

		return 0;

	}

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

	if (!vt)

	{

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

		dlclose(ghandle);

		dlclose(ehandle);

		close(wgfile);

		close(wefile);

		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);

		}

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

		if (symbol)

		{

			int newOffset;

			char symvt[128];

			strcpy(symvt, it->name);

			strcat(symvt, "_vt");

			const char *newvtsym = symbols.GetKeyValue(symvt);

			if (newvtsym && newvtsym[0])

			{

				void **newvt = (void**) mu.ResolveSymbol(ghandle, newvtsym);

			        if (!newvt)

				{

					printf("O: %-22s - can't find, skipping\n", symvt);

					continue;

				}

				newOffset = findVFunc(ghandle, newvt, symbol);

			}

			else

			{

				newOffset = findVFunc(ghandle, vt, symbol);

			}

			if (newOffset == it->lin)

			{

				printf("O: %-22s - GOOD.    current [ w: %3d, l: %3d ].\n", it->name, it->win, it->lin);

			}

			else

			{

				printf("O: %-22s - CHANGED. old [ w: %3d, l: %3d ]. new [ w: %3d, l: %3d ].\n",

					it->name,

					it->win, it->lin,

					newOffset - (it->lin - it->win), newOffset

					);

			}

		}

		else // !symbol

		{

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

		}

	}

	printf("\nWindows offsets are (semi-)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);

		}

		const char *linSymbol = it->lin;

		const char *winSymbol = it->win;

		bool hasLinux   = (linSymbol && linSymbol[0]);

		bool hasWindows = (winSymbol && winSymbol[0]);

		if (!hasLinux && !hasWindows)

		{

			printf("S: %-22s - hasn't linux nor windows data, skipping\n", it->name);

			continue;

		}

		int  winFile;

		void *linHandle;

		if (it->lib == Server)

		{

			winFile   = wgfile;

			linHandle = ghandle;

		}

		else if (it->lib == Engine)

		{

			winFile   = wefile;

			linHandle = ehandle;

		}

		else

		{

			printf("S: %-22s - isn't from server nor engine, skipping\n", it->name);

			continue;

		}

		bool foundLinux   = (!hasLinux   || checkSigStringL(linHandle, linSymbol));

		bool foundWindows = (!hasWindows || checkSigStringW(winFile,   winSymbol));

		// Prepare for ternery ABUSE

		if (foundLinux && foundWindows)

		{

			// too much clutter to print current data if it matches anyway, unlike with offsets

			/*

			printf("%-22s (%s) - GOOD. current:\n\t[w:%s]\n\t[l:%s]\n",

				it->name,

				(it->lib == Server) ? "server" : "engine",

				winSymbol ? winSymbol : "",

				linSymbol ? linSymbol : ""

				);

			*/

			printf("S: %-22s (%s) - GOOD.\n",

				it->name,

				(it->lib == Server) ? "server" : "engine"

				);

		}

		else

		{

			// extra \n at end is intentional to add buffer after possibly long sigs

			printf("S: %-22s (%s) - w: %s - l: %s\n%s%s%s%s%s%s%s%s\n",

					it->name,

					(it->lib == Server) ? "server" : "engine",

					hasWindows ? (foundWindows ? "GOOD" : "CHANGED") : "UNKNOWN",

					hasLinux   ? (foundLinux   ? "GOOD" : "CHANGED") : "UNKNOWN",

					hasWindows ? "\tcurrent - w: " : "",

					(hasWindows && foundWindows) ? "    (found) \"" : (hasWindows ? "(NOT found) \"" : ""),

					(hasWindows && winSymbol)  ? winSymbol : "",

					hasWindows ? "\"\n" : "",

					hasLinux ? "\tcurrent - l: " : "",

					(hasLinux && foundLinux) ? "    (found) \"" : (hasLinux ? "(NOT found) \"" : ""),

					(hasLinux && linSymbol)  ? linSymbol : "",

					hasLinux ? "\"\n" : ""

					);

		}

		//  j/k, no way that anyone could have been prepared for that

	}

	return 0;

}

bool checkSigStringW(int file, const char* symbol)

{

	void *addr = NULL;

	bool isAt = (symbol[0] == '@');

	// we can't support this on windows from here

	if (isAt)

		return false;

	unsigned char real_sig[511];

	size_t real_bytes = UTIL_DecodeHexString(real_sig, sizeof(real_sig), symbol);

	if (real_bytes >= 1)

	{

		addr = mu.FindPatternInFile(file, (char*)real_sig, real_bytes);

	}

	if (addr)

		return true;

	return false;

}

bool checkSigStringL(void *handle, const char* symbol)

{

	void *addr = NULL;

	bool isAt = (symbol[0] == '@');

	if (isAt)

	{

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

	}

	else

	{

		unsigned char real_sig[511];

		size_t real_bytes = UTIL_DecodeHexString(real_sig, sizeof(real_sig), symbol);

		if (real_bytes >= 1)

		{

			addr = mu.FindPattern(handle, (char*)real_sig, real_bytes);

		}

	}

	if (addr)

		return true;

	return false;

}

/* 

   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 funcPos, paramPos;

	findFuncPos(symbol, funcPos, paramPos);

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

	{

		void *pFunc = vt[i];

		const char *s;

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

			continue;

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

			break;

		int tempFuncPos, tempParamPos;

		findFuncPos(s, tempFuncPos, tempParamPos);

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

		{

			offset = i;

			break;

		}

	}

	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;

	}

}

size_t UTIL_DecodeHexString(unsigned char *buffer, size_t maxlength, const char *hexstr)

{

	size_t written = 0;

	size_t length = strlen(hexstr);

	for (size_t i = 0; i < length; i++)

	{

		if (written >= maxlength)

			break;

		buffer[written++] = hexstr[i];

		if (hexstr[i] == '\\' && hexstr[i + 1] == 'x')

		{

			if (i + 3 >= length)

				continue;

			/* Get the hex part. */

			char s_byte[3];

			int r_byte;

			s_byte[0] = hexstr[i + 2];

			s_byte[1] = hexstr[i + 3];

			s_byte[2] = '\0';

			/* Read it as an integer */

			sscanf(s_byte, "%x", &r_byte);

			/* Save the value */

			buffer[written - 1] = r_byte;

			/* Adjust index */

			i += 3;

		}

	}

	return written;

}