/* Copyright (C) 2021 Wildfire Games.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

// Note: This used to use BFD to get more useful debugging information.
// (See SVN r8270 if you want that code.)
// That requires binutils at runtime, which hits some bugs and library versioning
// issues on some Linux distros.
// The debugging info reported by this code with BFD wasn't especially useful,
// and it's easy enough to get people to run in gdb if we want a proper backtrace.
// So we now go with the simple approach of not using BFD.

#include "precompiled.h"

#include "lib/sysdep/sysdep.h"
#include "lib/debug.h"

#include <algorithm>
#include <cstring>
#include <sys/syscall.h>

#if OS_ANDROID

// Android NDK doesn't support backtrace()
// TODO: use unwind.h or similar?

void* debug_GetCaller(void* UNUSED(context), const wchar_t* UNUSED(lastFuncToSkip))
{
	return NULL;
}

Status debug_DumpStack(wchar_t* UNUSED(buf), size_t UNUSED(max_chars), void* UNUSED(context), const wchar_t* UNUSED(lastFuncToSkip))
{
	return ERR::NOT_SUPPORTED;
}

Status debug_ResolveSymbol(void* UNUSED(ptr_of_interest), wchar_t* UNUSED(sym_name), wchar_t* UNUSED(file), int* UNUSED(line))
{
	return ERR::NOT_SUPPORTED;
}

#else

#include <execinfo.h>

void* debug_GetCaller(void* UNUSED(context), const wchar_t* UNUSED(lastFuncToSkip))
{
	// bt[0] == this function
	// bt[1] == our caller
	// bt[2] == the first caller they are interested in
	// HACK: we currently don't support lastFuncToSkip (would require debug information),
	// instead just returning the caller of the function calling us
	void *bt[3];
	int bt_size = backtrace(bt, 3);
	if (bt_size < 3)
	    return NULL;
	return bt[2];
}

Status debug_DumpStack(wchar_t* buf, size_t max_chars, void* UNUSED(context), const wchar_t* UNUSED(lastFuncToSkip))
{
	static const size_t N_FRAMES = 16;
	void *bt[N_FRAMES];
	int bt_size = 0;
	wchar_t *bufpos = buf;
	wchar_t *bufend = buf + max_chars;

	bt_size = backtrace(bt, ARRAY_SIZE(bt));

	// Assumed max length of a single print-out
	static const size_t MAX_OUT_CHARS = 1024;

	for (size_t i = 0; (int)i < bt_size && bufpos+MAX_OUT_CHARS < bufend; i++)
	{
		wchar_t file[DEBUG_FILE_CHARS];
		wchar_t symbol[DEBUG_SYMBOL_CHARS];
		int line;
		int len;

		if (debug_ResolveSymbol(bt[i], symbol, file, &line) == 0)
		{
			if (file[0])
				len = swprintf(bufpos, MAX_OUT_CHARS, L"(%p) %ls:%d %ls\n", bt[i], file, line, symbol);
			else
				len = swprintf(bufpos, MAX_OUT_CHARS, L"(%p) %ls\n", bt[i], symbol);
		}
		else
		{
			len = swprintf(bufpos, MAX_OUT_CHARS, L"(%p)\n", bt[i]);
		}

		if (len < 0)
		{
			// MAX_OUT_CHARS exceeded, realistically this was caused by some
			// mindbogglingly long symbol name... replace the end with an
			// ellipsis and a newline
			memcpy(&bufpos[MAX_OUT_CHARS-6], L"...\n", 5*sizeof(wchar_t));
			len = MAX_OUT_CHARS;
		}

		bufpos += len;
	}

	return INFO::OK;
}

Status debug_ResolveSymbol(void* ptr_of_interest, wchar_t* sym_name, wchar_t* file, int* line)
{
	if (sym_name)
		*sym_name = 0;
	if (file)
		*file = 0;
	if (line)
		*line = 0;

	char** symbols = backtrace_symbols(&ptr_of_interest, 1);
	if (symbols)
	{
		swprintf_s(sym_name, DEBUG_SYMBOL_CHARS, L"%hs", symbols[0]);
		free(symbols);

		// (Note that this will usually return a pretty useless string,
		// because we compile with -fvisibility=hidden and there won't be
		// any exposed symbols for backtrace_symbols to report.)

		return INFO::OK;
	}
	else
	{
		return ERR::FAIL;
	}
}

#endif

/* This is basically a reimplementation of the pthread_setname_np() glibc
 * function, to make it work on every Linux distribution, no matter the libc
 * used.
 *
 * The thread name limit is 16 (including the terminating null byte) on Linux,
 * so we have to cut the provided name at 15 bytes.
 *
 * This API exists since Linux 2.6.33, on older kernels the user will just not
 * get thread names.
 */
void debug_SetThreadName(const char* name)
{
	constexpr size_t MAX_THREAD_NAME_LEN = 15;
	constexpr size_t MAX_FILE_PATH_LEN = 32;

	char pathname[MAX_FILE_PATH_LEN];
	pid_t tid = syscall(SYS_gettid);
	snprintf(pathname, MAX_FILE_PATH_LEN, "/proc/self/task/%d/comm", tid);

	FILE* comm = fopen(pathname, "w");
	if (!comm)
		return;

	std::string limited_name(name, std::min(strlen(name), MAX_THREAD_NAME_LEN));
	fputs(limited_name.c_str(), comm);
	fclose(comm);
}