#include <array>
#include <cstdint>
#include <exception>
#include <stdexcept>
#include <windows.h>
#include <rpc.h>
#ifdef DXX_ENABLE_WINDOWS_MINIDUMP
#include <dbghelp.h>
#endif
#include "vers_id.h"

using path_buffer = std::array<wchar_t, MAX_PATH>;
void d_set_exception_handler();

namespace {

class RAII_Windows_FILE_HANDLE
{
	const HANDLE m_h;
public:
	RAII_Windows_FILE_HANDLE(HANDLE &&h) :
		m_h{h}
	{
	}
	~RAII_Windows_FILE_HANDLE()
	{
		if (*this)
			CloseHandle(m_h);
	}
	RAII_Windows_FILE_HANDLE(const RAII_Windows_FILE_HANDLE &) = delete;
	RAII_Windows_FILE_HANDLE &operator=(const RAII_Windows_FILE_HANDLE &) = delete;
	explicit operator bool() const
	{
		return m_h != INVALID_HANDLE_VALUE;
	}
	operator HANDLE() const
	{
		return m_h;
	}
};

class RAII_Windows_DynamicSharedObject
{
	HMODULE m_h;
	RAII_Windows_DynamicSharedObject(HMODULE &&h) :
		m_h{h}
	{
	}
	static RAII_Windows_DynamicSharedObject LoadInternal(std::array<wchar_t, MAX_PATH> &pathbuf, const unsigned lws, const wchar_t *const filename)
	{
		wcscpy(&pathbuf[lws], filename);
		return LoadLibraryW(pathbuf.data());
	}
public:
	~RAII_Windows_DynamicSharedObject()
	{
		if (*this)
			FreeLibrary(m_h);
	}
	RAII_Windows_DynamicSharedObject(const RAII_Windows_DynamicSharedObject &) = delete;
	RAII_Windows_DynamicSharedObject &operator=(const RAII_Windows_DynamicSharedObject &) = delete;
	RAII_Windows_DynamicSharedObject(RAII_Windows_DynamicSharedObject &&) = default;
	explicit operator bool() const
	{
		return m_h;
	}
	/*
	 * This leaks the loaded library.  It is used to ensure the library
	 * will still be loaded when the termination handler runs, long
	 * after this object has gone out of scope.
	 */
	void release()
	{
		m_h = nullptr;
	}
	template <std::size_t N>
		static RAII_Windows_DynamicSharedObject Load(std::array<wchar_t, MAX_PATH> &pathbuf, const unsigned lws, const wchar_t (&filename)[N])
		{
			if (lws >= MAX_PATH - N)
				return nullptr;
			return LoadInternal(pathbuf, lws, filename);
		}
	template <typename T>
		T *GetProc(const char *const proc) const
		{
			union {
				FARPROC gpa;
				T *result;
			};
			gpa = GetProcAddress(m_h, proc);
			return result;
		}
};

struct dxx_trap_context
{
	EXCEPTION_RECORD ExceptionRecord;
	CONTEXT ContextRecord;
	/* Pointer to the first inaccessible byte above the stack. */
	const uint8_t *end_sp;
};

}

#define DXX_REPORT_TEXT_FORMAT_UUID	"Format UUID: 0f7deda4-1122-4be8-97d5-afc91b7803d6"
#define DXX_REPORT_TEXT_LEADER_VERSION_PREFIX	"Rebirth version: x"
#define DXX_REPORT_TEXT_LEADER_BUILD_DATETIME	"Rebirth built: "
#define DXX_REPORT_TEXT_LEADER_EXCEPTION_MESSAGE	 "Exception message: "

constexpr unsigned dump_stack_bytes = 2048 * sizeof(void *);
constexpr unsigned dump_stack_stride = 16;

/*
 * This includes leading text describing the UUID, so it must be bigger
 * than a bare UUID would require.
 */
static std::array<char, 54> g_strctxuuid;
/*
 * These labels are defined in asm() statements to record the address at
 * which special instructions are placed.  The array size must match the
 * size of the assembly instruction.  See `vectored_exception_handler`
 * for how these are used.
 */
extern const char dxx_rebirth_veh_ud2[2], dxx_rebirth_veh_sp[2];

/*
 * 64 bit registers use an R prefix; 32 bit registers use an E prefix.
 * For this handler, they can be treated the same.  Use a macro to
 * expand to the proper name.
 *
 * Win32 uses a leading underscore on names, relative to the C name.
 * Win64 does not.  Use a macro to cover that difference.
 */
#ifdef WIN64
#define DXX_NT_CONTEXT_REGISTER(n)	R##n
#define DXX_ASM_LABEL(L)	"" L
#define DXX_WINDOWS_HOST_ARCH_W	L"64"
#define DXX_REPORT_TEXT_LEADER_VERSION	DXX_REPORT_TEXT_LEADER_VERSION_PREFIX "64"
#else
#define DXX_NT_CONTEXT_REGISTER(n)	E##n
#define DXX_ASM_LABEL(L)	"_" L
#define DXX_WINDOWS_HOST_ARCH_W	L"86"
#define DXX_REPORT_TEXT_LEADER_VERSION	DXX_REPORT_TEXT_LEADER_VERSION_PREFIX "86"
#endif

static LONG CALLBACK vectored_exception_handler(EXCEPTION_POINTERS *const ep)
{
	const auto ctx = ep->ContextRecord;
	auto &ip = ctx->DXX_NT_CONTEXT_REGISTER(ip);
	auto &ax = ctx->DXX_NT_CONTEXT_REGISTER(ax);
	const auto t = reinterpret_cast<dxx_trap_context *>(ax);
	/*
	 * If the fault address is dxx_rebirth_veh_ud2, this is an expected
	 * fault forced solely to capture register context.  This fault must
	 * always happen.
	 */
	if (ip == reinterpret_cast<uintptr_t>(dxx_rebirth_veh_ud2))
	{
		/*
		 * Copy the captured data into the faulting function's local
		 * variable.  The address of that local was loaded into ax before
		 * triggering the fault.
		 */
		t->ExceptionRecord = *ep->ExceptionRecord;
		t->ContextRecord = *ctx;
		/* Step past the faulting instruction. */
		ip += sizeof(dxx_rebirth_veh_ud2);
		return EXCEPTION_CONTINUE_EXECUTION;
	}
	/*
	 * If the fault address is dxx_rebirth_veh_sp, this is an expected
	 * fault triggered by scanning up off the top of the stack.  This
	 * fault usually happens, but might not if the exception happened
	 * with a sufficiently deep stack.
	 */
	else if (ip == reinterpret_cast<uintptr_t>(dxx_rebirth_veh_sp))
	{
		/*
		 * The faulting function arranged for ax to hold the terminating
		 * address of the search and for bx to hold the currently tested
		 * address.  When the fault happens, bx points to an
		 * inaccessible byte.  Set ax to point to that byte.  Decrement
		 * bx to counter the guaranteed increment in the faulting
		 * function.  The combination of these changes ensures that the
		 * (current != end) test fails, terminating the loop without
		 * provoking an additional fault.
		 */
		ax = ctx->DXX_NT_CONTEXT_REGISTER(bx)--;
		/* Step past the faulting instruction. */
		ip += sizeof(dxx_rebirth_veh_sp);
		return EXCEPTION_CONTINUE_EXECUTION;
	}
	return EXCEPTION_CONTINUE_SEARCH;
}

/* Ensure gcc does not clone the inline labels */
__attribute__((__noinline__,__noclone__,__warn_unused_result__))
static void *capture_exception_context(dxx_trap_context &dtc, const uint8_t *const sp)
{
	const auto handler = AddVectoredExceptionHandler(1, &vectored_exception_handler);
	if (handler)
	{
		dtc = {};
		/*
		 * This block guarantees at least one and at most two faults to
		 * occur.  Run it only if an exception handler was successfully
		 * added to catch these faults.
		 */
		asm volatile(
DXX_ASM_LABEL("dxx_rebirth_veh_ud2") ":\n"
/*
 * Force a fault by executing a guaranteed undefined instruction.  The
 * fault handler will capture register context for a minidump, then step
 * past this instruction.
 *
 * Before the fault, store the address of the `dxx_trap_context`
 * instance `dtc` into ax for easy access by the fault handler.  The
 * fault handler then initializes dtc from the captured data.  Mark
 * memory as clobbered to prevent any speculative caching of `dtc`
 * across the asm block.  A narrower clobber could be used, but "memory"
 * is sufficient and this code is not performance critical.
 */
"	ud2\n"
			:: "a" (&dtc) : "memory"
		);
		auto p = reinterpret_cast<uintptr_t>(sp);
		for (auto e = p + dump_stack_bytes; p != e; ++p)
			asm volatile(
DXX_ASM_LABEL("dxx_rebirth_veh_sp") ":\n"
/*
 * Force a read of the address pointed at by [sp].  This must be done in
 * assembly, not through a volatile C read, because the vectored
 * exception handler must know the specific address of the read
 * instruction.
 *
 * This may fault if the stack is not sufficiently deep.  If a fault
 * happens, the fault handler will adjust `e` and `p`, then step past
 * the compare (although stepping past is not strictly necessary).  On
 * resume from the fault, the loop will find that the adjusted values
 * make `++p` == `e`, causing the loop to terminate.
 */
"	cmpb %%al,(%[sp])\n"
				: "+a" (e),
				[sp] "+b" (p)
				:: "cc"
			);
		/*
		 * Save the address of the first inaccessible byte, rounded down
		 * to the nearest paragraph.
		 */
		dtc.end_sp = reinterpret_cast<const uint8_t *>(p & -dump_stack_stride);
		RemoveVectoredExceptionHandler(handler);
	}
	return handler;
}
#undef DXX_ASM_LABEL

/*
 * Initialize `path` with a path suitable to be used to write a minidump
 * for the exception.  Initialize `filename` to point to the first
 * character in the filename (bypassing the directories).
 */
static unsigned prepare_exception_log_path(path_buffer &path, wchar_t *&filename, const unsigned pid)
{
	const auto l = GetTempPathW(path.size(), path.data());
	SYSTEMTIME st{};
	GetSystemTime(&st);
	/*
	 * Subsecond precision is not required.  The program will terminate
	 * after writing this dump.  No user is likely to be able to restart
	 * the game, and provoke a second dump, and on the same PID, within
	 * the same second.
	 */
	const auto r = l + _snwprintf(filename = path.data() + l, path.size() - l, L"%.4u-%.2u-%.2u-%.2u-%.2u-%.2u x" DXX_WINDOWS_HOST_ARCH_W L" P%u %hs.elog", st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond, pid, g_descent_version);
	const auto extension = path.data() + r - 5;
	wchar_t *p;
	/*
	 * NTFS does not allow star in filenames.  The expected content of
	 * this part of the filename will never contain an 's', so replace
	 * '*' with 's'.  The filename will contain at most one star, but
	 * possibly none if the version string reported no unstaged changes.
	 * The position of the star varies depending on whether the version
	 * string also included a plus to report staged uncommitted changes.
	 */
	if (*(p = &extension[-1]) == '*' ||
		*(p = &extension[-2]) == '*')
		*p = 's';
	return r;
}

#ifdef DXX_ENABLE_WINDOWS_MINIDUMP
using MiniDumpWriteDump_type = decltype(MiniDumpWriteDump);
static MiniDumpWriteDump_type *g_pMiniDumpWriteDump;

/*
 * Write a minidump to the open file `h`, reported as being from pid
 * `pid` with context from `dtc`.  If `what` is not empty, include it as
 * a comment stream.  The caller uses this to pass the exception text
 * (as returned by `std::exception::what()`) so that it will be easy to
 * find in the debugger.
 */
static void write_exception_dump(dxx_trap_context &dtc, const unsigned pid, const std::string &what, const HANDLE h, const MiniDumpWriteDump_type *const pMiniDumpWriteDump)
{
	MINIDUMP_EXCEPTION_INFORMATION mei;
	MINIDUMP_USER_STREAM_INFORMATION musi;
	EXCEPTION_POINTERS ep;
	ep.ContextRecord = &dtc.ContextRecord;
	ep.ExceptionRecord = &dtc.ExceptionRecord;
	mei.ThreadId = GetCurrentThreadId();
	mei.ExceptionPointers = &ep;
	mei.ClientPointers = 0;
	std::array<MINIDUMP_USER_STREAM, 5> mus;
	std::array<char, 92> musTextVersion;
	std::array<char, 44> musTextDateTime;
	std::array<char, 512> musTextExceptionMessage;
	unsigned UserStreamCount = 0;
	{
		auto &m = mus[UserStreamCount++];
		m.Type = MINIDUMP_STREAM_TYPE::CommentStreamA;
		static char leader[] = DXX_REPORT_TEXT_FORMAT_UUID;
		m.BufferSize = sizeof(leader);
		m.Buffer = leader;
	}
	{
		auto &m = mus[UserStreamCount++];
		m.Type = MINIDUMP_STREAM_TYPE::CommentStreamA;
		m.BufferSize = g_strctxuuid.size();
		m.Buffer = g_strctxuuid.data();
	}
	{
		auto &m = mus[UserStreamCount++];
		m.Type = MINIDUMP_STREAM_TYPE::CommentStreamA;
		m.Buffer = musTextVersion.data();
		m.BufferSize = 1 + std::snprintf(musTextVersion.data(), musTextVersion.size(), DXX_REPORT_TEXT_LEADER_VERSION " %s", g_descent_version);
	}
	{
		auto &m = mus[UserStreamCount++];
		m.Type = MINIDUMP_STREAM_TYPE::CommentStreamA;
		m.Buffer = musTextDateTime.data();
		m.BufferSize = 1 + std::snprintf(musTextDateTime.data(), musTextDateTime.size(), DXX_REPORT_TEXT_LEADER_BUILD_DATETIME "%s", g_descent_build_datetime);
	}
	if (!what.empty())
	{
		auto &m = mus[UserStreamCount++];
		m.Type = MINIDUMP_STREAM_TYPE::CommentStreamA;
		m.Buffer = musTextExceptionMessage.data();
		m.BufferSize = 1 + std::snprintf(musTextExceptionMessage.data(), musTextExceptionMessage.size(), DXX_REPORT_TEXT_LEADER_EXCEPTION_MESSAGE "%s", what.c_str());
	}
	musi.UserStreamCount = UserStreamCount;
	musi.UserStreamArray = mus.data();
	(*pMiniDumpWriteDump)(GetCurrentProcess(), pid, h, MiniDumpWithFullMemory, &mei, &musi, nullptr);
}

/*
 * Open the file named by `path` for write.  On success, call
 * `write_exception_dump` above with that handle.  On failure, clear the
 * path so that the later UI code does not tell the user about a file
 * that does not exist.
 */
static void write_exception_dump(dxx_trap_context &dtc, const unsigned pid, const std::string &what, path_buffer &path, const MiniDumpWriteDump_type *const pMiniDumpWriteDump)
{
	if (RAII_Windows_FILE_HANDLE h{CreateFileW(path.data(), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL)})
		write_exception_dump(dtc, pid, what, h, pMiniDumpWriteDump);
	else
		path.front() = 0;
}
#endif

/*
 * Write a plain text dump of metadata and a hex dump of the faulting
 * stack.
 */
static void write_exception_stack(const wchar_t *const filename, const unsigned pid, const uint8_t *const begin_sp, const dxx_trap_context &dtc, const std::string &what, const HANDLE h)
{
	std::array<char, 4096> buf;
	buf = {};
	const auto len_header_text = std::snprintf(buf.data(), buf.size(),
"Rebirth exception printed context\n"
DXX_REPORT_TEXT_FORMAT_UUID "\n"
"%.50s\n"
DXX_REPORT_TEXT_LEADER_VERSION " %s\n"
DXX_REPORT_TEXT_LEADER_BUILD_DATETIME "%s\n"
"Rebirth PID: %u\n"
"Report date-time: %.19ls\n"
DXX_REPORT_TEXT_LEADER_EXCEPTION_MESSAGE "\"%s\"\n"
"UD2 IP: %p\n"
"SP: %p\n"
"\n"
, g_strctxuuid.data(), g_descent_version, g_descent_build_datetime, pid, filename, what.c_str(), reinterpret_cast<const uint8_t *>(dtc.ContextRecord.DXX_NT_CONTEXT_REGISTER(ip)), begin_sp
);
	/*
	 * end_sp is rounded down to a paragraph boundary.
	 * Round sp the same way so that there will exist an integer N such
	 * that (`sp` + (N * `dump_stack_stride`)) == `end_sp`.
	 */
	const auto sp = reinterpret_cast<const uint8_t *>(reinterpret_cast<uintptr_t>(begin_sp) & -dump_stack_stride);
	DWORD dwWritten;
	WriteFile(h, buf.data(), len_header_text, &dwWritten, 0);
	const auto end_sp = dtc.end_sp;
	for (unsigned i = 0; i < dump_stack_bytes; i += dump_stack_stride)
	{
		char hexdump[dump_stack_stride + 1];
		const auto base_paragraph_pointer = &sp[i];
		if (base_paragraph_pointer == end_sp)
			break;
		hexdump[dump_stack_stride] = 0;
		for (unsigned j = dump_stack_stride; j--;)
		{
			const uint8_t c = reinterpret_cast<const uint8_t *>(base_paragraph_pointer)[j];
			hexdump[j] = (c >= ' ' && c <= '~') ? c : '.';
		}
		buf = {};
#define FORMAT_PADDED_UINT8_4	" %.2x %.2x %.2x %.2x "
#define VAR_PADDED_UINT8_4(I)	sp[I], sp[I + 1], sp[I + 2], sp[I + 3]
		const auto len_line_text = std::snprintf(buf.data(), buf.size(),
"%p:  " FORMAT_PADDED_UINT8_4 FORMAT_PADDED_UINT8_4 FORMAT_PADDED_UINT8_4 FORMAT_PADDED_UINT8_4 "    %s\n"
, base_paragraph_pointer, VAR_PADDED_UINT8_4(i), VAR_PADDED_UINT8_4(i + 4), VAR_PADDED_UINT8_4(i + 8), VAR_PADDED_UINT8_4(i + 12), hexdump);
#undef VAR_PADDED_UINT8_4
#undef FORMAT_PADDED_UINT8_4
		WriteFile(h, buf.data(), len_line_text, &dwWritten, 0);
	}
}

static void write_exception_stack(const wchar_t *const filename, const unsigned pid, const uint8_t *const sp, const dxx_trap_context &dtc, const std::string &what, path_buffer &path)
{
	if (RAII_Windows_FILE_HANDLE h{CreateFileW(path.data(), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL)})
		write_exception_stack(filename, pid, sp, dtc, what, h);
	else
		path.front() = 0;
}

/*
 * Prevent moving the large `dxx_trap_context` into the caller.
 * The caller captures the stack pointer before this function begins.
 * The captured value should exclude the locals of this function, so
 * that the data printed from the captured value covers the stack used
 * prior to the throw which triggered the terminate handler.  If this
 * function were inlined into the caller, the captured stack pointer
 * would include the locals of this function.
 */
__attribute__((__noinline__,__noclone__))
static void write_exception_logs(const uint8_t *const sp)
{
	std::string what;
	try {
		/*
		 * Rethrow the faulting exception, then catch it to extract its
		 * explanatory text.
		 */
		std::rethrow_exception(std::current_exception());
	} catch (const std::exception &ee) {
		what = ee.what();
	} catch (...) {
	}
#ifdef DXX_ENABLE_WINDOWS_MINIDUMP
	path_buffer path_dump;
#define DXX_PATH_DUMP_FORMAT_STRING	L"%s%s\n"
#define DXX_PATH_DUMP_ARGUMENTS	\
	, path_dump.front() ? L"If possible, make available the binary file:\n  " : L"No dump file could be generated."	\
	, path_dump.data()
#else
#define DXX_PATH_DUMP_FORMAT_STRING	\
	L"Dump file generation is not enabled in this build.\n"
#define DXX_PATH_DUMP_ARGUMENTS
#endif
	path_buffer path_stack;
	dxx_trap_context dtc;
	if (capture_exception_context(dtc, sp))
	{
		const unsigned pid = GetCurrentProcessId();
		wchar_t *filename;
		const auto pl = prepare_exception_log_path(path_stack, filename, pid);
#ifdef DXX_ENABLE_WINDOWS_MINIDUMP
		path_dump = path_stack;
		wcscpy(&path_dump[pl - 4], L"mdmp");
		if (const auto pMiniDumpWriteDump = g_pMiniDumpWriteDump)
			write_exception_dump(dtc, pid, what, path_dump, pMiniDumpWriteDump);
		else
			path_dump.front() = 0;
#else
		(void)pl;
#endif
		write_exception_stack(filename, pid, sp, dtc, what, path_stack);
	}
	else
	{
#ifdef DXX_ENABLE_WINDOWS_MINIDUMP
		path_dump.front() = 0;
#endif
		path_stack.front() = 0;
	}
	std::array<wchar_t, 1024> msg;
	_snwprintf(msg.data(), msg.size(),
L"Rebirth encountered a fatal error.  Please report this to the developers.\n"
L"\nInclude in your report:\n"
L"%s%hs%s"
L"* The level(s) played this session, including download URLs for any add-on missions\n"
L"%s%s\n\n"
DXX_PATH_DUMP_FORMAT_STRING
L"\nTo the extent possible, provide steps to reproduce, starting from the game main menu.",
what.empty() ? L"" : L"* The exception message text:\n  \"", what.c_str(), what.empty() ? L"" : L"\"\n",
path_stack.front() ? L"* The contents of the text file:\n  " : L"", path_stack.data()
DXX_PATH_DUMP_ARGUMENTS
);
#undef DXX_PATH_DUMP_ARGUMENTS
#undef DXX_PATH_DUMP_FORMAT_STRING
	MessageBoxW(NULL, msg.data(), L"Rebirth - Fatal Error", MB_ICONERROR | MB_TOPMOST | MB_TASKMODAL);
}

[[noreturn]]
static void terminate_handler()
{
	const uint8_t *sp;
	asm(
#ifdef WIN64
		"movq %%rsp, %[sp]"
#else
		"movl %%esp, %[sp]"
#endif
		: [sp] "=rm" (sp));
	write_exception_logs(sp);
	ExitProcess(0);
}

void d_set_exception_handler()
{
	std::set_terminate(&terminate_handler);
	std::array<wchar_t, MAX_PATH> ws;
	if (const auto lws = GetSystemDirectoryW(ws.data(), ws.size()))
	{
		if (auto &&rpcrt4 = RAII_Windows_DynamicSharedObject::Load(ws, lws, L"\\rpcrt4.dll"))
		{
			if (const auto pUuidCreate = rpcrt4.GetProc<decltype(UuidCreate)>("UuidCreate"))
			{
				UUID ctxuuid;
				/*
				 * Create a UUID specific to this run.
				 */
				if (SUCCEEDED((*pUuidCreate)(&ctxuuid)))
				{
					std::snprintf(g_strctxuuid.data(), g_strctxuuid.size(), "Context UUID: %08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x", ctxuuid.Data1, ctxuuid.Data2, ctxuuid.Data3, ctxuuid.Data4[0], ctxuuid.Data4[1], ctxuuid.Data4[2], ctxuuid.Data4[3], ctxuuid.Data4[4], ctxuuid.Data4[5], ctxuuid.Data4[6], ctxuuid.Data4[7]);
				}
			}
		}
#ifdef DXX_ENABLE_WINDOWS_MINIDUMP
		if (auto &&dbghelp = RAII_Windows_DynamicSharedObject::Load(ws, lws, L"\\dbghelp.dll"))
		{
			if ((g_pMiniDumpWriteDump = dbghelp.GetProc<decltype(MiniDumpWriteDump)>("MiniDumpWriteDump")))
				dbghelp.release();
		}
#endif
	}
}
