#include <utility>
#include <string>
#include <string_view>
#include <windows.h>
#include <wininet.h>

#include "err.h"
#include "util.h"
#include "win32.h"
#include "window.h"

static thread_local const wchar_t* s_action;

std::wstring WideFromNarrow(const std::string_view src, const int cp)
{
	int cchNarrow = src.length()+1;
	int cchWide = MultiByteToWideChar(cp, 0, src.data(), cchNarrow, nullptr, 0);
	std::wstring dst(cchWide, 0);
	if (!MultiByteToWideChar(cp, 0, src.data(), cchNarrow, dst.data(), cchWide))
		throw Err(WINDOWS, L"Narrow string could not be converted to wide string: %s.");
	return dst;
}

void WithNextWindow(void (*proc)(HWND))
{
	/* WithNextWindow uses a CBT hook to call an arbitrary
	 * procedure just before the creation of the next window. The
	 * hook is removed as soon as HCBT_CREATEWND is received.
	 * Thus, proc is guaranteed to be executed only once. Note
	 * that static storage must be used, as SetWindowHookEx cannot
	 * accept a capturing lambda as the hook procedure. */

	static thread_local void (*procNext)(HWND);
	static thread_local HHOOK hHook;
	static const auto procCBT = [](const int nCode,
	    const WPARAM wParam, const LPARAM lParam) -> LRESULT CALLBACK
	{
		if (nCode == HCBT_CREATEWND) {
			if (!UnhookWindowsHookEx(hHook))
				throw Err(WINDOWS, L"Window hook could not be removed: %s.");
			procNext(reinterpret_cast<HWND>(wParam));
			return 0;
		} else
			return CallNextHookEx(0, nCode, wParam, lParam);
	};

	procNext = proc;
	if (!(hHook = SetWindowsHookExW(WH_CBT, procCBT, nullptr, GetCurrentThreadId())))
		throw Err(WINDOWS, L"Window hook could not be set: %s.");
}

/* Display next created window in the center of given window. */
static void CenterNextWindow(HWND hWnd)
{
	if (!hWnd)
		return;

	/* CenterNextWindow employs a trick similar to that above.
	 * Note, however, that repositioning does not work unless it
	 * is delayed until the new window is activated. This
	 * complicates the code somewhat. */

	static thread_local HWND hWndParent;
	static thread_local HWND hWndNext;
	static thread_local HHOOK hHook;
	static const auto procCBT = [](const int nCode,
	    const WPARAM wParam, const LPARAM lParam) -> LRESULT CALLBACK
	{
		if (!hWndNext && nCode == HCBT_CREATEWND) {
			hWndNext = reinterpret_cast<HWND>(wParam);
			return 0;
		} else if (nCode == HCBT_ACTIVATE
		    && reinterpret_cast<HWND>(wParam) == hWndNext) {
			if (!UnhookWindowsHookEx(hHook))
				throw Err(WINDOWS, L"Window hook could not be removed: %s.");

			long lStyle = GetWindowLongW(hWndNext, GWL_STYLE);
			if (!(lStyle & WS_POPUP)) return 0;

			RECT rcMain, rcMsg;
			GetWindowRect(hWndParent, &rcMain);
			GetWindowRect(hWndNext, &rcMsg);
			SetWindowPos(hWndNext, nullptr,
			    rcMain.left+(rcMain.right-rcMain.left)/2-(rcMsg.right-rcMsg.left)/2,
			    rcMain.top+(rcMain.bottom-rcMain.top)/2-(rcMsg.bottom-rcMsg.top)/2,
			    -1, -1,
			    SWP_NOZORDER|SWP_NOSIZE|SWP_NOACTIVATE);

			return 0;
		} else
			return CallNextHookEx(0, nCode, wParam, lParam);
	};

	hWndParent = hWnd;
	hWndNext = nullptr;
	if (!(hHook = SetWindowsHookExW(WH_CBT, procCBT, nullptr, GetCurrentThreadId())))
		throw Err(WINDOWS, L"Window hook could not be set: %s.");
}

int EBMessageBox(const std::wstring_view text, const std::wstring_view caption, const UINT uType)
{
	extern Window* g_window;
	const HWND hWnd = g_window? g_window->hWnd: nullptr;
	CenterNextWindow(hWnd);
	return MessageBox(hWnd, text.data(), caption.data(), uType);
}

int GetRelativeCursorPos(const HWND hWnd, POINT* const pt) noexcept
{
	RECT rc;
	if (!GetClientRect(hWnd, &rc)) return 0;
	SetLastError(ERROR_SUCCESS);
	if (!MapWindowPoints(hWnd, nullptr, (POINT*)&rc, 2)) return 0;

	POINT ptMouse;
	if (!GetCursorPos(&ptMouse)) return 0;
	pt->x = ptMouse.x-rc.left;
	pt->y = ptMouse.y-rc.top;
	return 1;
}

std::optional<Library> Library::Maybe(const wchar_t* const lib) noexcept
{
	HMODULE hModule = LoadLibraryW(lib);
	if (!hModule) return {};
	return Library(hModule);
}

Library::Library(const HMODULE hModule) noexcept
	: m_hModule(hModule) {}

Library::Library(const wchar_t* const lib)
{
	m_hModule = LoadLibraryW(lib);
	if (!m_hModule)
		throw Err(WINDOWS, L"Library "s + lib + L" could not be loaded: %s.");
}

Library::~Library()
{
	FreeLibrary(m_hModule);
}