#include <sstream>

#ifdef WIN32
#include <Windows.h>
#include <DbgHelp.h>
#endif

#include "GLTB/exception.h"

namespace gltb {
	std::string Exception::asFormattedText()
	{
		std::ostringstream output;

		output << "Exception: " << getDescription() << std::endl;
		output << "In: " << getLocation();

		return output.str();
	}

#if defined LINUX

	TraceableException::TraceableException(std::string description, std::string location)
	: Exception(description, location)
	{
		exceptionTrace=new void*[300];
		exceptionTraceSize=backtrace(exceptionTrace,300);
	};

	TraceableException::~TraceableException()
	{
		delete[] exceptionTrace;
	}

	std::string TraceableException::getBacktrace()
	{
		std::string result;

		char **backtraceSymbols=backtrace_symbols(exceptionTrace,exceptionTraceSize);
		for(int i=0;i<exceptionTraceSize;i++) {
			result+=std::string(backtraceSymbols[i]) + "\n";
		}
		free(backtraceSymbols);

		return result;
	}

#elif defined WIN32

	TraceableException::TraceableException(std::string description, std::string location)
	: Exception(description, location)
	{
		analyzeStack();
	}

	TraceableException::~TraceableException()
	{
	}

	void outputSymbol(std::ostringstream &output, const HANDLE &processHandle, const STACKFRAME64 &stackFrame, SYMBOL_INFO_PACKAGE &symbol, IMAGEHLP_LINE64 &line)
	{
		if(SymFromAddr(processHandle,stackFrame.AddrPC.Offset,0,&symbol.si)) {
			output << symbol.si.Name;
			if(SymGetLineFromAddr64(processHandle,stackFrame.AddrPC.Offset,0,&line)) {
				output << " (" << line.FileName << ":" << line.LineNumber << ")";
			}
		} else {
			output << " UNKNOWN SYMBOL";
		}
		output << std::endl;
	}

	void TraceableException::analyzeStack()
	{
		CONTEXT context;
		int platformFlag;

		HANDLE processHandle=GetCurrentProcess();

#ifndef _WIN64
		platformFlag=IMAGE_FILE_MACHINE_I386;

		STACKFRAME64 stackFrame;

		// fill in stack frame, requires inline assembly
		memset(&context,0,sizeof(CONTEXT));
		context.ContextFlags=CONTEXT_CONTROL;

		__asm {
			mov [context.Ebp], ebp
			mov [context.Esp], esp
		__EIPHack:
			mov eax, [__EIPHack]
			mov [context.Eip], eax
		}

		stackFrame.AddrPC.Offset=context.Eip;
		stackFrame.AddrPC.Mode=AddrModeFlat;
		stackFrame.AddrFrame.Offset=context.Ebp;
		stackFrame.AddrFrame.Mode=AddrModeFlat;
		stackFrame.AddrStack.Offset=context.Esp;
		stackFrame.AddrStack.Mode=AddrModeFlat;

#else
		platformFlag=IMAGE_FILE_MACHINE_AMD64;

		RtlCaptureContext(&context);

		STACKFRAME64 stackFrame;

		stackFrame.AddrPC.Offset=context.Rip;
		stackFrame.AddrPC.Mode=AddrModeFlat;
		stackFrame.AddrFrame.Offset=context.Rbp; // might be Rdi as well according to MSDN - how to detect?
		stackFrame.AddrFrame.Mode=AddrModeFlat;
		stackFrame.AddrStack.Offset=context.Rsp;
		stackFrame.AddrStack.Mode=AddrModeFlat;
#endif

		SymInitialize(processHandle,NULL,TRUE);
		int oldSymOptions=SymGetOptions();
		SymSetOptions(SYMOPT_LOAD_LINES | SYMOPT_INCLUDE_32BIT_MODULES | SymGetOptions());

		SYMBOL_INFO_PACKAGE symbol;
		symbol.si.SizeOfStruct=sizeof(SYMBOL_INFO);
		symbol.si.MaxNameLen=MAX_SYM_NAME;
	
		IMAGEHLP_LINE64 line;
		line.SizeOfStruct=sizeof(IMAGEHLP_LINE64);
		char fileName[MAX_PATH];
		memset(fileName,0,MAX_PATH);
		line.FileName=fileName;

		std::ostringstream output;

		outputSymbol(output,processHandle,stackFrame,symbol,line);
		while(StackWalk64(platformFlag,processHandle,GetCurrentThread(),&stackFrame,&context,NULL,NULL,NULL,NULL)) {
			outputSymbol(output,processHandle,stackFrame,symbol,line);
		}

		SymCleanup(processHandle);
		SymSetOptions(oldSymOptions);

		backtrace=output.str();
	}

	
	std::string TraceableException::getBacktrace()
	{
		return backtrace;
	}

#else // We're on a platform where we don't know how to get a backtrace (e.g. Android)

	TraceableException::TraceableException(std::string description, std::string location)
	: Exception(description, location)
	{
	};

	TraceableException::~TraceableException()
	{
	}

	std::string TraceableException::getBacktrace()
	{
		return "--- NOT AVAILABLE ---";
	}
	
#endif

	std::string TraceableException::asFormattedText()
	{
		std::ostringstream output;
		output << "TracableException: " << getDescription() << std::endl;
		output << "In: " << getLocation() << std::endl;
		output << std::endl;
		output << "Backtrace: " << std::endl;
		output << getBacktrace();

		return output.str();
	}

	std::string Error::asFormattedText()
	{
		std::ostringstream output;
		output << "Error: " << getDescription() << std::endl;
		output << "In: " << getLocation() << std::endl;
		output << std::endl;
		output << "Backtrace: " << std::endl;
		output << getBacktrace();

		return output.str();
	}
}