#include "SignalHandlers.h"
#include "system/System.h"

#ifdef WIN32
	#include <Windows.h>
	#include <thread>

	static DWORD gMainThreadId;
	static std::thread gThreadMessageLoop;
#endif

#include <csignal>

static HttpServer::Server *globalServerPtr = nullptr;

/**
 * Terminate signal
 */
static void handlerSigTerm(const int) noexcept {
	if (globalServerPtr) {
		globalServerPtr->stop();
	}
}

/**
 * Interrupt signal
 */
static void handlerSigInt(const int) noexcept {
	if (globalServerPtr) {
		globalServerPtr->stop();
	}
}

/**
 * Signal to restart
 */
static void handlerSigUsr1(const int) noexcept {
	if (globalServerPtr) {
		globalServerPtr->restart();
	}
}

/**
 * Signal to update modules
 */
static void handlerSigUsr2(const int) noexcept {
	if (globalServerPtr) {
		globalServerPtr->update();
	}
}

#ifdef WIN32
/**
 * Note: PostQuitMessage(0)
 *  It doesn't work in case the program was launched and was
 *  attempted to finish under different remote sessions.
 */
static ::LRESULT CALLBACK WndProc(
	const ::HWND hWnd,
	const ::UINT message,
	const ::WPARAM wParam,
	const ::LPARAM lParam
) noexcept {
	switch (message)
	{
		case SIGTERM: {
			handlerSigTerm(message);
			::PostMessage(hWnd, WM_QUIT, 0, 0); // Fuck ::PostQuitMessage(0);

			break;
		}

		case SIGINT: {
			handlerSigInt(message);
			::PostMessage(hWnd, WM_QUIT, 0, 0); // Fuck ::PostQuitMessage(0);

			break;
		}

		case SIGUSR1: {
			handlerSigUsr1(message);
			break;
		}

		case SIGUSR2: {
			handlerSigUsr2(message);
			break;
		}

		// Cases WM_QUERYENDSESSION and WM_ENDSESSION run before shutting down the system (or ending user session)
		case WM_QUERYENDSESSION: {
			handlerSigTerm(message);
			break;
		}

		case WM_ENDSESSION: {
			const ::HANDLE hThread = ::OpenThread(SYNCHRONIZE, false, gMainThreadId);
			::WaitForSingleObject(hThread, INFINITE);
			::CloseHandle(hThread);
			break;
		}

		default: {
			return ::DefWindowProc(hWnd, message, wParam, lParam);
		}
	}

	return 0;
}

static ::WPARAM mainMessageLoop(
	const ::HINSTANCE hInstance,
	Utils::Event * const eventWindowCreation
) noexcept {
	const ::HWND hWnd = ::CreateWindow(
		myWndClassName,
		nullptr,
		0,
		CW_USEDEFAULT,
		CW_USEDEFAULT,
		0,
		0,
		nullptr,
		nullptr,
		hInstance,
		nullptr
	);

	eventWindowCreation->notify(); // After this action, eventWindowCreation will be destroyed (in the other thread)

	if (0 == hWnd) {
		return 0;
	}

	::MSG msg;

	while (::GetMessage(&msg, hWnd, 0, 0) ) {
		::TranslateMessage(&msg);
		::DispatchMessage(&msg);
	}

	return msg.wParam;
}

#ifdef _CONSOLE
static ::BOOL consoleSignalHandler(const ::DWORD ctrlType) noexcept
{
	switch (ctrlType)
	{
	case CTRL_CLOSE_EVENT:
	// Cases CTRL_LOGOFF_EVENT and CTRL_SHUTDOWN_EVENT don't happen because... it's Windows %)
	//  @see my function WndProc -> cases WM_QUERYENDSESSION and WM_ENDSESSION. Only they happen in this program, because the library user32.dll is connected.
	//  @prooflink: https://msdn.microsoft.com/library/windows/desktop/ms686016(v=vs.85).aspx
	case CTRL_LOGOFF_EVENT:
	case CTRL_SHUTDOWN_EVENT: {
		handlerSigTerm(ctrlType);
		const ::HANDLE hThread = ::OpenThread(SYNCHRONIZE, false, gMainThreadId);
		::WaitForSingleObject(hThread, INFINITE);
		::CloseHandle(hThread);
		return true;
	}

	case CTRL_C_EVENT: {
		handlerSigInt(ctrlType);
		return true;
	}

	default:
		return false;
	}
}
#endif // _CONSOLE
#endif // WIN32

bool bindSignalHandlers(HttpServer::Server *server) noexcept
{
	globalServerPtr = server;

#ifdef WIN32

#ifdef _CONSOLE
	::SetConsoleCtrlHandler(reinterpret_cast<PHANDLER_ROUTINE>(consoleSignalHandler), true);
#elif
	::signal(SIGINT, handlerSigInt);
	::signal(SIGTERM, handlerSigTerm);
#endif // _CONSOLE

	const ::HINSTANCE hInstance = ::GetModuleHandle(nullptr);

	::WNDCLASSEX wcex {};

	wcex.cbSize = sizeof(::WNDCLASSEX);
	wcex.lpfnWndProc = WndProc;
	wcex.hInstance = hInstance;
	wcex.lpszClassName = myWndClassName;

	if (::RegisterClassEx(&wcex) == 0) {
		return false;
	}

	Utils::Event eventWindowCreation;

	gMainThreadId = ::GetCurrentThreadId();
	gThreadMessageLoop = std::thread(mainMessageLoop, hInstance, &eventWindowCreation);

	eventWindowCreation.wait();

#elif POSIX

	struct ::sigaction act {};

	act.sa_handler = handlerSigInt;
	::sigaction(SIGINT, &act, nullptr);

	act.sa_handler = handlerSigTerm;
	::sigaction(SIGTERM, &act, nullptr);

	act.sa_handler = handlerSigUsr1;
	::sigaction(SIGUSR1, &act, nullptr);

	act.sa_handler = handlerSigUsr2;
	::sigaction(SIGUSR2, &act, nullptr);

	::signal(SIGPIPE, SIG_IGN);

#else
	#error "Undefined platform"
#endif

	return true;
}

void stopSignalHandlers() noexcept
{
#ifdef WIN32
	System::sendSignal(::GetCurrentProcessId(), SIGINT);
	gThreadMessageLoop.join();
#endif
}