PluginJsHandler.cpp

#include "PluginJsHandler.h"
#include "QtGuiModifications.h"

// Local
#include "JavascriptApi.h"
#include "GrpcPlugin.h"
#include "WebServer.h"
#include "WindowsFunctions.h"
#include "SlDockEventFilter.h"

// Windows
#include <ShlObj.h>
#include <shellapi.h>
#include <Psapi.h>
#include <bcrypt.h>
#pragma comment(lib, "bcrypt.lib")

// Stl
#include <chrono>
#include <functional>
#include <codecvt>
#include <filesystem>
#include <fstream>
#include <sstream>
#include <algorithm>
#include <cwctype>
#include <vector>

// Obs
#include <obs.hpp>
#include <obs-frontend-api.h>

#include "../obs-browser/panel/browser-panel-internal.hpp"

// Qt
#include <QMainWindow>
#include <QDockWidget>
#include <QCheckBox>
#include <QMessageBox>
#include <QComboBox>
#include <QFontDatabase>
#include <QApplication>
#include <QProcess>

using namespace json11;

PluginJsHandler::PluginJsHandler() {}

PluginJsHandler::~PluginJsHandler()
{
	stop();

	if (m_childJob)
		CloseHandle(m_childJob);

	if (m_restartApp)
		QProcess::startDetached(*m_restartProgramStr, *m_restartArguments);
}

std::wstring PluginJsHandler::getDownloadsDir() const
{
	wchar_t path[MAX_PATH];

	if (SUCCEEDED(SHGetFolderPathW(NULL, CSIDL_APPDATA, NULL, 0, path)))
		return std::wstring(path) + L"\\StreamlabsOBS";

	return L"";
}

std::wstring PluginJsHandler::getFontsDir() const
{
	auto downloadsDir = getDownloadsDir();

	if (!downloadsDir.empty())
		return downloadsDir + L"\\Fonts";

	return L"";
}

/*static*/
QDockWidget* PluginJsHandler::findDock(const std::string &objectName)
{
	QMainWindow* mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// Note: Be careful about when and where this is called per thread safety with qt
	QList<QDockWidget *> docks = mainWindow->findChildren<QDockWidget *>();
	foreach(QDockWidget * dock, docks)
	{
		if (dock->objectName().toStdString() == objectName)
			return dock;
	}

	return nullptr;
}

void PluginJsHandler::start()
{
	m_running = true;
	m_workerThread = std::thread(&PluginJsHandler::workerThread, this);
	m_freezeCheckThread = std::thread(&PluginJsHandler::freezeCheckThread, this);
}

void PluginJsHandler::stop()
{
	m_running = false;

	if (m_workerThread.joinable())
		m_workerThread.join();

	if (m_freezeCheckThread.joinable())
		m_freezeCheckThread.join();
}

void PluginJsHandler::pushApiRequest(const std::string &funcName, const std::string &params)
{
	std::lock_guard<std::mutex> grd(m_queueMtx);
	m_queudRequests.push_back({funcName, params});
}

void PluginJsHandler::workerThread()
{
	while (m_running)
	{
		using namespace std::chrono;

		// A request can arrive before connectToClient() has published the channel we answer on.
		// Leave it queued rather than computing a reply with nowhere to send it - the browser is
		// waiting on a callback, so dropping one is a hang and running one early was a crash.
		if (!GrpcPlugin::instance().clientReady())
		{
			std::this_thread::sleep_for(1ms);
			continue;
		}

		std::vector<std::pair<std::string, std::string>> latestBatch;

		{
			std::lock_guard<std::mutex> grd(m_queueMtx);
			latestBatch.swap(m_queudRequests);
		}

		if (latestBatch.empty())
		{
			std::this_thread::sleep_for(1ms);
		}
		else
		{
			for (auto &itr : latestBatch)
				executeApiRequest(itr.first, itr.second);
		}
	}
}

void PluginJsHandler::freezeCheckThread()
{
	while (m_running)
	{
		std::atomic<bool> threadActive = true;

		std::thread([&] {
			QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();
			QMetaObject::invokeMethod(mainWindow, [mainWindow]() { printf("0"); }, Qt::BlockingQueuedConnection);
			threadActive = false;
		}).detach();

		auto timeStart = std::chrono::steady_clock::now();

		while (threadActive)
		{
			auto elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - timeStart).count();

			if (elapsedTime > 30000)
			{
				blog(LOG_ERROR, "PluginJsHandler::freezeCheckThread - UI seems frozen.");
				int result = MessageBoxA(0, "The UI is not responding.\nWould you like to try and close the program?", "Frozen", MB_YESNO | MB_ICONERROR);

				if (result == IDYES)
				{
					// Try to invoke crash handler (works often enough to get reports we need)
					*((unsigned int *)0) = 0xDEAD;
					abort();
				}

				return;
			}

			std::this_thread::sleep_for(std::chrono::milliseconds(1));
		}

		// Check every 10 seconds
		for (int i = 0; i < 10000 && m_running; ++i)
			std::this_thread::sleep_for(std::chrono::milliseconds(1));
	}
}

void PluginJsHandler::executeApiRequest(const std::string &funcName, const std::string &params)
{
	std::string err;
	Json jsonParams = Json::parse(params, err);

	if (!err.empty())
	{
		blog(LOG_ERROR, "PluginJsHandler::executeApiRequest invalid params %s", params.c_str());
		return;
	}

	const auto &param1Value = jsonParams["param1"];

	if (param1Value.is_null())
	{
		blog(LOG_ERROR, "PluginJsHandler::executeApiRequest Error: 'param1' key not found. %s", params.c_str());
		return;
	}


#ifndef GITHUB_REVISION
	blog(LOG_INFO, "executeApiRequest (start) %s: %s\n", funcName.c_str(), params.c_str());
#endif

	std::string jsonReturnStr;

	switch (JavascriptApi::getFunctionId(funcName)) {
		case JavascriptApi::JS_QUERY_DOCKS: JS_QUERY_DOCKS(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_DOCK_EXECUTEJAVASCRIPT: JS_DOCK_EXECUTEJAVASCRIPT(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_DOCK_SETURL: JS_DOCK_SETURL(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_DOWNLOAD_ZIP: JS_DOWNLOAD_ZIP(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_RUN_STREAMLABS_EXE: JS_RUN_STREAMLABS_EXE(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_DOWNLOAD_FILE: JS_DOWNLOAD_FILE(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_READ_FILE: JS_READ_FILE(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_DELETE_FILES: JS_DELETE_FILES(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_DROP_FOLDER: JS_DROP_FOLDER(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_QUERY_DOWNLOADS_FOLDER: JS_QUERY_DOWNLOADS_FOLDER(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_GET_LOGS_REPORT_STRING: JS_GET_LOGS_REPORT_STRING(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_OBS_SOURCE_CREATE: JS_OBS_SOURCE_CREATE(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_OBS_SOURCE_DESTROY: JS_OBS_SOURCE_DESTROY(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_DOCK_SETAREA: JS_DOCK_SETAREA(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_DOCK_RESIZE: JS_DOCK_RESIZE(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_DOCK_NEW_BROWSER_DOCK: JS_DOCK_NEW_BROWSER_DOCK(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_GET_MAIN_WINDOW_GEOMETRY: JS_GET_MAIN_WINDOW_GEOMETRY(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_TOGGLE_USER_INPUT: JS_TOGGLE_USER_INPUT(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_TOGGLE_DOCK_VISIBILITY: JS_TOGGLE_DOCK_VISIBILITY(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_DOCK_SWAP: JS_DOCK_SWAP(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_DESTROY_DOCK: JS_DESTROY_DOCK(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_DOCK_RENAME: JS_DOCK_RENAME(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_DOCK_SETTITLE: JS_DOCK_SETTITLE(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_SET_STREAMSETTINGS: JS_SET_STREAMSETTINGS(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_GET_STREAMSETTINGS: JS_GET_STREAMSETTINGS(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_SL_VERSION_INFO: JS_SL_VERSION_INFO(jsonParams, jsonReturnStr); break;		
		case JavascriptApi::JS_START_WEBSERVER: JS_START_WEBSERVER(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_STOP_WEBSERVER: JS_STOP_WEBSERVER(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_LAUNCH_OS_BROWSER_URL: JS_LAUNCH_OS_BROWSER_URL(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_GET_AUTH_TOKEN: JS_GET_AUTH_TOKEN(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_CLEAR_AUTH_TOKEN: JS_CLEAR_AUTH_TOKEN(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_SET_CURRENT_SCENE: JS_SET_CURRENT_SCENE(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_CREATE_SCENE: JS_CREATE_SCENE(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_SCENE_ADD: JS_SCENE_ADD(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_SOURCE_GET_PROPERTIES: JS_SOURCE_GET_PROPERTIES(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_SOURCE_GET_SETTINGS: JS_SOURCE_GET_SETTINGS(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_SOURCE_SET_SETTINGS: JS_SOURCE_SET_SETTINGS(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_INSTALL_FONT: JS_INSTALL_FONT(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_GET_SCENE_COLLECTIONS: JS_GET_SCENE_COLLECTIONS(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_GET_CURRENT_SCENE_COLLECTION: JS_GET_CURRENT_SCENE_COLLECTION(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_SET_CURRENT_SCENE_COLLECTION: JS_SET_CURRENT_SCENE_COLLECTION(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_ADD_SCENE_COLLECTION: JS_ADD_SCENE_COLLECTION(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_SET_SCENEITEM_POS: JS_SET_SCENEITEM_POS(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_SET_SCENEITEM_ROT: JS_SET_SCENEITEM_ROT(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_SET_SCENEITEM_VISIBILITY: JS_SET_SCENEITEM_VISIBILITY(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_SET_SCENEITEM_CROP: JS_SET_SCENEITEM_CROP(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_SET_SCENEITEM_SCALE_FILTER: JS_SET_SCENEITEM_SCALE_FILTER(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_SET_SCENEITEM_BLENDING_MODE: JS_SET_SCENEITEM_BLENDING_MODE(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_SET_SCENEITEM_BLENDING_METHOD: JS_SET_SCENEITEM_BLENDING_METHOD(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_SET_SCALE: JS_SET_SCALE(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_GET_SCENEITEM_POS: JS_GET_SCENEITEM_POS(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_GET_SCENEITEM_ROT: JS_GET_SCENEITEM_ROT(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_GET_SCENEITEM_CROP: JS_GET_SCENEITEM_CROP(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_GET_SCENEITEM_SCALE_FILTER: JS_GET_SCENEITEM_SCALE_FILTER(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_GET_SCENEITEM_BLENDING_MODE: JS_GET_SCENEITEM_BLENDING_MODE(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_GET_SCENEITEM_BLENDING_METHOD: JS_GET_SCENEITEM_BLENDING_METHOD(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_GET_SCALE: JS_GET_SCALE(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_SCENE_GET_SOURCES: JS_SCENE_GET_SOURCES(jsonParams, jsonReturnStr); break;	
		case JavascriptApi::JS_QUERY_ALL_SOURCES: JS_QUERY_ALL_SOURCES(jsonParams, jsonReturnStr); break;		
		case JavascriptApi::JS_GET_SOURCE_DIMENSIONS: JS_GET_SOURCE_DIMENSIONS(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_GET_CANVAS_DIMENSIONS: JS_GET_CANVAS_DIMENSIONS(jsonParams,jsonReturnStr); break;
		case JavascriptApi::JS_GET_CURRENT_SCENE: JS_GET_CURRENT_SCENE(jsonParams,jsonReturnStr); break;
		case JavascriptApi::JS_OBS_BRING_FRONT: JS_OBS_BRING_FRONT(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_OBS_TOGGLE_HIDE_SELF: JS_OBS_TOGGLE_HIDE_SELF(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_OBS_ADD_TRANSITION: JS_OBS_ADD_TRANSITION(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_OBS_SET_CURRENT_TRANSITION: JS_OBS_SET_CURRENT_TRANSITION(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_OBS_REMOVE_TRANSITION: JS_OBS_REMOVE_TRANSITION(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_TRANSITION_GET_SETTINGS: JS_TRANSITION_GET_SETTINGS(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_TRANSITION_SET_SETTINGS: JS_TRANSITION_SET_SETTINGS(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_ENUM_SCENES: JS_ENUM_SCENES(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_RESTART_OBS: JS_RESTART_OBS(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_GET_IS_OBS_STREAMING: JS_GET_IS_OBS_STREAMING(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_SAVE_SL_BROWSER_DOCKS: JS_SAVE_SL_BROWSER_DOCKS(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_QT_SET_JS_ON_CLICK_STREAM: JS_QT_SET_JS_ON_CLICK_STREAM(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_QT_INVOKE_CLICK_ON_STREAM_BUTTON: JS_QT_INVOKE_CLICK_ON_STREAM_BUTTON(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_SOURCE_FILTER_ADD: JS_SOURCE_FILTER_ADD(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_SOURCE_FILTER_REMOVE: JS_SOURCE_FILTER_REMOVE(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_QT_GET_COOKIE_VALUE: JS_QT_GET_COOKIE_VALUE(jsonParams, jsonReturnStr); break;			
		case JavascriptApi::JS_BROWSERSOURCE_SEND_MESSAGE: JS_BROWSERSOURCE_SEND_MESSAGE(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_PATH_JOIN: JS_PATH_JOIN(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_GET_ENV_VAR: JS_GET_ENV_VAR(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_MKDIR: JS_MKDIR(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_PATH_EXISTS: JS_PATH_EXISTS(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_REMOVE_PATH: JS_REMOVE_PATH(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_MOVE_PATH: JS_MOVE_PATH(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_SHA256_FILE: JS_SHA256_FILE(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_WRITE_FILE: JS_WRITE_FILE(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_IS_PROCESS_RUNNING: JS_IS_PROCESS_RUNNING(jsonParams, jsonReturnStr); break;
		case JavascriptApi::JS_STOP_PROCESS: JS_STOP_PROCESS(jsonParams, jsonReturnStr); break;
		default: jsonReturnStr = Json(Json::object{{"error", "Unknown Javascript Function"}}).dump(); break;
	}

#ifndef GITHUB_REVISION
	blog(LOG_INFO, "executeApiRequest (finish) %s: jsonReturnStr = %s\n", funcName.c_str(), jsonReturnStr.c_str());
#endif

	// We're done, send callback
	if (param1Value.int_value() > 0)
	{
		if (auto *client = GrpcPlugin::instance().getClient())
			client->send_executeCallback(param1Value.int_value(), jsonReturnStr);
		else
			blog(LOG_ERROR, "PluginJsHandler::executeApiRequest no channel to answer %s on", funcName.c_str());
	}
}

void PluginJsHandler::JS_QT_GET_COOKIE_VALUE(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];

	std::string class_name = param2Value.string_value();
	std::string cookie_name = param3Value.string_value();

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	CefRefPtr<CefCookieManager> mgr;

	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, &mgr, &class_name, cookie_name]() {
			for (auto *w : mainWindow->findChildren<QWidget *>())
			{
				if (std::string(w->metaObject()->className()) != class_name)
					continue;

				QCefWidgetInternal *cefWidget = nullptr;

				for (auto *child : w->findChildren<QWidget *>())
				{
					if (std::string(child->metaObject()->className()) == "QCefWidgetInternal")
					{
						cefWidget = (QCefWidgetInternal *)child;
						break;
					}
				}
				if (!cefWidget || !cefWidget->cefBrowser)
					continue;

				auto host = cefWidget->cefBrowser->GetHost();
				if (!host)
					continue;

				auto ctx = host->GetRequestContext();

				if (!ctx)
					continue;

				mgr = ctx->GetCookieManager(nullptr);

				if (mgr)
					break;
			}
		},
		Qt::BlockingQueuedConnection);

	if (!mgr)
	{
		out_jsonReturn = Json(Json::object({{"error", "QCefWidgetInternal object not found with that class name"}})).dump();
		return;
	}
	
	class CookieVisitor : public CefCookieVisitor
	{
	public:
		std::string target;
		std::string value;
		bool found = false;

		std::mutex mtx;
		std::condition_variable cv;
		bool done = false;

		CookieVisitor(const char *name) : target(name) {}

		bool Visit(const CefCookie &cookie, int count, int total, bool &deleteCookie) override
		{
			if (CefString(&cookie.name).ToString() == target)
			{
				value = CefString(&cookie.value).ToString();
				found = true;
			}

			if (found || count >= total - 1)
			{
				std::lock_guard<std::mutex> lk(mtx);
				done = true;
				cv.notify_all();
				return false;
			}
			return true;
		}

		bool Wait(int timeout_ms = 5000)
		{
			std::unique_lock<std::mutex> lk(mtx);
			return cv.wait_for(lk, std::chrono::milliseconds(timeout_ms), [this] { return done; });
		}

		IMPLEMENT_REFCOUNTING(CookieVisitor);
	};

	CefRefPtr<CookieVisitor> visitor = new CookieVisitor(cookie_name.c_str());

	if (!mgr->VisitAllCookies(visitor))
	{
		out_jsonReturn = Json(Json::object({{"error", "Unknown CEF error prevented VisitAllCookies"}})).dump();
		return;
	}

	visitor->Wait(5000);

	if (visitor->found)
		out_jsonReturn = Json(Json::object({{"value", visitor->value}})).dump();
	else
		out_jsonReturn = Json(Json::object({{"error", "Cookie with that name not found in that QCefWidgetInternal"}})).dump();
}

void PluginJsHandler::JS_START_WEBSERVER(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];
	const auto &param4Value = params["param4"];

	WebServer::instance().setExpectedReferer(param3Value.string_value());
	WebServer::instance().setRedirectUrl(param4Value.string_value());

	if (WebServer::instance().isAlreadyStarted())
	{
		out_jsonReturn = Json(Json::object{{"port", WebServer::instance().getPort()}}).dump();
		return;
	}

	if (!WebServer::instance().start(param2Value.int_value()))
	{
		out_jsonReturn = Json(Json::object{{"error", WebServer::instance().getErr()}}).dump();
		return;
	}

	out_jsonReturn = Json(Json::object{{"port", WebServer::instance().getPort()}}).dump();
}

void PluginJsHandler::JS_STOP_WEBSERVER(const json11::Json &params, std::string &out_jsonReturn)
{
	WebServer::instance().stop();
}

void PluginJsHandler::JS_LAUNCH_OS_BROWSER_URL(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	std::string url = param2Value.string_value();

	// Check if URL has a protocol prefix
	if (url.find("http://") != 0 && url.find("https://") != 0)
		url = "https://" + url;

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, url, &out_jsonReturn]() {
			mainWindow->setWindowState(mainWindow->windowState() & ~Qt::WindowMinimized);
			mainWindow->show();
			mainWindow->raise();
			mainWindow->activateWindow();

			// Win32 workaround
			HWND hWnd = reinterpret_cast<HWND>(mainWindow->winId());
			DWORD foregroundThread = GetWindowThreadProcessId(GetForegroundWindow(), nullptr);
			DWORD currentThread = GetCurrentThreadId();

			if (foregroundThread != currentThread)
			{
				AttachThreadInput(currentThread, foregroundThread, TRUE);
				SetForegroundWindow(hWnd);
				AttachThreadInput(currentThread, foregroundThread, FALSE);
			}
			else
			{
				SetForegroundWindow(hWnd);
			}

			// The member conversion, not a local wstring_convert: that one throws on input that
			// is not valid utf-8, and this string came from the page.
			std::wstring wurl = utf8_to_ws(url);

			SHELLEXECUTEINFO info = {};
			info.cbSize = sizeof(SHELLEXECUTEINFO);
			info.fMask = SEE_MASK_NOASYNC | SEE_MASK_FLAG_NO_UI;
			info.lpVerb = L"open";
			info.lpFile = wurl.c_str();
			info.lpDirectory = nullptr;
			info.nShow = SW_SHOWNORMAL;

			if (!ShellExecuteEx(&info))
				out_jsonReturn = Json(Json::object{{"error", "Failed to open."}}).dump();
		},
		Qt::BlockingQueuedConnection);

}

void PluginJsHandler::JS_GET_AUTH_TOKEN(const json11::Json &params, std::string &out_jsonReturn)
{
	out_jsonReturn = Json(Json::object{{"token", WebServer::instance().getToken()}}).dump();
}

void PluginJsHandler::JS_CLEAR_AUTH_TOKEN(const json11::Json &params, std::string &out_jsonReturn)
{
	WebServer::instance().clearToken();
	out_jsonReturn = Json(Json::object{{"status", "success"}}).dump();
}

void PluginJsHandler::JS_SL_VERSION_INFO(const json11::Json &params, std::string &out_jsonReturn)
{
#ifdef GITHUB_REVISION
	out_jsonReturn = Json(Json::object{{"branch", SL_OBS_VERSION}, {"git_sha", GITHUB_REVISION}, {"rev", SL_REVISION}}).dump();
#else
	out_jsonReturn = Json(Json::object{{"branch", "debug"}, {"git_sha", "debug"}, {"rev", "debug"}}).dump();
#endif
}

void PluginJsHandler::JS_GET_STREAMSETTINGS(const json11::Json &params, std::string &out_jsonReturn)
{
	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, &out_jsonReturn]() {
			obs_service_t *service_t = obs_frontend_get_streaming_service();

			if (service_t)
			{
				obs_data_t *settings = obs_service_get_settings(service_t);

				std::string service = obs_data_get_string(settings, "service");
				std::string protocol = obs_data_get_string(settings, "protocol");
				std::string server = obs_data_get_string(settings, "server");
				bool use_auth = obs_data_get_bool(settings, "use_auth");
				std::string username = obs_data_get_string(settings, "username");
				std::string password = obs_data_get_string(settings, "password");
				std::string key = obs_data_get_string(settings, "key");

				out_jsonReturn = Json(Json::object{{"service", service}, {"protocol", protocol}, {"server", server}, {"use_auth", use_auth}, {"username", username}, {"password", password}, {"key", key}}).dump();
			}
			else
			{
				out_jsonReturn = Json(Json::object({{"error", "No service exists"}})).dump();
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_SET_STREAMSETTINGS(const json11::Json &params, std::string &out_jsonReturn)
{
	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];
	const auto &param4Value = params["param4"];
	const auto &param5Value = params["param5"];
	const auto &param6Value = params["param6"];
	const auto &param7Value = params["param7"];
	const auto &param8Value = params["param8"];

	// "rtmp_custom" : "rtmp_common"
	std::string service = param2Value.string_value();
	std::string protocol = param3Value.string_value();
	std::string server = param4Value.string_value();
	bool use_auth = param5Value.bool_value();
	std::string username = param6Value.string_value();
	std::string password = param7Value.string_value();
	std::string key = param8Value.string_value();

	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, &service, &protocol, &server, use_auth, &username, &password, &key, &out_jsonReturn]() {

			obs_service_t *oldService = obs_frontend_get_streaming_service();
			OBSDataAutoRelease hotkeyData = obs_hotkeys_save_service(oldService);

			OBSDataAutoRelease settings = obs_data_create();

			obs_data_set_string(settings, "service", service.c_str());
			obs_data_set_string(settings, "protocol", protocol.c_str());
			obs_data_set_string(settings, "server", server.c_str());
			obs_data_set_bool(settings, "use_auth", use_auth);
			obs_data_set_string(settings, "username", username.c_str());
			obs_data_set_string(settings, "password", password.c_str());
			obs_data_set_string(settings, "key", key.c_str());

			OBSServiceAutoRelease newService = obs_service_create(service.c_str(), "default_service", settings, hotkeyData);

			if (!newService)
				return;

			obs_frontend_set_streaming_service(newService);
			obs_frontend_save_streaming_service();
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_QUERY_DOCKS(const Json &params, std::string &out_jsonReturn)
{
	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, &out_jsonReturn]() {
			std::vector<Json> dockInfo;

			QList<QDockWidget *> docks = mainWindow->findChildren<QDockWidget *>();
			foreach(QDockWidget * dock, docks)
			{
				bool isSlabs = false;
				std::string name = dock->objectName().toStdString();
				std::string url;

				// Translate the global coordinates to coordinates relative to the main window
				QRect globalGeometry = dock->geometry();
				QRect mainWindowGeometry = mainWindow->geometry();
				int x = globalGeometry.x() - mainWindowGeometry.x();
				int y = globalGeometry.y() - mainWindowGeometry.y();
				int width = dock->width();
				int height = dock->height();
				bool floating = dock->isFloating();
				bool visible = dock->isVisible();
				std::string dockName = dock->objectName().toStdString();
				std::string dockTitle = dock->windowTitle().toStdString();

				if (dock->property("isSlabs").isValid())
				{
					isSlabs = true;
					QCefWidgetInternal *widget = (QCefWidgetInternal *)dock->widget();

					if (auto browser = widget->cefBrowser)
					{
						if (auto mainframe = browser->GetMainFrame())
							url = mainframe->GetURL();
					}
				}

				// Create a Json object for this dock widget and add it to the panelInfo vector
				dockInfo.push_back(Json::object{{"name", name}, {"x", x}, {"y", y}, {"width", width}, {"height", height}, {"floating", floating},
					{"isSlabs", isSlabs}, {"url", url}, {"visible", visible}, {"title", dockTitle}});
			}

			// Convert the panelInfo vector to a Json object and dump string
			Json ret = dockInfo;
			out_jsonReturn = ret.dump();
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_DOCK_SWAP(const Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];

	std::string objectName1 = param2Value.string_value();
	std::string objectName2 = param3Value.string_value();

	// Assume failure until we find the docks and swap them
	out_jsonReturn = Json(Json::object({{"error", "Did not find docks with objectNames: " + objectName1 + " and " + objectName2}})).dump();

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, objectName1, objectName2, &out_jsonReturn]() {
			QDockWidget *dock1 = nullptr;
			QDockWidget *dock2 = nullptr;

			QList<QDockWidget *> docks = mainWindow->findChildren<QDockWidget *>();
			foreach(QDockWidget * dock, docks)
			{
				if (dock->objectName().toStdString() == objectName1)
					dock1 = dock;
				else if (dock->objectName().toStdString() == objectName2)
					dock2 = dock;

				if (dock1 && dock2)
					break;
			}

			if (dock1 && dock2)
			{
				QRect geo1 = dock1->geometry();
				QRect geo2 = dock2->geometry();

				// Swap the geometries
				dock1->setGeometry(geo2);
				dock2->setGeometry(geo1);

				out_jsonReturn = Json(Json::object{{"status", "success"}}).dump();
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_DOCK_RESIZE(const Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];
	const auto &param4Value = params["param4"];

	std::string objectName = param2Value.string_value();
	int width = param3Value.int_value();
	int height = param3Value.int_value();

	// An error for now, if we succeed this is overwritten
	out_jsonReturn = Json(Json::object({{"error", "Did not find dock with objectName: " + objectName}})).dump();

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, objectName, width, height, &out_jsonReturn]() {

			if (auto dock = findDock(objectName))
			{
				dock->resize(width, height);
				out_jsonReturn = Json(Json::object{{"status", "success"}}).dump();
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_DOCK_SETAREA(const Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];

	std::string objectName = param2Value.string_value();
	int areaMask = param3Value.int_value();

	// An error for now, if we succeed this is overwritten
	out_jsonReturn = Json(Json::object({{"error", "Did not find dock with objectName: " + objectName}})).dump();

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, objectName, areaMask, &out_jsonReturn]() {
			// Find the panel by name (assuming the name is stored as a property)
			QList<QDockWidget *> docks = mainWindow->findChildren<QDockWidget *>();
			foreach(QDockWidget * dock, docks)
			{
				if (dock->objectName().toStdString() == objectName)
				{
					if (dock->isFloating())
						dock->setFloating(false);

					// Map the input area mask to the corresponding Qt::DockWidgetArea
					Qt::DockWidgetArea dockArea = static_cast<Qt::DockWidgetArea>(areaMask & Qt::DockWidgetArea_Mask);
					mainWindow->addDockWidget(dockArea, dock);
					out_jsonReturn = Json(Json::object{{"status", "success"}}).dump();
					break;
				}
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_DOCK_EXECUTEJAVASCRIPT(const Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];

	std::string objectName = param2Value.string_value();
	std::string javascriptcode = param3Value.string_value();

	if (javascriptcode.empty())
	{
		out_jsonReturn = Json(Json::object({{"error", "Invalid params"}})).dump();
		return;
	}

	// An error for now, if we succeed this is overwritten
	out_jsonReturn = Json(Json::object({{"error", "Did not find dock with objectName: " + objectName}})).dump();

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, javascriptcode, objectName, &out_jsonReturn]() {

			if (auto dock = findDock(objectName))
			{
				if (dock->property("isSlabs").isValid())
				{
					QCefWidgetInternal *widget = (QCefWidgetInternal *)dock->widget();

					if (auto browser = widget->cefBrowser)
					{
						if (auto mainframe = browser->GetMainFrame())
						{
							mainframe->ExecuteJavaScript(javascriptcode.c_str(), mainframe->GetURL().c_str(), 0);
							out_jsonReturn = Json(Json::object{{"status", "Found dock and ran ExecuteJavaScript on " + mainframe->GetURL().ToString()}}).dump();
						}
					}
				}
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_TOGGLE_USER_INPUT(const json11::Json &params, std::string &out_jsonReturn)
{
	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();
	bool enable = params["param2"].bool_value();

	QMetaObject::invokeMethod(
		mainWindow, [mainWindow, enable]() { ::EnableWindow(reinterpret_cast<HWND>(mainWindow->winId()), enable); }, Qt::BlockingQueuedConnection);
}


void PluginJsHandler::JS_DOCK_NEW_BROWSER_DOCK(const json11::Json &params, std::string &out_jsonReturn)
{
	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];
	const auto &param4Value = params["param4"];

	std::string title = param2Value.string_value();
	std::string url = param3Value.string_value();
	std::string objectName = param4Value.string_value();

	if (objectName.empty() || title.empty() || url.empty())
	{
		out_jsonReturn = Json(Json::object({{"error", "Invalid params"}})).dump();
		return;
	}

	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, objectName, title, url, &out_jsonReturn]() {

			// Check duplication
			if (findDock(objectName))
			{
				out_jsonReturn = Json(Json::object({{"error", "Already exists"}})).dump();
				return;
			}

			obs_frontend_add_dock_by_id(objectName.c_str(), title.c_str(), nullptr);

			if (auto dock = findDock(objectName))
			{
				static QCef *qcef = obs_browser_init_panel();

				QCefWidget *browser = qcef->create_widget(dock, url, nullptr);

				dock->setWidget(browser);
				dock->setWindowTitle(title.c_str());
				dock->setObjectName(objectName.c_str());
				dock->setProperty("isSlabs", true);

				dock->resize(460, 600);
				dock->setMinimumSize(80, 80);
				dock->setWindowTitle(title.c_str());
				dock->setAllowedAreas(Qt::AllDockWidgetAreas);
				dock->installEventFilter(new SlDockEventFilter(dock));

				//mainWindow->addDockWidget(Qt::LeftDockWidgetArea, dock);
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_QT_INVOKE_CLICK_ON_STREAM_BUTTON(const Json &params, std::string &out_jsonReturn)
{
	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();
	out_jsonReturn = Json(Json::object{{"status", "failure"}}).dump();

	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, &out_jsonReturn]() {
			if (QApplication::activeModalWidget())
			{
				out_jsonReturn = Json(Json::object{{"error", "activeModalWidget"}}).dump();
			}
			else
			{
				QtGuiModifications::instance().outsideInvokeClickStreamButton();
				out_jsonReturn = Json(Json::object{{"status", "success"}}).dump();
			}
		},
		Qt::BlockingQueuedConnection);

}

void PluginJsHandler::JS_QT_SET_JS_ON_CLICK_STREAM(const Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	std::string jsstr = param2Value.string_value();

	QtGuiModifications::instance().setJavascriptToCallOnStreamClick(jsstr);
	out_jsonReturn = Json(Json::object{{"status", "success"}}).dump();
}

void PluginJsHandler::JS_GET_MAIN_WINDOW_GEOMETRY(const Json &params, std::string &out_jsonReturn)
{
	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, &out_jsonReturn]() {
			int x = mainWindow->geometry().x();
			int y = mainWindow->geometry().y();
			int width = mainWindow->width();
			int height = mainWindow->height();
			out_jsonReturn = Json(Json::object{{{"x", x}, {"y", y}, {"width", width}, {"height", height}}}).dump();
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_DOCK_SETURL(const Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];

	std::string objectName = param2Value.string_value();
	std::string url = param3Value.string_value();

	if (url.empty())
	{
		out_jsonReturn = Json(Json::object({{"error", "Invalid params"}})).dump();
		return;
	}

	// An error for now, if we succeed this is overwritten
	out_jsonReturn = Json(Json::object({{"error", "Did not find dock with objectName: " + objectName}})).dump();

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, url, objectName, &out_jsonReturn]() {

			if (auto dock = findDock(objectName))
			{
				if (dock->property("isSlabs").isValid())
				{
					QCefWidgetInternal *widget = (QCefWidgetInternal *)dock->widget();
					widget->setURL(url.c_str());
					out_jsonReturn = Json(Json::object{{"status", "success"}}).dump();
				}
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_TOGGLE_DOCK_VISIBILITY(const Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];

	std::string objectName = param2Value.string_value();
	bool visible = param3Value.bool_value();

	// An error for now, if we succeed this is overwritten
	out_jsonReturn = Json(Json::object({{"error", "Did not find dock with objectName: " + objectName}})).dump();

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, visible, objectName, &out_jsonReturn]() {
			QList<QDockWidget *> docks = mainWindow->findChildren<QDockWidget *>();
			foreach(QDockWidget * dock, docks)
			{
				if (dock->objectName().toStdString() == objectName)
				{
					dock->setVisible(visible);
					out_jsonReturn = Json(Json::object{{"status", "success"}}).dump();
					break;
				}
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_DOCK_SETTITLE(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];

	std::string objectName = param2Value.string_value();
	std::string newTitle = param3Value.string_value();

	// An error for now, if we succeed this is overwritten
	out_jsonReturn = Json(Json::object({{"error", "Did not find dock with objectName: " + objectName}})).dump();

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, newTitle, objectName, &out_jsonReturn]() {
			QList<QDockWidget *> docks = mainWindow->findChildren<QDockWidget *>();
			foreach(QDockWidget * dock, docks)
			{
				if (dock->objectName().toStdString() == objectName)
				{
					//QAction *action = reinterpret_cast<QAction *>(dock->property("actionptr").toULongLong());
					//action->setText(newTitle.c_str());
					dock->setWindowTitle(newTitle.c_str());
					out_jsonReturn = Json(Json::object({{"status", "success"}})).dump();
					break;
				}
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_DOCK_RENAME(const json11::Json &params, std::string &out_jsonReturn)
{
	out_jsonReturn = Json(Json::object({{"error", "deprecated"}})).dump();
}

void PluginJsHandler::JS_DESTROY_DOCK(const Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	std::string objectName = param2Value.string_value();

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, objectName, &out_jsonReturn]() {
			//obs_frontend_remove_dock(objectName.c_str());
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_SOURCE_GET_SETTINGS(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	std::string sourceName = param2Value.string_value();

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, sourceName, &out_jsonReturn]() {
			OBSSourceAutoRelease existingSource = obs_get_source_by_name(sourceName.c_str());
			if (existingSource == nullptr)
			{
				out_jsonReturn = Json(Json::object({{"error", "Did not find an object with name " + sourceName}})).dump();
				return;
			}

			obs_data_t *settingsSource = obs_source_get_settings(existingSource);
			if (settingsSource == nullptr)
			{
				out_jsonReturn = Json(Json::object({{"error", "Error getting settings from " + sourceName}})).dump();
				return;
			}

			out_jsonReturn = Json(obs_data_get_json(settingsSource)).dump();
			obs_data_release(settingsSource);
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_SOURCE_SET_SETTINGS(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];
	std::string sourceName = param2Value.string_value();
	std::string settingsJson = param3Value.string_value();

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, sourceName, settingsJson, &out_jsonReturn]() {
			OBSSourceAutoRelease existingSource = obs_get_source_by_name(sourceName.c_str());
			if (existingSource == nullptr)
			{
				out_jsonReturn = Json(Json::object({{"error", "Did not find an object with name " + sourceName}})).dump();
				return;
			}

			obs_data_t *newSettings = obs_data_create_from_json(settingsJson.c_str());
			if (newSettings == nullptr)
			{
				out_jsonReturn = Json(Json::object({{"error", "Error parsing settings JSON"}})).dump();
				return;
			}

			obs_source_update(existingSource, newSettings);
			obs_data_release(newSettings);

			out_jsonReturn = Json(Json::object({{"success", true}})).dump();
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_TRANSITION_GET_SETTINGS(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	std::string sourceName = param2Value.string_value();

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, sourceName, &out_jsonReturn]() {
			obs_frontend_source_list transitions = {};
			obs_frontend_get_transitions(&transitions);

			OBSSourceAutoRelease transition;
			for (size_t i = 0; i < transitions.sources.num; i++)
			{
				obs_source_t *source = transitions.sources.array[i];
				if (obs_source_get_name(source) == sourceName)
				{
					transition = obs_source_get_ref(source);
					break;
				}
			}

			obs_frontend_source_list_free(&transitions);

			if (!transition)
			{
				out_jsonReturn = Json(Json::object({{"error", "Did not find transition named " + sourceName}})).dump();
				return;
			}

			obs_data_t *settingsSource = obs_source_get_settings(transition);
			if (settingsSource == nullptr)
			{
				out_jsonReturn = Json(Json::object({{"error", "Error getting settings from " + sourceName}})).dump();
				return;
			}

			out_jsonReturn = Json(obs_data_get_json(settingsSource)).dump();
			obs_data_release(settingsSource);
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_TRANSITION_SET_SETTINGS(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];
	std::string sourceName = param2Value.string_value();
	std::string settingsJson = param3Value.string_value();

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, sourceName, settingsJson, &out_jsonReturn]() {
			obs_frontend_source_list transitions = {};
			obs_frontend_get_transitions(&transitions);

			OBSSourceAutoRelease transition;
			for (size_t i = 0; i < transitions.sources.num; i++)
			{
				obs_source_t *source = transitions.sources.array[i];
				if (obs_source_get_name(source) == sourceName)
				{
					transition = obs_source_get_ref(source);
					break;
				}
			}

			obs_frontend_source_list_free(&transitions);

			if (!transition)
			{
				out_jsonReturn = Json(Json::object({{"error", "Did not find transition named " + sourceName}})).dump();
				return;
			}

			obs_data_t *newSettings = obs_data_create_from_json(settingsJson.c_str());
			if (newSettings == nullptr)
			{
				out_jsonReturn = Json(Json::object({{"error", "Error parsing settings JSON"}})).dump();
				return;
			}

			obs_source_update(transition, newSettings);
			obs_data_release(newSettings);

			out_jsonReturn = Json(Json::object({{"success", true}})).dump();
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_OBS_SET_CURRENT_TRANSITION(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	std::string sourceName = param2Value.string_value();

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, sourceName, &out_jsonReturn]() {

			obs_frontend_source_list transitions = {};
			obs_frontend_get_transitions(&transitions);

			OBSSourceAutoRelease transition;
			for (size_t i = 0; i < transitions.sources.num; i++)
			{
				obs_source_t *source = transitions.sources.array[i];
				if (obs_source_get_name(source) == sourceName)
				{
					transition = obs_source_get_ref(source);
					break;
				}
			}

			obs_frontend_source_list_free(&transitions);

			if (!transition)
			{
				out_jsonReturn = Json(Json::object({{"error", "Did not find transition named " + sourceName}})).dump();
				return;
			}

			obs_frontend_set_current_transition(transition);
		},
		Qt::BlockingQueuedConnection);	
}

void PluginJsHandler::JS_SAVE_SL_BROWSER_DOCKS(const json11::Json& params, std::string& out_jsonReturn)
{
	saveSlabsBrowserDocks();
	out_jsonReturn = Json(Json::object({{"success", true}})).dump();
}

void PluginJsHandler::JS_GET_IS_OBS_STREAMING(const json11::Json &params, std::string &out_jsonReturn)
{
	out_jsonReturn = Json(Json::object({{"value", obs_frontend_streaming_active()}})).dump();
}

void PluginJsHandler::JS_SOURCE_FILTER_ADD(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];
	std::string sourceName = param2Value.string_value();
	std::string filterName = param3Value.string_value();

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(mainWindow, [mainWindow, sourceName, filterName, &out_jsonReturn]() {
		OBSSourceAutoRelease source = obs_get_source_by_name(sourceName.c_str());

		if (!source)
		{
			out_jsonReturn = Json(Json::object({{"error", "Did not find source named " + sourceName}})).dump();
			return;
		}

		OBSSourceAutoRelease filter = obs_get_source_by_name(filterName.c_str());

		if (!filter)
		{
			out_jsonReturn = Json(Json::object({{"error", "Did not find filter named " + filterName}})).dump();
			return;
		}

		obs_source_filter_add(source, filter);
		out_jsonReturn = Json(Json::object({{"success", true}})).dump();
	});
}

void PluginJsHandler::JS_SOURCE_FILTER_REMOVE(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];
	std::string sourceName = param2Value.string_value();
	std::string filterName = param3Value.string_value();

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(mainWindow, [mainWindow, sourceName, filterName, &out_jsonReturn]() {
		OBSSourceAutoRelease source = obs_get_source_by_name(sourceName.c_str());

		if (!source)
		{
			out_jsonReturn = Json(Json::object({{"error", "Did not find source named " + sourceName}})).dump();
			return;
		}

		OBSSourceAutoRelease filter = obs_get_source_by_name(filterName.c_str());

		if (!filter)
		{
			out_jsonReturn = Json(Json::object({{"error", "Did not find filter named " + filterName}})).dump();
			return;
		}

		obs_source_filter_remove(source, filter);
		out_jsonReturn = Json(Json::object({{"success", true}})).dump();
	});
}

void PluginJsHandler::JS_OBS_REMOVE_TRANSITION(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	std::string sourceName = param2Value.string_value();

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, sourceName, &out_jsonReturn]() {
			obs_frontend_source_list transitions = {};
			obs_frontend_get_transitions(&transitions);

			OBSSourceAutoRelease transition;
			for (size_t i = 0; i < transitions.sources.num; i++)
			{
				obs_source_t *source = transitions.sources.array[i]; 
				if (obs_source_get_name(source) == sourceName)
				{
					transition = obs_source_get_ref(source);
					break;
				}
			}

			obs_frontend_source_list_free(&transitions);

			if (!transition)
			{
				out_jsonReturn = Json(Json::object({{"error", "Did not find transition named " + sourceName}})).dump();
				return;
			}
						
			// TODO: OBS needs frontend support for this, I'm looking for their transitions widget and manipulating it here with duplicated code from the UI
			QList<QWidget *> allWidgets = mainWindow->findChildren<QWidget *>();
			foreach(QWidget * widget, allWidgets)
			{
				if (widget->objectName().toStdString() == "transitions")
				{
					QComboBox *transitions = (QComboBox *)widget;
					int idx = transitions->findData(QVariant::fromValue<OBSSource>(transition.Get()));

					if (idx == -1)
					{
						out_jsonReturn = Json(Json::object({{"Transition not found in Qt widget", true}})).dump();
						return;
					}

					transitions->removeItem(idx);
					out_jsonReturn = Json(Json::object({{"success", true}})).dump();
					return;
				}
			}

			out_jsonReturn = Json(Json::object({{"error", "Unable to find transitions widget"}})).dump();	
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_OBS_ADD_TRANSITION(const json11::Json& params, std::string& out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];
	std::string id = param2Value.string_value();
	std::string sourceName = param3Value.string_value();

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, id, sourceName, &out_jsonReturn]() {

			obs_frontend_source_list transitions = {};
			obs_frontend_get_transitions(&transitions);

			OBSSourceAutoRelease transition;
			for (size_t i = 0; i < transitions.sources.num; i++)
			{
				obs_source_t *source = transitions.sources.array[i];
				if (obs_source_get_name(source) == sourceName)
				{
					transition = obs_source_get_ref(source);
					break;
				}
			}

			obs_frontend_source_list_free(&transitions);

			if (transition != nullptr)
			{
				out_jsonReturn = Json(Json::object({{"error", "Transition already exists named " + sourceName}})).dump();
				return;
			}

			// TODO: OBS needs frontend support for this, I'm looking for their transitions widget and manipulating it here with duplicated code from the UI
			QList<QWidget *> allWidgets = mainWindow->findChildren<QWidget *>();
			foreach(QWidget * widget, allWidgets)
			{
				if (widget->objectName().toStdString() == "transitions")
				{
					QComboBox *transitions = (QComboBox *)widget;
					obs_source_t *source = obs_source_create_private(id.c_str(), sourceName.c_str(), NULL);

					if (!source)
					{
						out_jsonReturn = Json(Json::object({{"error", "Failed to create the object"}})).dump();	
						return;
					}

					auto onTransitionStop = [](void *data, calldata_t *) {
						QMainWindow *window = (QMainWindow *)data;
						QMetaObject::invokeMethod(window, "TransitionStopped", Qt::QueuedConnection);
					};

					auto onTransitionFullStop = [](void *data, calldata_t *) {
						QMainWindow *window = (QMainWindow *)data;
						QMetaObject::invokeMethod(window, "TransitionFullyStopped", Qt::QueuedConnection);
					};

					signal_handler_t *handler = obs_source_get_signal_handler(source);
					signal_handler_connect(handler, "transition_video_stop", onTransitionStop, mainWindow);
					signal_handler_connect(handler, "transition_stop", onTransitionFullStop, mainWindow);

					transitions->addItem(sourceName.c_str(), QVariant::fromValue(OBSSource(source)));
					//transitions->setCurrentIndex(transitions->count() - 1);

					obs_source_release(source);

					out_jsonReturn = Json(Json::object({{"success", true}})).dump();
					return;
				}
			}

			out_jsonReturn = Json(Json::object({{"error", "Unable to find transitions widget"}})).dump();	
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_OBS_TOGGLE_HIDE_SELF(const json11::Json& params, std::string& out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();
	bool boolval = param2Value.bool_value();
	
	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, boolval, &out_jsonReturn]() {
			mainWindow->setHidden(boolval);
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_OBS_BRING_FRONT(const json11::Json& params, std::string& out_jsonReturn)
{
	DWORD currentProcessId = ::GetCurrentProcessId();

	EnumWindows(
		[](HWND hWnd, LPARAM lParam) -> BOOL {
			DWORD processId;
			::GetWindowThreadProcessId(hWnd, &processId);

			if (processId == (DWORD)lParam)
				WindowsFunctions::ForceForegroundWindow(hWnd);
			
			return TRUE;
		},
		(LPARAM)currentProcessId);
}

void PluginJsHandler::JS_GET_CURRENT_SCENE(const json11::Json &params, std::string &out_jsonReturn)
{
	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, &out_jsonReturn]() {
			OBSSourceAutoRelease current_scene_source = obs_frontend_get_current_scene();

			if (current_scene_source == nullptr)
			{
				out_jsonReturn = Json(Json::object({{"error", "Empty current scene."}})).dump();
				return;
			}

			auto rawName = obs_source_get_name(current_scene_source);
			out_jsonReturn = Json(Json::object({{"name", rawName ? rawName : ""}})).dump();
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_SET_CURRENT_SCENE(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	std::string scene_name = param2Value.string_value();

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, scene_name, &out_jsonReturn]() {
			OBSSourceAutoRelease source = obs_get_source_by_name(scene_name.c_str());
			if (!source)
				out_jsonReturn = Json(Json::object({{"error", "Did not find an object with name " + scene_name}})).dump();			
			else if (!obs_source_is_scene(source))
				out_jsonReturn = Json(Json::object({{"error", "The object found is not a scene"}})).dump();			
			else
				obs_frontend_set_current_scene(source);
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_SCENE_ADD(const json11::Json& params, std::string& out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];

	std::string scene_name = param2Value.string_value();
	std::string source_name = param3Value.string_value();

	if (scene_name == source_name)
	{
		out_jsonReturn = Json(Json::object({{"error", "Scene and source inputs have same name"}})).dump();
		return;
	}

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, scene_name, source_name, &out_jsonReturn]() {
			OBSSourceAutoRelease scene = obs_get_source_by_name(scene_name.c_str());
			OBSSourceAutoRelease source = obs_get_source_by_name(source_name.c_str());
			if (!scene)
				out_jsonReturn = Json(Json::object({{"error", "Did not find an object with name " + scene_name}})).dump();
			else if (!source)
				out_jsonReturn = Json(Json::object({{"error", "Did not find an object with name " + source_name}})).dump();
			else if (!obs_source_is_scene(scene))
				out_jsonReturn = Json(Json::object({{"error", "The object found is not a scene"}})).dump();
			else
			{
				obs_scene_t *scene_obj = obs_scene_from_source(scene);

				if (obs_scene_find_source(scene_obj, source_name.c_str()))
				{
					out_jsonReturn = Json(Json::object({{"error", "The source is already in the scene"}})).dump();
					return;
				}

				obs_sceneitem_t *scene_item = obs_scene_add(scene_obj, source);
				if (!scene_item)
					out_jsonReturn = Json(Json::object({{"error", "Failed to add source to scene"}})).dump();
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_SOURCE_GET_PROPERTIES(const json11::Json& params, std::string& out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	std::string source_name = param2Value.string_value();

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, source_name, &out_jsonReturn]() {
			OBSSourceAutoRelease existingSource = obs_get_source_by_name(source_name.c_str());

			if (existingSource == nullptr)
			{
				out_jsonReturn = Json(Json::object({{"error", "Source not found: " + source_name}})).dump();
				return;
			}

			obs_properties_t *prp = obs_source_properties(existingSource);
			obs_data_t *settings = obs_source_get_settings(existingSource);

			Json::array jsonProperties;

			const char *buf = nullptr;
			for (obs_property_t *p = obs_properties_first(prp); (p != nullptr); obs_property_next(&p))
			{
				Json::object propJson;
				const char *name = obs_property_name(p);

				switch (obs_property_get_type(p))
				{
				case OBS_PROPERTY_BOOL:
				{
					propJson = {{name, obs_data_get_bool(settings, name)}};
					break;
				}
				case OBS_PROPERTY_INT:
				{
					Json::object valueObj;
					valueObj["type"] = "integer";
					valueObj["value"] = (int)obs_data_get_int(settings, name);
					valueObj["min"] = obs_property_int_min(p);
					valueObj["max"] = obs_property_int_max(p);
					valueObj["step"] = obs_property_int_step(p);
					propJson[name] = valueObj;
					break;
				}
				case OBS_PROPERTY_FLOAT:
				{
					Json::object valueObj = {{"type", "float"}, {"value", obs_data_get_double(settings, name)}, {"min", obs_property_float_min(p)}, {"max", obs_property_float_max(p)}, {"step", obs_property_float_step(p)}};
					propJson[name] = valueObj;
					break;
				}
				case OBS_PROPERTY_TEXT:
				{
					const char *valueBuf = obs_data_get_string(settings, name);
					std::string value = valueBuf ? valueBuf : "";
					Json::object valueObj = {{"type", "text"}, {"value", value}};
					propJson[name] = valueObj;
					break;
				}
				case OBS_PROPERTY_PATH: {
					const char *valueBuf = obs_data_get_string(settings, name);
					const char *filterBuf = obs_property_path_filter(p);
					const char *defaultPathBuf = obs_property_path_default_path(p);

					Json::object valueObj = {{"type", "path"}, {"value", valueBuf ? valueBuf : ""}, {"filter", filterBuf ? filterBuf : ""}, {"default_path", defaultPathBuf ? defaultPathBuf : ""}};
					propJson[name] = valueObj;
					break;
				}
				case OBS_PROPERTY_LIST:
				{
					enum ListType
					{
						InvalidListType,
						Editable,
						List,
					};

					enum Format
					{
						InvalidFormat,
						Integer,
						Float,
						String,
					};

					Json::array itemsArray;
					size_t items = obs_property_list_item_count(p);

					ListType fieldType = ListType(obs_property_list_type(p));
					Format format = Format(obs_property_list_format(p));

					for (size_t idx = 0; idx < items; ++idx)
					{
						const char *itemBuf = obs_property_list_item_name(p, idx);
						Json::object entry = {{"name", itemBuf ? itemBuf : ""}, {"enabled", !obs_property_list_item_disabled(p, idx)}};

						switch (format)
						{
						case Format::Integer:
							entry["value_int"] = (int)obs_property_list_item_int(p, idx);
							break;
						case Format::Float:
							entry["value_float"] = obs_property_list_item_float(p, idx);
							break;
						case Format::String:
							entry["value_string"] = (itemBuf = obs_property_list_item_string(p, idx)) ? itemBuf : "";
							break;
						}
						itemsArray.push_back(entry);
					}

					Json::object listObj = {{"type", "list"},
								{"field_type", static_cast<int>(fieldType)}, // Assuming you want to store the enum value
								{"format", static_cast<int>(format)},
								{"items", itemsArray}};

					propJson[name] = listObj;
					break;
				}

				case OBS_PROPERTY_COLOR_ALPHA:
				case OBS_PROPERTY_COLOR:
				{
					propJson["type"] = "ColorProperty";
					propJson["field_type"] = (int)obs_property_int_type(p);
					propJson["value"] = (int)obs_data_get_int(settings, name);
					break;
				}
				case OBS_PROPERTY_BUTTON:
					propJson["type"] = "ButtonProperty";
					break;
				case OBS_PROPERTY_FONT:
				{
					obs_data_t *font_obj = obs_data_get_obj(settings, name);
					propJson["type"] = "FontProperty";
					propJson["face"] = (buf = obs_data_get_string(font_obj, "face")) != nullptr ? buf : "";
					propJson["style"] = (buf = obs_data_get_string(font_obj, "style")) != nullptr ? buf : "";
					propJson["path"] = (buf = obs_data_get_string(font_obj, "path")) != nullptr ? buf : "";
					propJson["size"] = (int)obs_data_get_int(font_obj, "size");
					propJson["flags"] = (int)obs_data_get_int(font_obj, "flags");
					break;
				}
				case OBS_PROPERTY_EDITABLE_LIST:
				{
					propJson["type"] = "EditableListProperty";
					propJson["field_type"] = int(obs_property_editable_list_type(p));
					propJson["filter"] = (buf = obs_property_editable_list_filter(p)) != nullptr ? buf : "";
					propJson["default_path"] = (buf = obs_property_editable_list_default_path(p)) != nullptr ? buf : "";

					obs_data_array_t *array = obs_data_get_array(settings, name);
					size_t count = obs_data_array_count(array);
					json11::Json::array valuesArray;

					for (size_t idx = 0; idx < count; ++idx)
					{
						obs_data_t *item = obs_data_array_item(array, idx);
						valuesArray.push_back((buf = obs_data_get_string(item, "value")) != nullptr ? buf : "");
					}
					propJson["values"] = valuesArray;
					break;
				}

				case OBS_PROPERTY_FRAME_RATE:
				{
					propJson["type"] = "FrameRateProperty";
					size_t num_ranges = obs_property_frame_rate_fps_ranges_count(p);
					json11::Json::array rangesArray;

					for (size_t idx = 0; idx < num_ranges; idx++)
					{
						auto min = obs_property_frame_rate_fps_range_min(p, idx);
						auto max = obs_property_frame_rate_fps_range_max(p, idx);

						json11::Json::object minObj;
						minObj["numerator"] = (int)min.numerator;
						minObj["denominator"] = (int)min.denominator;

						json11::Json::object maxObj;
						maxObj["numerator"] = (int)max.numerator;
						maxObj["denominator"] = (int)max.denominator;

						json11::Json::object rangeObj;
						rangeObj["minimum"] = minObj;
						rangeObj["maximum"] = maxObj;

						rangesArray.push_back(rangeObj);
					}

					propJson["ranges"] = rangesArray;

					size_t num_options = obs_property_frame_rate_options_count(p);
					json11::Json::array optionsArray;

					for (size_t idx = 0; idx < num_options; idx++)
					{
						auto min = obs_property_frame_rate_fps_range_min(p, idx), max = obs_property_frame_rate_fps_range_max(p, idx);
						json11::Json::object optionObj;

						optionObj["name"] = (buf = obs_property_frame_rate_option_name(p, idx)) != nullptr ? buf : "";
						optionObj["description"] = (buf = obs_property_frame_rate_option_description(p, idx)) != nullptr ? buf : "";

						optionsArray.push_back(optionObj);
					}
					propJson["options"] = optionsArray;

					media_frames_per_second fps = {};
					if (obs_data_get_frames_per_second(settings, name, &fps, nullptr))
						propJson["current_fps"] = json11::Json::object{{"numerator", (int)fps.numerator}, {"denominator", (int)fps.denominator}};

					break;
				}
				}

				jsonProperties.push_back(propJson);
			}

			Json output = jsonProperties;
			out_jsonReturn = output.dump();
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_CREATE_SCENE(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	std::string scene_name = param2Value.string_value();

	if (scene_name.empty() || scene_name.size() > 1024)
	{
		out_jsonReturn = Json(Json::object({{"error", "Invalid scene name " + scene_name}})).dump();
		return;
	}

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, scene_name, &out_jsonReturn]() {
			OBSSourceAutoRelease existing = obs_get_source_by_name(scene_name.c_str());

			if (existing != nullptr)
			{
				out_jsonReturn = Json(Json::object({{"error", "Source with that name exists"}})).dump();
				return;
			}

			OBSSceneAutoRelease scene = obs_scene_create(scene_name.c_str());
			if (!scene)
				out_jsonReturn = Json(Json::object({{"error", "Failed to create scene."}})).dump();
						
		},
		Qt::BlockingQueuedConnection);
}

// One job object shared by every exe we launch. KILL_ON_JOB_CLOSE ties them all to our lifetime,
// so this handle is created once and released in the destructor rather than per launch.
HANDLE PluginJsHandler::getChildJob()
{
	if (m_childJob)
		return m_childJob;

	HANDLE job = CreateJobObjectW(nullptr, nullptr);

	if (!job)
		return nullptr;

	JOBOBJECT_EXTENDED_LIMIT_INFORMATION jobInfo = {};
	jobInfo.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;

	if (!SetInformationJobObject(job, JobObjectExtendedLimitInformation, &jobInfo, sizeof(jobInfo)))
	{
		// Without the limit the job buys us nothing, so don't hold a handle to it.
		CloseHandle(job);
		return nullptr;
	}

	m_childJob = job;
	return m_childJob;
}

// A process handle is signalled once the process ends, so this answers the question exactly.
// GetExitCodeProcess cannot: STILL_ACTIVE is 259, which is also a legal exit code, so a child
// that exits with 259 would read as running for as long as the plugin is up.
static bool isChildRunning(HANDLE process)
{
	return WaitForSingleObject(process, 0) == WAIT_TIMEOUT;
}

// Release the children that have already exited. A zero timeout makes each check a state query
// rather than a wait, so this stays cheap even over a map that has got out of hand, and it is
// the same predicate sys_isProcessRunning answers with - nothing is dropped here that it would
// still call running.
size_t PluginJsHandler::reapExitedChildren()
{
	size_t reaped = 0;

	for (auto it = m_childProcesses.begin(); it != m_childProcesses.end();)
	{
		if (isChildRunning(it->second))
		{
			++it;
			continue;
		}

		CloseHandle(it->second);
		it = m_childProcesses.erase(it);
		++reaped;
	}

	return reaped;
}

void PluginJsHandler::JS_RUN_STREAMLABS_EXE(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	std::string fileName = param2Value.string_value();
	const bool hideWindow = params["param3"].bool_value();

	std::wstring folderPath = getDownloadsDir();

	// Confined like every other path this api takes: only something we put in the Streamlabs
	// folder may be launched. A name relative to that folder and an absolute path inside it -
	// which is the shape fs_downloadZip hands back - both resolve; anything else is refused.
	std::filesystem::path resolved;
	std::string err;

	if (!resolveWithinDownloads(folderPath, fileName, resolved, err))
	{
		out_jsonReturn = Json(Json::object({{"success", false}, {"error", err}})).dump();
		return;
	}

	std::wstring fullPath = resolved.wstring();

	// Tie the child's lifetime to ours: the launched exe is terminated if this (parent) process goes away.
	HANDLE hJob = getChildJob();

	STARTUPINFOW si = {sizeof(si)};
	PROCESS_INFORMATION pi = {};
	DWORD creationFlags = CREATE_SUSPENDED;

	if (hideWindow)
	{
		// SW_HIDE hides a GUI window; CREATE_NO_WINDOW suppresses the console a console app would otherwise get.
		si.dwFlags |= STARTF_USESHOWWINDOW;
		si.wShowWindow = SW_HIDE;
		creationFlags |= CREATE_NO_WINDOW;
	}

	BOOL success = CreateProcessW(fullPath.c_str(), nullptr, nullptr, nullptr, FALSE, creationFlags, nullptr, folderPath.c_str(), &si, &pi);

	if (success)
	{
		if (hJob)
			AssignProcessToJobObject(hJob, pi.hProcess);

		ResumeThread(pi.hThread);
		CloseHandle(pi.hThread);

		// Drained since the last pile-up, so a fresh one should warn from the floor again rather
		// than inherit a raised mark. Checked here rather than after the sweep below: the map
		// also shrinks through sys_stopProcess and sys_isProcessRunning, neither of which comes
		// anywhere near this branch.
		if (m_childProcesses.size() < kChildReapAt)
			m_childWarnAt = kChildReapAt;

		m_childProcesses[pi.dwProcessId] = pi.hProcess;

		// Nothing here on a normal launch: the branch is not taken until a caller has piled up
		// kChildReapAt of them without ever asking about one.
		if (m_childProcesses.size() >= kChildReapAt)
		{
			const size_t reaped = reapExitedChildren();
			const size_t live = m_childProcesses.size();

			if (live >= m_childWarnAt)
			{
				// Sweeping released nothing like enough, so these really are still running: a
				// caller leaking processes rather than handles, which is worth seeing in a log.
				blog(LOG_WARNING, "PluginJsHandler::JS_RUN_STREAMLABS_EXE %zu child processes are still running (released %zu)", live, reaped);
				m_childWarnAt = live * 2;
			}
		}

		out_jsonReturn = Json(Json::object({{"success", true}, {"pid", (int)pi.dwProcessId}})).dump();
	}
	else
	{
		out_jsonReturn = Json(Json::object({{"success", false}, {"error", "CreateProcess failed with error " + std::to_string(GetLastError())}})).dump();
	}
}

void PluginJsHandler::JS_DOWNLOAD_ZIP(const Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	std::string url = param2Value.string_value();

	// Optional SHA-256 (hex). When provided, the downloaded zip must match it before we unpack anything.
	std::string expectedSha = params["param3"].string_value();
	std::wstring folderPath = getDownloadsDir();

	if (!folderPath.empty())
	{
		using namespace std::chrono;

		// Current time in miliseconds
		system_clock::time_point now = system_clock::now();
		auto duration = now.time_since_epoch();
		auto millis = duration_cast<milliseconds>(duration).count();
		std::wstring millis_str = std::to_wstring(millis);

		// ThreadID + MsTime should be unique, same threaID within 1ms window is a statistical improbability
		std::wstring subFolderPath = folderPath + L"\\" + std::to_wstring(GetCurrentThreadId()) + millis_str;
		std::wstring zipFilepath = subFolderPath + L"\\download.zip";

		CreateDirectoryW(folderPath.c_str(), NULL);
		CreateDirectoryW(subFolderPath.c_str(), NULL);

		if (WindowsFunctions::DownloadFile(url, ws_to_utf8(zipFilepath)))
		{
			// Verify the checksum (if one was supplied) before trusting the archive.
			bool shaOk = true;
			std::string shaError;

			if (!expectedSha.empty())
			{
				std::string actualSha;
				std::string hashErr;

				if (!sha256File(zipFilepath, actualSha, hashErr))
				{
					shaOk = false;
					shaError = "Failed to hash downloaded file: " + hashErr;
				}
				else
				{
					// Lowercase the expected hex so the compare is case-insensitive (actualSha is already lowercase).
					std::string expectedLower = expectedSha;
					for (char &c : expectedLower)
					{
						if (c >= 'A' && c <= 'Z')
							c = (char)(c - 'A' + 'a');
					}

					if (actualSha != expectedLower)
					{
						shaOk = false;
						shaError = "SHA-256 mismatch: expected " + expectedLower + ", got " + actualSha;
					}
				}
			}

			if (!shaOk)
			{
				out_jsonReturn = Json(Json::object({{"error", shaError}})).dump();
			}
			else
			{
				std::vector<std::string> filepaths;

				if (WindowsFunctions::Unzip(ws_to_utf8(zipFilepath), filepaths))
				{
					// Build json string now
					Json::array json_array;

					for (const auto &filepath : filepaths)
					{
						Json::object obj;
						obj["path"] = filepath;
						json_array.push_back(obj);
					}

					out_jsonReturn = Json(json_array).dump();
				}
				else
				{
					out_jsonReturn = Json(Json::object({{"error", "Unzip file failed"}})).dump();
				}
			}
		}
		else
		{
			out_jsonReturn = Json(Json::object({{"error", "Http download file failed"}})).dump();
		}

		// zip file itself not needed
		::_wremove(zipFilepath.c_str());
	}
	else
	{
		out_jsonReturn = Json(Json::object({{"error", "File system can't access Local AppData folder"}})).dump();
	}
}

void PluginJsHandler::JS_DOWNLOAD_FILE(const Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];

	std::string url = param2Value.string_value();
	std::string filename = param3Value.string_value();
	std::wstring folderPath = getDownloadsDir();

	if (filename.empty() || url.empty())
	{
		out_jsonReturn = Json(Json::object({{"error", "Invalid params"}})).dump();
		return;
	}

	/*
	 * The filename comes from the page and is concatenated onto a directory we made, so without
	 * this a caller could walk back out of the Streamlabs folder with '..' and have the download
	 * written anywhere it can reach.
	 *
	 * Checked as a leaf name rather than by resolving and comparing, because that is the whole
	 * contract here: the api documents a filename, and the directory it goes in is created empty
	 * for this one call, so a name carrying a separator or a drive had nowhere to land anyway.
	 * filename() differs from the path itself for exactly those, and '.' and '..' survive it.
	 */
	const std::filesystem::path leaf = utf8_to_ws(filename);

	if (leaf != leaf.filename() || leaf.filename() == L"." || leaf.filename() == L"..")
	{
		// The rejected name is not quoted back: it is the caller's bytes, and json11 emits string
		// bytes as they are, so echoing them can make the reply itself malformed.
		out_jsonReturn = Json(Json::object({{"error", "Invalid filename (a plain file name is expected)"}})).dump();
		return;
	}

	if (!folderPath.empty())
	{
		using namespace std::chrono;

		// Current time in miliseconds
		system_clock::time_point now = system_clock::now();
		auto duration = now.time_since_epoch();
		auto millis = duration_cast<milliseconds>(duration).count();
		std::wstring millis_str = std::to_wstring(millis);

		// ThreadID + MsTime should be unique, same threaID within 1ms window is a statistical improbability
		std::wstring subFolderPath = folderPath + L"\\" + std::to_wstring(GetCurrentThreadId()) + millis_str;
		std::wstring downloadPath = subFolderPath + L"\\" + leaf.wstring();

		CreateDirectoryW(folderPath.c_str(), NULL);
		CreateDirectoryW(subFolderPath.c_str(), NULL);

		// ws_to_utf8 on the way out too: json11 has no wstring constructor, so a std::wstring
		// matches its vector-like one and this answered with an array of utf-16 code units
		// rather than the path string the api documents.
		if (WindowsFunctions::DownloadFile(url, ws_to_utf8(downloadPath)))
			out_jsonReturn = Json(Json::object({{"path", ws_to_utf8(downloadPath)}})).dump();
		else
			out_jsonReturn = Json(Json::object({{"error", "Http download file failed"}})).dump();
	}
	else
	{
		out_jsonReturn = Json(Json::object({{"error", "File system can't access Local AppData folder"}})).dump();
	}
}

void PluginJsHandler::JS_INSTALL_FONT(const json11::Json& params, std::string& out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	std::string filepath = param2Value.string_value();

	if (filepath.empty())
	{
		out_jsonReturn = Json(Json::object({{"error", "Invalid param"}})).dump();
		return;
	}

	if (WindowsFunctions::InstallFont(filepath.c_str()))
	{
		int id = QFontDatabase::addApplicationFont(filepath.c_str());

		if (id != -1)
		{
			std::wstring fontDir = getFontsDir();

			try
			{
				// Create the fonts directory if it does not exist
				std::filesystem::create_directories(fontDir);

				// Copy the file, overwrite if it already exists
				std::filesystem::path destPath = fontDir;
				destPath /= std::filesystem::path(filepath).filename();
				std::filesystem::copy(filepath, destPath, std::filesystem::copy_options::overwrite_existing);
			}
			catch (const std::filesystem::filesystem_error &e)
			{
				out_jsonReturn = Json(Json::object({{"error", e.what()}})).dump();
				return;
			}

			out_jsonReturn = Json(Json::object{{"status", "success"}}).dump();
		}
		else
		{
			out_jsonReturn = Json(Json::object({{"error", "QFontDatabase addApplicationFont failed"}})).dump();
		}
	}
	else
	{
		out_jsonReturn = Json(Json::object({{"error", "WinApi AddFontResourceA failed"}})).dump();
	}
}

void PluginJsHandler::JS_READ_FILE(const Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];

	std::string filepath = param2Value.string_value();
	std::string filecontents;

	std::ifstream file(filepath, std::ios::binary | std::ios::ate);

	Json ret;

	if (file)
	{
		try
		{
			// Get the file size
			std::streamsize fileSize = file.tellg();
			file.seekg(0, std::ios::beg);

			// Check if file size is 1MB or higher
			if (fileSize >= 1048576)
			{
				ret = Json::object({{"error", "File size is 1MB or higher"}});
			}
			else
			{
				std::stringstream buffer;
				buffer << file.rdbuf();
				filecontents = buffer.str();
				ret = Json::object({{"contents", filecontents}});
			}
		}
		catch (...)
		{
			ret = Json::object({{"error", "Unable to read file. Checking for windows errors: '" + std::to_string(GetLastError()) + "'"}});
		}
	}
	else
	{
		ret = Json::object({{"error", "Unable to open file. Checking for windows errors: '" + std::to_string(GetLastError()) + "'"}});
	}

	out_jsonReturn = ret.dump();
}

void PluginJsHandler::JS_DELETE_FILES(const Json &params, std::string &out_jsonReturn)
{
	Json ret;
	std::vector<std::string> errors;
	std::vector<std::string> success;

	const auto &param2Value = params["param2"];

	std::string err;
	Json jsonArray = Json::parse(params["param2"].string_value().c_str(), err);

	if (!err.empty())
	{
		out_jsonReturn = Json(Json::object({{"error", "Invalid parameter: " + err}})).dump();
		return;
	}

	const auto &filepaths = jsonArray.array_items();

	for (const auto &filepathJson : filepaths)
	{
		if (filepathJson.is_object())
		{
			const auto &filepath = filepathJson["path"].string_value();

			std::filesystem::path downloadsDir = std::filesystem::path(getDownloadsDir());
			std::filesystem::path fullPath = downloadsDir / filepath;
			std::filesystem::path normalizedPath = fullPath.lexically_normal();

			// Check if filepath contains relative components that move outside the downloads directory
			if (normalizedPath.string().find(downloadsDir.string()) != 0)
			{
				errors.push_back("Invalid path: " + filepath);
			}
			else
			{
				try
				{
					if (std::filesystem::exists(normalizedPath))
					{
						std::filesystem::remove(normalizedPath);
						success.push_back(filepath);
					}
					else
					{
						errors.push_back("File not found: " + filepath);
					}
				}
				catch (const std::filesystem::filesystem_error &e)
				{
					errors.push_back("Error deleting file '" + filepath + "': " + e.what());
				}
			}
		}
	}

	out_jsonReturn = Json(Json::object({{"success", success}, {"errors", errors}})).dump();
}

void PluginJsHandler::JS_DROP_FOLDER(const Json &params, std::string &out_jsonReturn)
{
	const auto &filepath = params["param2"].string_value();

	std::filesystem::path downloadsDir = std::filesystem::path(getDownloadsDir());
	std::filesystem::path fullPath = downloadsDir / filepath;
	std::filesystem::path normalizedPath = fullPath.lexically_normal();

	// Check if filepath contains relative components that move outside the downloads directory
	if (normalizedPath.string().find(downloadsDir.string()) != 0)
	{
		out_jsonReturn = Json(Json::object({{"error", "Invalid path: " + filepath}})).dump();
	}
	else
	{
		try
		{
			std::filesystem::remove_all(normalizedPath);
		}
		catch (const std::filesystem::filesystem_error &e)
		{
			out_jsonReturn = Json(Json::object({{"error", "Failed to delete '" + filepath + "': " + e.what()}})).dump();
		}
	}
}

void PluginJsHandler::JS_GET_LOGS_REPORT_STRING(const json11::Json& params, std::string& out_jsonReturn)
{
	std::string fullReport;

	namespace fs = std::filesystem;

	#define maxLogFileSize 2097152

	auto processLogFile = [](const fs::path &filePath, std::string &fullReport)
	{
		std::ifstream file(filePath, std::ios::binary | std::ios::ate);
		auto fileSize = file.tellg();

		if (fileSize > maxLogFileSize)
		{
			// File size is greater than 2 MB
			// Move to 2 MB before the end of the file
			file.seekg(-maxLogFileSize, std::ios::end);
		}
		else
		{
			// Start from the beginning if file is under 2 MB
			file.seekg(0, std::ios::beg);
		}

		// Read the file content
		std::vector<char> buffer(std::istreambuf_iterator<char>(file), {});
		fullReport += "-- " + filePath.filename().string() + " --\n\n";
		fullReport.append(buffer.begin(), buffer.end());
		fullReport += "\n\n-- END OF FILE --\n\n";
	};

	std::string appDataPath = getenv("APPDATA");
	std::string programDataPath = getenv("PROGRAMDATA");
	std::string logDir = appDataPath + "\\obs-studio\\logs";
	std::string cefLogPath = appDataPath + "\\StreamlabsOBS_CEF_Cache\\cef.log";
	std::string streamlabsServiceDir = programDataPath + "\\StreamlabsService";

	try
	{
		std::size_t currentLogDirSize = 0;

		// Process OBS log files
		if (fs::exists(logDir) && fs::is_directory(logDir))
		{
			std::vector<fs::directory_entry> entries(fs::directory_iterator(logDir), {});
			std::sort(entries.begin(), entries.end(), [](const fs::directory_entry &a, const fs::directory_entry &b) { return fs::last_write_time(a) > fs::last_write_time(b); });

			for (const auto &entry : entries)
			{
				const auto &path = entry.path();
				if (path.extension() == ".txt")
				{
					std::ifstream file(path, std::ios::binary | std::ios::ate);
					auto fileSize = file.tellg();

					if (currentLogDirSize + fileSize > maxLogFileSize)
					{
						fullReport += "-- " + path.filename().string() + " --\n\n";
						fullReport += "File too large to fit in report.\n\n";
						continue;
					}

					processLogFile(path, fullReport);
					currentLogDirSize += fileSize;

					if (currentLogDirSize >= maxLogFileSize)
						break;
				}
			}
		}

		// Process the CEF log file
		if (fs::exists(cefLogPath))
			processLogFile(cefLogPath, fullReport);

		// Process Streamlabs Service log and text files with size check
		if (fs::exists(streamlabsServiceDir) && fs::is_directory(streamlabsServiceDir))
		{
			for (const auto &entry : fs::directory_iterator(streamlabsServiceDir))
			{
				const auto &path = entry.path();

				if (path.extension() == ".log" || path.extension() == ".txt")
					processLogFile(path, fullReport);
			}
		}
	}
	catch (const fs::filesystem_error &e)
	{
		std::string err = e.what();
		out_jsonReturn = Json(Json::object({{"error", err}})).dump();
	}
	catch (const std::exception &e)
	{
		std::string err = e.what();
		out_jsonReturn = Json(Json::object({{"error", err}})).dump();
	}
	catch (...)
	{
		out_jsonReturn = Json(Json::object({{"error", "Unknown Exception"}})).dump();
	}

	if (fullReport.empty())
		out_jsonReturn = Json(Json::object({{"error", "Empty Report"}})).dump();
	else
		out_jsonReturn = Json(Json::object({{"content", fullReport}})).dump();
}


void PluginJsHandler::JS_QUERY_DOWNLOADS_FOLDER(const Json &params, std::string &out_jsonReturn)
{
	std::wstring downloadsFolderFullPath = getDownloadsDir();
	std::vector<Json> pathsList;

	try
	{
		// Use recursive_directory_iterator for recursive traversal
		for (const auto &entry : std::filesystem::recursive_directory_iterator(downloadsFolderFullPath))
			pathsList.push_back(entry.path().generic_string());

		out_jsonReturn = Json(Json::array(pathsList)).dump();
	}
	catch (const std::filesystem::filesystem_error &e)
	{
		out_jsonReturn = Json(Json::object({{"error", "Failed to query downloads folder: " + std::string(e.what())}})).dump();
	}
}

void PluginJsHandler::JS_PATH_JOIN(const Json &params, std::string &out_jsonReturn)
{
	const std::string a = params["param2"].string_value();
	const std::string b = params["param3"].string_value();

	if (a.empty() && b.empty())
	{
		out_jsonReturn = Json(Json::object({{"error", "Invalid params"}})).dump();
		return;
	}

	std::filesystem::path joined;

	if (a.empty())
		joined = std::filesystem::path(utf8_to_ws(b));
	else if (b.empty())
		joined = std::filesystem::path(utf8_to_ws(a));
	else
		joined = std::filesystem::path(utf8_to_ws(a)) / std::filesystem::path(utf8_to_ws(b));

	joined = joined.make_preferred();

	out_jsonReturn = Json(Json::object({{"path", ws_to_utf8(joined.wstring())}})).dump();
}

void PluginJsHandler::JS_GET_ENV_VAR(const Json &params, std::string &out_jsonReturn)
{
	const std::string varName = params["param2"].string_value();

	if (varName.empty())
	{
		out_jsonReturn = Json(Json::object({{"error", "Invalid param"}})).dump();
		return;
	}

	std::wstring wName = utf8_to_ws(varName);

	// First call sizes the buffer (return value includes the null terminator when the var exists).
	DWORD needed = GetEnvironmentVariableW(wName.c_str(), nullptr, 0);

	if (needed == 0)
	{
		out_jsonReturn = Json(Json::object({{"error", "Environment variable not set: " + varName}})).dump();
		return;
	}

	std::wstring value(needed, L'\0');
	DWORD written = GetEnvironmentVariableW(wName.c_str(), value.data(), needed);

	// 'written' excludes the null terminator
	value.resize(written); 

	out_jsonReturn = Json(Json::object({{"value", ws_to_utf8(value)}})).dump();
}

void PluginJsHandler::JS_MKDIR(const Json &params, std::string &out_jsonReturn)
{
	const std::string inputPath = params["param2"].string_value();

	std::filesystem::path resolved;
	std::string err;

	if (!resolveWithinDownloads(getDownloadsDir(), inputPath, resolved, err))
	{
		out_jsonReturn = Json(Json::object({{"error", err}})).dump();
		return;
	}

	std::error_code ec;
	std::filesystem::create_directories(resolved, ec);

	// create_directories returns false (with no error_code) when the directory already exists - that's fine.
	if (ec)
		out_jsonReturn = Json(Json::object({{"error", "Failed to create directory: " + ec.message()}})).dump();
	else
		out_jsonReturn = Json(Json::object({{"success", true}})).dump();
}

void PluginJsHandler::JS_PATH_EXISTS(const Json &params, std::string &out_jsonReturn)
{
	const std::string inputPath = params["param2"].string_value();

	std::filesystem::path resolved;
	std::string err;

	// Confined like the rest, so this can't be used to probe for arbitrary files outside the folder.
	if (!resolveWithinDownloads(getDownloadsDir(), inputPath, resolved, err))
	{
		out_jsonReturn = Json(Json::object({{"error", err}})).dump();
		return;
	}

	std::error_code ec;
	bool exists = std::filesystem::exists(resolved, ec);
	bool isDirectory = exists && std::filesystem::is_directory(resolved, ec);

	out_jsonReturn = Json(Json::object({{"exists", exists}, {"isDirectory", isDirectory}})).dump();
}

void PluginJsHandler::JS_REMOVE_PATH(const Json &params, std::string &out_jsonReturn)
{
	const std::string inputPath = params["param2"].string_value();
	const bool recursive = params["param3"].bool_value();
	const bool force = params["param4"].bool_value();

	std::filesystem::path resolved;
	std::string err;

	if (!resolveWithinDownloads(getDownloadsDir(), inputPath, resolved, err))
	{
		out_jsonReturn = Json(Json::object({{"error", err}})).dump();
		return;
	}

	std::error_code ec;

	if (!std::filesystem::exists(resolved, ec))
	{
		// 'force' mirrors 'rm -f': a missing target is not an error.
		if (force)
			out_jsonReturn = Json(Json::object({{"success", true}})).dump();
		else
			out_jsonReturn = Json(Json::object({{"error", "Path not found: " + inputPath}})).dump();

		return;
	}

	const bool isDir = std::filesystem::is_directory(resolved, ec);

	if (isDir && recursive)
	{
		std::filesystem::remove_all(resolved, ec);
	}
	else if (isDir && !recursive)
	{
		// Without 'recursive' this only succeeds on an empty directory, matching 'rmdir' / 'rm' semantics.
		std::filesystem::remove(resolved, ec);

		if (ec)
		{
			out_jsonReturn = Json(Json::object({{"error", "Directory not empty (pass recursive=true): " + inputPath}})).dump();
			return;
		}
	}
	else
	{
		std::filesystem::remove(resolved, ec);
	}

	if (ec)
		out_jsonReturn = Json(Json::object({{"error", "Failed to remove '" + inputPath + "': " + ec.message()}})).dump();
	else
		out_jsonReturn = Json(Json::object({{"success", true}})).dump();
}

void PluginJsHandler::JS_MOVE_PATH(const Json &params, std::string &out_jsonReturn)
{
	const std::string srcInput = params["param2"].string_value();
	const std::string dstInput = params["param3"].string_value();

	const std::wstring downloadsDir = getDownloadsDir();

	std::filesystem::path srcResolved;
	std::filesystem::path dstResolved;
	std::string err;

	// Both endpoints must live inside the Streamlabs folder.
	if (!resolveWithinDownloads(downloadsDir, srcInput, srcResolved, err))
	{
		out_jsonReturn = Json(Json::object({{"error", "Source: " + err}})).dump();
		return;
	}

	if (!resolveWithinDownloads(downloadsDir, dstInput, dstResolved, err))
	{
		out_jsonReturn = Json(Json::object({{"error", "Destination: " + err}})).dump();
		return;
	}

	std::error_code ec;

	if (!std::filesystem::exists(srcResolved, ec))
	{
		out_jsonReturn = Json(Json::object({{"error", "Source path not found: " + srcInput}})).dump();
		return;
	}

	// Refuse to clobber an existing destination. The updater is expected to move the old target out of
	// the way first, which keeps the swap predictable and avoids accidentally destroying data on overwrite.
	if (std::filesystem::exists(dstResolved, ec))
	{
		out_jsonReturn = Json(Json::object({{"error", "Destination already exists: " + dstInput}})).dump();
		return;
	}

	std::filesystem::rename(srcResolved, dstResolved, ec);

	if (ec)
	{
		// rename() can't move across volumes; fall back to a recursive copy followed by deleting the source.
		std::error_code copyEc;
		std::filesystem::copy(srcResolved, dstResolved, std::filesystem::copy_options::recursive, copyEc);

		if (copyEc)
		{
			out_jsonReturn = Json(Json::object({{"error", "Failed to move '" + srcInput + "' to '" + dstInput + "': " + copyEc.message()}})).dump();
			return;
		}

		std::error_code removeEc;
		std::filesystem::remove_all(srcResolved, removeEc);

		if (removeEc)
		{
			out_jsonReturn = Json(Json::object({{"error", "Copied to destination but failed to remove source '" + srcInput + "': " + removeEc.message()}})).dump();
			return;
		}
	}

	out_jsonReturn = Json(Json::object({{"success", true}})).dump();
}

void PluginJsHandler::JS_SHA256_FILE(const Json &params, std::string &out_jsonReturn)
{
	const std::string inputPath = params["param2"].string_value();

	std::filesystem::path resolved;
	std::string err;

	if (!resolveWithinDownloads(getDownloadsDir(), inputPath, resolved, err))
	{
		out_jsonReturn = Json(Json::object({{"error", err}})).dump();
		return;
	}

	std::error_code ec;

	if (!std::filesystem::exists(resolved, ec) || std::filesystem::is_directory(resolved, ec))
	{
		out_jsonReturn = Json(Json::object({{"error", "File not found: " + inputPath}})).dump();
		return;
	}

	std::string digest;
	std::string hashErr;

	if (sha256File(resolved, digest, hashErr))
		out_jsonReturn = Json(Json::object({{"sha256", digest}})).dump();
	else
		out_jsonReturn = Json(Json::object({{"error", hashErr}})).dump();
}

void PluginJsHandler::JS_WRITE_FILE(const Json &params, std::string &out_jsonReturn)
{
	const std::string inputPath = params["param2"].string_value();
	const std::string contents = params["param3"].string_value();
	const bool append = params["param4"].bool_value();

	std::filesystem::path resolved;
	std::string err;

	if (!resolveWithinDownloads(getDownloadsDir(), inputPath, resolved, err))
	{
		out_jsonReturn = Json(Json::object({{"error", err}})).dump();
		return;
	}

	std::ios::openmode mode = std::ios::binary | std::ios::out;
	mode |= append ? std::ios::app : std::ios::trunc;

	std::ofstream file(resolved, mode);

	if (!file)
	{
		out_jsonReturn = Json(Json::object({{"error", "Unable to open file for writing (does the parent directory exist?): " + inputPath}})).dump();
		return;
	}

	file.write(contents.data(), (std::streamsize)contents.size());
	file.flush();

	if (!file)
	{
		out_jsonReturn = Json(Json::object({{"error", "Failed while writing file: " + inputPath}})).dump();
		return;
	}

	out_jsonReturn = Json(Json::object({{"success", true}, {"bytesWritten", (int)contents.size()}})).dump();
}

void PluginJsHandler::JS_IS_PROCESS_RUNNING(const Json &params, std::string &out_jsonReturn)
{
	DWORD pid = (DWORD)params["param2"].int_value();

	bool running = false;

	auto it = m_childProcesses.find(pid);

	if (it != m_childProcesses.end())
	{
		if (isChildRunning(it->second))
		{
			running = true;
		}
		else
		{
			// Process has exited - release it.
			CloseHandle(it->second);
			m_childProcesses.erase(it);
		}
	}

	out_jsonReturn = Json(Json::object({{"running", running}})).dump();
}

void PluginJsHandler::JS_STOP_PROCESS(const Json &params, std::string &out_jsonReturn)
{
	DWORD pid = (DWORD)params["param2"].int_value();

	auto it = m_childProcesses.find(pid);

	if (it == m_childProcesses.end())
	{
		out_jsonReturn = Json(Json::object({{"success", false}, {"error", "Unknown pid (not a process we started)"}})).dump();
		return;
	}

	BOOL terminated = TerminateProcess(it->second, 0);
	DWORD err = terminated ? 0 : GetLastError();

	// Either way we're done tracking this pid: release the handle and drop it from the cache.
	CloseHandle(it->second);
	m_childProcesses.erase(it);

	if (terminated)
		out_jsonReturn = Json(Json::object({{"success", true}})).dump();
	else
		out_jsonReturn = Json(Json::object({{"success", false}, {"error", "TerminateProcess failed with error " + std::to_string(err)}})).dump();
}

void PluginJsHandler::JS_OBS_SOURCE_CREATE(const Json &params, std::string &out_jsonReturn)
{
	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, this, &params, &out_jsonReturn]() {
			const auto &id = params["param2"].string_value();
			const auto &name = params["param3"].string_value();
			const auto &settings_jsonStr = params["param4"].string_value();
			const auto &hotkey_data_jsonStr = params["param5"].string_value();

			// Name is also the guid, duplicates can't exist
			//	see "bool AddNew(QWidget *parent, const char *id, const char *name," in obs gui code
			OBSSourceAutoRelease existingSource = obs_get_source_by_name(name.c_str());

			if (existingSource != nullptr)
			{
				out_jsonReturn = Json(Json::object({{"error", "name already exists, " + name}})).dump();
				return;
			}

			OBSSourceAutoRelease scene = obs_frontend_get_current_scene();

			if (scene == nullptr)
			{
				out_jsonReturn = Json(Json::object({{"error", "Empty current scene."}})).dump();
				return;
			}

			obs_data_t *settings = obs_data_create_from_json(settings_jsonStr.c_str());
			obs_data_t *hotkeys = obs_data_create_from_json(hotkey_data_jsonStr.c_str());

			obs_source_t *source = obs_source_create(id.c_str(), name.c_str(), settings, hotkeys);

			obs_data_release(hotkeys);
			obs_data_release(settings);

			if (!source)
			{
				out_jsonReturn = Json(Json::object({{"error", "obs_source_create returned null"}})).dump();
				return;
			}

			obs_data_t *settingsSource = obs_source_get_settings(source);

			Json jsonReturnValue = Json::object({{"settings", Json(obs_data_get_json(settingsSource))},
							     {"audio_mixers", Json(std::to_string(obs_source_get_audio_mixers(source)))},
							     {"deinterlace_mode", Json(std::to_string(obs_source_get_deinterlace_mode(source)))},
							     {"deinterlace_field_order", Json(std::to_string(obs_source_get_deinterlace_field_order(source)))}});

			out_jsonReturn = jsonReturnValue.dump();
			obs_data_release(settingsSource);

			obs_scene_t *scene_obj = obs_scene_from_source(scene);

			if (obs_scene_find_source(scene_obj, name.c_str()))
			{
				out_jsonReturn = Json(Json::object({{"error", "The source is already in the scene"}})).dump();
				return;
			}

			obs_sceneitem_t *scene_item = obs_scene_add(scene_obj, source);
			if (!scene_item)
				out_jsonReturn = Json(Json::object({{"error", "Failed to add source to scene"}})).dump();

			obs_source_release(source);
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_OBS_SOURCE_DESTROY(const Json &params, std::string &out_jsonReturn)
{
	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, this, params, &out_jsonReturn]() {
			const auto &name = params["param2"].string_value();

			OBSSourceAutoRelease src = obs_get_source_by_name(name.c_str());

			if (src == nullptr)
			{
				out_jsonReturn = Json(Json::object({{"error", "Can't find source with name " + name}})).dump();
				return;
			}

			if (obs_source_get_type(src) == OBS_SOURCE_TYPE_TRANSITION)
			{
				obs_source_remove(src);
			}
			else if (obs_source_get_type(src) == OBS_SOURCE_TYPE_SCENE)
			{
				// Function from obs ui
				auto getSceneCount = []()
				{
					size_t ret;
					auto sceneEnumProc = [](void *param, obs_source_t *scene) {
						auto ret = static_cast<size_t *>(param);

						if (obs_source_is_group(scene))
							return true;

						(*ret)++;
						return true;
					};

					obs_enum_scenes(sceneEnumProc, &ret);
					return ret;
				};

				if (getSceneCount() < 2)
				{
					out_jsonReturn = Json(Json::object({{"error", "You cannot remove the last scene in the collection."}})).dump();
					return;
				}

				blog(LOG_INFO, "Releasing scene %s", obs_source_get_name(src));
				std::list<obs_sceneitem_t *> items;
				auto cb = [](obs_scene_t *scene, obs_sceneitem_t *item, void *data) {
					if (item)
					{
						std::list<obs_sceneitem_t *> *items = reinterpret_cast<std::list<obs_sceneitem_t *> *>(data);
						obs_sceneitem_addref(item);
						items->push_back(item);
					}
					return true;
				};
				obs_scene_t *scene = obs_scene_from_source(src);
				if (scene)
					obs_scene_enum_items(scene, cb, &items);

				for (auto item : items)
				{
					obs_sceneitem_remove(item);
					obs_sceneitem_release(item);
				}

				obs_source_remove(src);
			}
			else
			{
				obs_source_remove(src);
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_GET_SCENE_COLLECTIONS(const json11::Json& params, std::string& out_jsonReturn)
{
	char **scene_collections = obs_frontend_get_scene_collections();

	std::vector<Json> result;

	for (int i = 0; scene_collections[i] != nullptr; ++i)
		result.push_back(Json::object{{"name", scene_collections[i]}});

	// Convert the panelInfo vector to a Json object and dump string
	Json ret = result;
	out_jsonReturn = ret.dump();
}

void PluginJsHandler::JS_GET_CURRENT_SCENE_COLLECTION(const json11::Json &params, std::string &out_jsonReturn)
{
	Json ret = Json::object{{"name", obs_frontend_get_current_scene_collection()}};
	out_jsonReturn = ret.dump();
}

void PluginJsHandler::JS_SET_CURRENT_SCENE_COLLECTION(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &name = params["param2"].string_value();

	if (name.empty())
	{
		out_jsonReturn = Json(Json::object({{"error", "Invalid param"}})).dump();
		return;
	}

	obs_frontend_set_current_scene_collection(name.c_str());
}

void PluginJsHandler::JS_ADD_SCENE_COLLECTION(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &name = params["param2"].string_value();

	if (name.empty())
	{
		out_jsonReturn = Json(Json::object({{"error", "Invalid param"}})).dump();
		return;
	}

	if (!obs_frontend_add_scene_collection(name.c_str()))
		out_jsonReturn = Json(Json::object({{"error", "Obs function failed"}})).dump();
	else
		out_jsonReturn = Json(Json::object{{"status", "success"}}).dump();
}

void PluginJsHandler::JS_SET_SCENEITEM_POS(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];
	const auto &param4Value = params["param4"];
	const auto &param5Value = params["param5"];

	std::string scene_name = param2Value.string_value();
	std::string source_name = param3Value.string_value();
	float x = (float)param4Value.number_value();
	float y = (float)param5Value.number_value();

	if (scene_name == source_name)
	{
		out_jsonReturn = Json(Json::object({{"error", "Scene and source inputs have same name"}})).dump();
		return;
	}

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, scene_name, source_name, x, y, &out_jsonReturn]() {
			OBSSourceAutoRelease scene = obs_get_source_by_name(scene_name.c_str());
			if (!scene)
				out_jsonReturn = Json(Json::object({{"error", "Did not find an object with name " + scene_name}})).dump();
			else if (!obs_source_is_scene(scene))
				out_jsonReturn = Json(Json::object({{"error", "The object found is not a scene"}})).dump();
			else
			{
				obs_scene_t *scene_obj = obs_scene_from_source(scene);
				obs_sceneitem_t *scene_item = obs_scene_find_source(scene_obj, source_name.c_str());

				if (!scene_item)
				{
					out_jsonReturn = Json(Json::object({{"error", "Failed find the source in that scene"}})).dump();
					return;
				}

				vec2 pos;
				pos.x = x;
				pos.y = y;
				obs_sceneitem_set_pos(scene_item, &pos);
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_SET_SCENEITEM_VISIBILITY(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];
	const auto &param4Value = params["param4"];

	std::string scene_name = param2Value.string_value();
	std::string source_name = param3Value.string_value();
	const bool is_visible = param4Value.bool_value();

	if (scene_name == source_name)
	{
		out_jsonReturn = Json(Json::object({{"error", "Scene and source inputs have same name"}})).dump();
		return;
	}

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[scene_name, source_name, is_visible, &out_jsonReturn]() {
			OBSSourceAutoRelease scene = obs_get_source_by_name(scene_name.c_str());
			if (!scene)
				out_jsonReturn = Json(Json::object({{"error", "Did not find an object with name " + scene_name}})).dump();
			else if (!obs_source_is_scene(scene))
				out_jsonReturn = Json(Json::object({{"error", "The object found is not a scene"}})).dump();
			else
			{
				obs_scene_t *scene_obj = obs_scene_from_source(scene);
				obs_sceneitem_t *scene_item = obs_scene_find_source(scene_obj, source_name.c_str());

				if (!scene_item)
				{
					out_jsonReturn = Json(Json::object({{"error", "Failed find the source in that scene"}})).dump();
					return;
				}

				obs_sceneitem_set_visible(scene_item, is_visible);
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_SET_SCENEITEM_ROT(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];
	const auto &param4Value = params["param4"];

	std::string scene_name = param2Value.string_value();
	std::string source_name = param3Value.string_value();
	float rotation = (float)param4Value.number_value();

	if (scene_name == source_name)
	{
		out_jsonReturn = Json(Json::object({{"error", "Scene and source inputs have same name"}})).dump();
		return;
	}

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[scene_name, source_name, rotation, &out_jsonReturn]() {
			OBSSourceAutoRelease scene = obs_get_source_by_name(scene_name.c_str());
			if (!scene)
				out_jsonReturn = Json(Json::object({{"error", "Did not find an object with name " + scene_name}})).dump();
			else if (!obs_source_is_scene(scene))
				out_jsonReturn = Json(Json::object({{"error", "The object found is not a scene"}})).dump();
			else
			{
				obs_scene_t *scene_obj = obs_scene_from_source(scene);
				obs_sceneitem_t *scene_item = obs_scene_find_source(scene_obj, source_name.c_str());

				if (!scene_item)
				{
					out_jsonReturn = Json(Json::object({{"error", "Failed find the source in that scene"}})).dump();
					return;
				}

				obs_sceneitem_set_rot(scene_item, rotation);
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_SET_SCENEITEM_CROP(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];
	const auto &param4Value = params["param4"];
	const auto &param5Value = params["param5"];
	const auto &param6Value = params["param6"];
	const auto &param7Value = params["param7"];

	std::string scene_name = param2Value.string_value();
	std::string source_name = param3Value.string_value();
	int left = param4Value.int_value();
	int top = param5Value.int_value();
	int right = param6Value.int_value();
	int bottom = param7Value.int_value();

	if (scene_name == source_name)
	{
		out_jsonReturn = Json(Json::object({{"error", "Scene and source inputs have same name"}})).dump();
		return;
	}

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[scene_name, source_name, left, top, right, bottom, &out_jsonReturn]() {
			OBSSourceAutoRelease scene = obs_get_source_by_name(scene_name.c_str());
			if (!scene)
				out_jsonReturn = Json(Json::object({{"error", "Did not find an object with name " + scene_name}})).dump();
			else if (!obs_source_is_scene(scene))
				out_jsonReturn = Json(Json::object({{"error", "The object found is not a scene"}})).dump();
			else
			{
				obs_scene_t *scene_obj = obs_scene_from_source(scene);
				obs_sceneitem_t *scene_item = obs_scene_find_source(scene_obj, source_name.c_str());

				if (!scene_item)
				{
					out_jsonReturn = Json(Json::object({{"error", "Failed find the source in that scene"}})).dump();
					return;
				}

				struct obs_sceneitem_crop crop = {left, top, right, bottom};
				obs_sceneitem_set_crop(scene_item, &crop);
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_SET_SCENEITEM_SCALE_FILTER(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];
	const auto &param4Value = params["param4"];

	std::string scene_name = param2Value.string_value();
	std::string source_name = param3Value.string_value();
	int scale_type = param4Value.int_value();

	if (scene_name == source_name)
	{
		out_jsonReturn = Json(Json::object({{"error", "Scene and source inputs have same name"}})).dump();
		return;
	}

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[scene_name, source_name, scale_type, &out_jsonReturn]() {
			OBSSourceAutoRelease scene = obs_get_source_by_name(scene_name.c_str());
			if (!scene)
				out_jsonReturn = Json(Json::object({{"error", "Did not find an object with name " + scene_name}})).dump();
			else if (!obs_source_is_scene(scene))
				out_jsonReturn = Json(Json::object({{"error", "The object found is not a scene"}})).dump();
			else
			{
				obs_scene_t *scene_obj = obs_scene_from_source(scene);
				obs_sceneitem_t *scene_item = obs_scene_find_source(scene_obj, source_name.c_str());

				if (!scene_item)
				{
					out_jsonReturn = Json(Json::object({{"error", "Failed to find the source in that scene"}})).dump();
					return;
				}

				obs_sceneitem_set_scale_filter(scene_item, (obs_scale_type)scale_type);
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_SET_SCENEITEM_BLENDING_MODE(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];
	const auto &param4Value = params["param4"];

	std::string scene_name = param2Value.string_value();
	std::string source_name = param3Value.string_value();
	int blending_type = param4Value.int_value();

	if (scene_name == source_name)
	{
		out_jsonReturn = Json(Json::object({{"error", "Scene and source inputs have same name"}})).dump();
		return;
	}

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[scene_name, source_name, blending_type, &out_jsonReturn]() {
			OBSSourceAutoRelease scene = obs_get_source_by_name(scene_name.c_str());
			if (!scene)
				out_jsonReturn = Json(Json::object({{"error", "Did not find an object with name " + scene_name}})).dump();
			else if (!obs_source_is_scene(scene))
				out_jsonReturn = Json(Json::object({{"error", "The object found is not a scene"}})).dump();
			else
			{
				obs_scene_t *scene_obj = obs_scene_from_source(scene);
				obs_sceneitem_t *scene_item = obs_scene_find_source(scene_obj, source_name.c_str());

				if (!scene_item)
				{
					out_jsonReturn = Json(Json::object({{"error", "Failed to find the source in that scene"}})).dump();
					return;
				}

				obs_sceneitem_set_blending_mode(scene_item, (obs_blending_type)blending_type);
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_SET_SCENEITEM_BLENDING_METHOD(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];
	const auto &param4Value = params["param4"];

	std::string scene_name = param2Value.string_value();
	std::string source_name = param3Value.string_value();
	int blending_method = param4Value.int_value();

	if (scene_name == source_name)
	{
		out_jsonReturn = Json(Json::object({{"error", "Scene and source inputs have same name"}})).dump();
		return;
	}

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[scene_name, source_name, blending_method, &out_jsonReturn]() {
			OBSSourceAutoRelease scene = obs_get_source_by_name(scene_name.c_str());
			if (!scene)
				out_jsonReturn = Json(Json::object({{"error", "Did not find an object with name " + scene_name}})).dump();
			else if (!obs_source_is_scene(scene))
				out_jsonReturn = Json(Json::object({{"error", "The object found is not a scene"}})).dump();
			else
			{
				obs_scene_t *scene_obj = obs_scene_from_source(scene);
				obs_sceneitem_t *scene_item = obs_scene_find_source(scene_obj, source_name.c_str());

				if (!scene_item)
				{
					out_jsonReturn = Json(Json::object({{"error", "Failed to find the source in that scene"}})).dump();
					return;
				}

				// Assuming obs_sceneitem_set_blending_method exists and accepts an enum type for blending method.
				obs_sceneitem_set_blending_method(scene_item, (obs_blending_method)blending_method);
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_SET_SCALE(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];
	const auto &param4Value = params["param4"];
	const auto &param5Value = params["param5"];

	std::string scene_name = param2Value.string_value();
	std::string source_name = param3Value.string_value();
	float x_scale = (float)param4Value.number_value();
	float y_scale = (float)param5Value.number_value();

	if (scene_name == source_name)
	{
		out_jsonReturn = Json(Json::object({{"error", "Scene and source inputs have same name"}})).dump();
		return;
	}

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[scene_name, source_name, x_scale, y_scale, &out_jsonReturn]() {
			OBSSourceAutoRelease scene = obs_get_source_by_name(scene_name.c_str());
			if (!scene)
				out_jsonReturn = Json(Json::object({{"error", "Did not find an object with name " + scene_name}})).dump();
			else if (!obs_source_is_scene(scene))
				out_jsonReturn = Json(Json::object({{"error", "The object found is not a scene"}})).dump();
			else
			{
				obs_scene_t *scene_obj = obs_scene_from_source(scene);
				obs_sceneitem_t *scene_item = obs_scene_find_source(scene_obj, source_name.c_str());

				if (!scene_item)
				{
					out_jsonReturn = Json(Json::object({{"error", "Failed to find the source in that scene"}})).dump();
					return;
				}

				// Assuming obs_sceneitem_set_scale exists and can set x and y scale values.
				vec2 scale = {x_scale, y_scale};
				obs_sceneitem_set_scale(scene_item, &scale);
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_GET_SCENEITEM_POS(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];

	std::string scene_name = param2Value.string_value();
	std::string source_name = param3Value.string_value();

	if (scene_name == source_name)
	{
		out_jsonReturn = Json(Json::object({{"error", "Scene and source inputs have same name"}})).dump();
		return;
	}

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[scene_name, source_name, &out_jsonReturn]() {
			OBSSourceAutoRelease scene = obs_get_source_by_name(scene_name.c_str());
			if (!scene)
				out_jsonReturn = Json(Json::object({{"error", "Did not find an object with name " + scene_name}})).dump();
			else if (!obs_source_is_scene(scene))
				out_jsonReturn = Json(Json::object({{"error", "The object found is not a scene"}})).dump();
			else
			{
				obs_scene_t *scene_obj = obs_scene_from_source(scene);
				obs_sceneitem_t *scene_item = obs_scene_find_source(scene_obj, source_name.c_str());

				if (!scene_item)
				{
					out_jsonReturn = Json(Json::object({{"error", "Failed to find the source in that scene"}})).dump();
					return;
				}

				// Assuming obs_sceneitem_get_pos exists and retrieves x and y position values.
				vec2 position;
				obs_sceneitem_get_pos(scene_item, &position);
				out_jsonReturn = Json(Json::object({{"x", position.x}, {"y", position.y}})).dump();
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_GET_SCENEITEM_ROT(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];

	std::string scene_name = param2Value.string_value();
	std::string source_name = param3Value.string_value();

	if (scene_name == source_name)
	{
		out_jsonReturn = Json(Json::object({{"error", "Scene and source inputs have same name"}})).dump();
		return;
	}

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[scene_name, source_name, &out_jsonReturn]() {
			OBSSourceAutoRelease scene = obs_get_source_by_name(scene_name.c_str());
			if (!scene)
				out_jsonReturn = Json(Json::object({{"error", "Did not find an object with name " + scene_name}})).dump();
			else if (!obs_source_is_scene(scene))
				out_jsonReturn = Json(Json::object({{"error", "The object found is not a scene"}})).dump();
			else
			{
				obs_scene_t *scene_obj = obs_scene_from_source(scene);
				obs_sceneitem_t *scene_item = obs_scene_find_source(scene_obj, source_name.c_str());

				if (!scene_item)
				{
					out_jsonReturn = Json(Json::object({{"error", "Failed to find the source in that scene"}})).dump();
					return;
				}

				// Assuming obs_sceneitem_get_rot exists and retrieves the rotation value.
				float rotation = obs_sceneitem_get_rot(scene_item);
				out_jsonReturn = Json(Json::object({{"rotation", rotation}})).dump();
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_GET_SCENEITEM_CROP(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];

	std::string scene_name = param2Value.string_value();
	std::string source_name = param3Value.string_value();

	if (scene_name == source_name)
	{
		out_jsonReturn = Json(Json::object({{"error", "Scene and source inputs have same name"}})).dump();
		return;
	}

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[scene_name, source_name, &out_jsonReturn]() {
			OBSSourceAutoRelease scene = obs_get_source_by_name(scene_name.c_str());
			if (!scene)
				out_jsonReturn = Json(Json::object({{"error", "Did not find an object with name " + scene_name}})).dump();
			else if (!obs_source_is_scene(scene))
				out_jsonReturn = Json(Json::object({{"error", "The object found is not a scene"}})).dump();
			else
			{
				obs_scene_t *scene_obj = obs_scene_from_source(scene);
				obs_sceneitem_t *scene_item = obs_scene_find_source(scene_obj, source_name.c_str());

				if (!scene_item)
				{
					out_jsonReturn = Json(Json::object({{"error", "Failed to find the source in that scene"}})).dump();
					return;
				}

				// Assuming obs_sceneitem_get_crop exists and retrieves the crop values.
				obs_sceneitem_crop crop_values;
				obs_sceneitem_get_crop(scene_item, &crop_values);

				out_jsonReturn = Json(Json::object({{"left", crop_values.left}, {"right", crop_values.right}, {"top", crop_values.top}, {"bottom", crop_values.bottom}})).dump();
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_GET_SOURCE_DIMENSIONS(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	std::string source_name = param2Value.string_value();

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	QMetaObject::invokeMethod(
		mainWindow,
		[source_name, &out_jsonReturn]() {
			OBSSourceAutoRelease source = obs_get_source_by_name(source_name.c_str());
			if (!source)
			{
				out_jsonReturn = Json(Json::object({{"error", "Did not find a source with name " + source_name}})).dump();
				return;
			}

			uint32_t width = obs_source_get_width(source);
			uint32_t height = obs_source_get_height(source);

			out_jsonReturn = Json(Json::object({{"width", static_cast<int>(width)}, {"height", static_cast<int>(height)}})).dump();
		},
		Qt::BlockingQueuedConnection);
}


void PluginJsHandler::JS_GET_SCALE(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];

	std::string scene_name = param2Value.string_value();
	std::string source_name = param3Value.string_value();

	if (scene_name == source_name)
	{
		out_jsonReturn = Json(Json::object({{"error", "Scene and source inputs have same name"}})).dump();
		return;
	}

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[scene_name, source_name, &out_jsonReturn]() {
			OBSSourceAutoRelease scene = obs_get_source_by_name(scene_name.c_str());
			if (!scene)
				out_jsonReturn = Json(Json::object({{"error", "Did not find an object with name " + scene_name}})).dump();
			else if (!obs_source_is_scene(scene))
				out_jsonReturn = Json(Json::object({{"error", "The object found is not a scene"}})).dump();
			else
			{
				obs_scene_t *scene_obj = obs_scene_from_source(scene);
				obs_sceneitem_t *scene_item = obs_scene_find_source(scene_obj, source_name.c_str());

				if (!scene_item)
				{
					out_jsonReturn = Json(Json::object({{"error", "Failed to find the source in that scene"}})).dump();
					return;
				}

				// Assuming obs_sceneitem_get_scale exists and retrieves the scale values.
				vec2 scale_values;
				obs_sceneitem_get_scale(scene_item, &scale_values);

				out_jsonReturn = Json(Json::object({{"x", scale_values.x}, {"y", scale_values.y}})).dump();
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_GET_SCENEITEM_SCALE_FILTER(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];

	std::string scene_name = param2Value.string_value();
	std::string source_name = param3Value.string_value();

	if (scene_name == source_name)
	{
		out_jsonReturn = Json(Json::object({{"error", "Scene and source inputs have same name"}})).dump();
		return;
	}

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[scene_name, source_name, &out_jsonReturn]() {
			OBSSourceAutoRelease scene = obs_get_source_by_name(scene_name.c_str());
			if (!scene)
				out_jsonReturn = Json(Json::object({{"error", "Did not find an object with name " + scene_name}})).dump();
			else if (!obs_source_is_scene(scene))
				out_jsonReturn = Json(Json::object({{"error", "The object found is not a scene"}})).dump();
			else
			{
				obs_scene_t *scene_obj = obs_scene_from_source(scene);
				obs_sceneitem_t *scene_item = obs_scene_find_source(scene_obj, source_name.c_str());

				if (!scene_item)
				{
					out_jsonReturn = Json(Json::object({{"error", "Failed to find the source in that scene"}})).dump();
					return;
				}

				// Assuming obs_sceneitem_get_scale_filter exists and retrieves the scale filter value.
				int scale_filter = static_cast<int>(obs_sceneitem_get_scale_filter(scene_item));
				out_jsonReturn = Json(Json::object({{"scale_filter", scale_filter}})).dump();
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_GET_SCENEITEM_BLENDING_MODE(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];

	std::string scene_name = param2Value.string_value();
	std::string source_name = param3Value.string_value();

	if (scene_name == source_name)
	{
		out_jsonReturn = Json(Json::object({{"error", "Scene and source inputs have same name"}})).dump();
		return;
	}

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[scene_name, source_name, &out_jsonReturn]() {
			OBSSourceAutoRelease scene = obs_get_source_by_name(scene_name.c_str());
			if (!scene)
				out_jsonReturn = Json(Json::object({{"error", "Did not find an object with name " + scene_name}})).dump();
			else if (!obs_source_is_scene(scene))
				out_jsonReturn = Json(Json::object({{"error", "The object found is not a scene"}})).dump();
			else
			{
				obs_scene_t *scene_obj = obs_scene_from_source(scene);
				obs_sceneitem_t *scene_item = obs_scene_find_source(scene_obj, source_name.c_str());

				if (!scene_item)
				{
					out_jsonReturn = Json(Json::object({{"error", "Failed to find the source in that scene"}})).dump();
					return;
				}

				// Assuming obs_sceneitem_get_blending_mode exists and retrieves the blending mode value.
				int blending_mode = static_cast<int>(obs_sceneitem_get_blending_mode(scene_item));
				out_jsonReturn = Json(Json::object({{"blending_mode", blending_mode}})).dump();
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_GET_SCENEITEM_BLENDING_METHOD(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	const auto &param3Value = params["param3"];

	std::string scene_name = param2Value.string_value();
	std::string source_name = param3Value.string_value();

	if (scene_name == source_name)
	{
		out_jsonReturn = Json(Json::object({{"error", "Scene and source inputs have same name"}})).dump();
		return;
	}

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	// This code is executed in the context of the QMainWindow's thread.
	QMetaObject::invokeMethod(
		mainWindow,
		[scene_name, source_name, &out_jsonReturn]() {
			OBSSourceAutoRelease scene = obs_get_source_by_name(scene_name.c_str());
			if (!scene)
				out_jsonReturn = Json(Json::object({{"error", "Did not find an object with name " + scene_name}})).dump();
			else if (!obs_source_is_scene(scene))
				out_jsonReturn = Json(Json::object({{"error", "The object found is not a scene"}})).dump();
			else
			{
				obs_scene_t *scene_obj = obs_scene_from_source(scene);
				obs_sceneitem_t *scene_item = obs_scene_find_source(scene_obj, source_name.c_str());

				if (!scene_item)
				{
					out_jsonReturn = Json(Json::object({{"error", "Failed to find the source in that scene"}})).dump();
					return;
				}

				// Assuming obs_sceneitem_get_blending_method exists and retrieves the blending method value.
				int blending_method = static_cast<int>(obs_sceneitem_get_blending_method(scene_item));
				out_jsonReturn = Json(Json::object({{"blending_method", blending_method}})).dump();
			}
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_SCENE_GET_SOURCES(const json11::Json &params, std::string &out_jsonReturn)
{
	const auto &param2Value = params["param2"];
	std::string scene_name = param2Value.string_value();

	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	QMetaObject::invokeMethod(
		mainWindow,
		[scene_name, &out_jsonReturn]() {
			OBSSourceAutoRelease scene = obs_get_source_by_name(scene_name.c_str());
			if (!scene)
			{
				out_jsonReturn = Json(Json::object({{"error", "Did not find an object with name " + scene_name}})).dump();
				return;
			}
			else if (!obs_source_is_scene(scene))
			{
				out_jsonReturn = Json(Json::object({{"error", "The object found is not a scene"}})).dump();
				return;
			}

			obs_scene_t *scene_obj = obs_scene_from_source(scene);

			std::vector<std::string> source_names;

			obs_scene_enum_items(
				scene_obj,
				[](obs_scene_t *, obs_sceneitem_t *item, void *param) {
					if (obs_source_t *source = obs_sceneitem_get_source(item))
					{
						std::vector<std::string> *names = reinterpret_cast<std::vector<std::string> *>(param);
						auto str = obs_source_get_name(source);

						if (str != NULL)
							names->push_back(str);
					}
					return true; 
				},
				&source_names);

			out_jsonReturn = Json(Json::object({{"source_names", source_names}})).dump();
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_RESTART_OBS(const json11::Json& params, std::string& out_jsonReturn)
{
	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	if (HWND hwnd = reinterpret_cast<HWND>(mainWindow->winId()))
	{
		m_restartApp = true;
		m_restartProgramStr = std::make_unique<QString>(qApp->arguments()[0]);
		m_restartArguments = std::make_unique<QStringList>(qApp->arguments());
		PostMessage(hwnd, WM_CLOSE, 0, 0);
	}
}

void PluginJsHandler::JS_ENUM_SCENES(const json11::Json &params, std::string &out_jsonReturn)
{
	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	QMetaObject::invokeMethod(
		mainWindow,
		[&out_jsonReturn]() {
			std::vector<json11::Json> sourcesList;

			obs_enum_scenes(
				[](void *param, obs_source_t *source) -> bool {
					std::vector<json11::Json> *sourcesList = reinterpret_cast<std::vector<json11::Json> *>(param);

					auto rawName = obs_source_get_name(source);
					auto rawId = obs_source_get_id(source);

					json11::Json sourceInfo = json11::Json::object({
						{"name", rawName ? rawName : ""},
						{"type", static_cast<int>(obs_source_get_type(source))},
						{"id", rawId ? rawId : ""},
					});

					sourcesList->push_back(sourceInfo);
					return true; // Continue enumeration
				},
				&sourcesList);

			out_jsonReturn = json11::Json(sourcesList).dump();
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_QUERY_ALL_SOURCES(const json11::Json &params, std::string &out_jsonReturn)
{
	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	QMetaObject::invokeMethod(
		mainWindow,
		[&out_jsonReturn]() {
			std::vector<json11::Json> sourcesList;

			obs_enum_sources(
				[](void *param, obs_source_t *source) -> bool {
					std::vector<json11::Json> *sourcesList = reinterpret_cast<std::vector<json11::Json> *>(param);

					auto rawName = obs_source_get_name(source);
					auto rawId = obs_source_get_id(source);

					json11::Json sourceInfo = json11::Json::object({
						{"name", rawName ? rawName : ""},
						{"type", static_cast<int>(obs_source_get_type(source))},
						{"id", rawId ? rawId : ""},
					});

					sourcesList->push_back(sourceInfo);
					return true; // Continue enumeration
				},
				&sourcesList);

			out_jsonReturn = json11::Json(sourcesList).dump();
		},
		Qt::BlockingQueuedConnection);
}

void PluginJsHandler::JS_GET_CANVAS_DIMENSIONS(const json11::Json &params, std::string &out_jsonReturn)
{
	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	QMetaObject::invokeMethod(
		mainWindow,
		[&out_jsonReturn]() {
			obs_video_info ovi;
			if (obs_get_video_info(&ovi))
			{
				uint32_t canvas_width = ovi.base_width;
				uint32_t canvas_height = ovi.base_height;
				out_jsonReturn = Json(Json::object({{"width", static_cast<int>(canvas_width)}, {"height", static_cast<int>(canvas_height)}})).dump();
			}
			else
			{
				out_jsonReturn = Json(Json::object({{"error", "Failed to get canvas dimensions"}})).dump();
			}
		},
		Qt::BlockingQueuedConnection);
}

/***
* OBS Callbacks
**/

/*static*/
void PluginJsHandler::handle_obs_frontend_event(obs_frontend_event event, void *data)
{

}

/***
* Save/Load
**/

// Handle the close event here before Qt sees it
LRESULT CALLBACK HandleWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	static bool finishedSaving = false;
	static bool doOnce = false;

	// Intercept WM_CLOSE with our own logic
	if (uMsg == WM_CLOSE && !finishedSaving)
	{
		if (!doOnce)
		{
			auto perform = [](HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
				::Sleep(100);
				PluginJsHandler::instance().onWmClose();
				finishedSaving = true;
				::PostMessage(hwnd, WM_CLOSE, 0, 0);
			};

			std::thread(perform, hwnd, uMsg, wParam, lParam).detach();
		}

		doOnce = true;
		return 0;
	}

	// Allow normal messaging
	WNDPROC origWndProc = (WNDPROC)GetWindowLongPtr(hwnd, GWLP_USERDATA);
	return CallWindowProc(origWndProc, hwnd, uMsg, wParam, lParam);
}

void PluginJsHandler::onWmClose()
{
	stop();
	QtGuiModifications::instance().stop();
	PluginJsHandler::instance().saveSlabsBrowserDocks();

	// Destroy CEF widgets before OBS gets to CefShutdown()
	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();
	QList<QDockWidget *> docks = mainWindow->findChildren<QDockWidget *>();
	for (auto *dock : docks)
	{
		if (dock->property("isSlabs").isValid())
		{
			delete dock->widget();
			dock->setWidget(nullptr);
		}
	}
}

void PluginJsHandler::saveSlabsBrowserDocks()
{
	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();

	QMetaObject::invokeMethod(
		mainWindow,
		[mainWindow, this]() {
			Json::array jarray;
			QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();
			QList<QDockWidget *> docks = mainWindow->findChildren<QDockWidget *>();

			foreach(QDockWidget * dock, docks)
			{
				if (dock->property("isSlabs").isValid())
				{
					QCefWidgetInternal *widget = (QCefWidgetInternal *)dock->widget();

					std::string url = "http://localhost:0/";

					if (auto browser = widget->cefBrowser)
					{
						if (auto mainframe = browser->GetMainFrame())
							url = mainframe->GetURL();
						else							
							blog(LOG_ERROR, "Found null GetMainFrame while saving slabs browser docks");
					}
					else
					{
						blog(LOG_ERROR, "Found null cefBrowser while saving slabs browser docks");
					}

					Json::object obj{
						{"title", dock->windowTitle().toStdString()},
						{"url", url},
						{"objectName", dock->objectName().toStdString()},
					};

					jarray.push_back(obj);
				}
			}
			
			// Json data
			std::string output = Json(jarray).dump();
			config_set_string(obs_frontend_get_global_config(), "BasicWindow", "SlabsBrowserDocks", output.c_str());

		},
		Qt::BlockingQueuedConnection);
}

// March 21st, 2024
//	Note, OBS loads the module before loading "DockState" and doing qt restoreState
//	OBS also saves all docks, even ours, into "DockState" on its own
//	So we don't worry about that because its doing it for us
void PluginJsHandler::loadSlabsBrowserDocks()
{
	// This is to intercept the shutdown event so that we can save it before OBS does anything
	QMainWindow *mainWindow = (QMainWindow *)obs_frontend_get_main_window();
	WNDPROC origWndProc = (WNDPROC)SetWindowLongPtr(reinterpret_cast<HWND>(mainWindow->winId()), GWLP_WNDPROC, (LONG_PTR)HandleWndProc);
	SetWindowLongPtr(reinterpret_cast<HWND>(mainWindow->winId()), GWLP_USERDATA, (LONG_PTR)origWndProc);

	const char *jsonStr = config_get_string(obs_frontend_get_global_config(), "BasicWindow", "SlabsBrowserDocks");

	std::string err;
	Json json = Json::parse(jsonStr, err);

	if (!err.empty())
		return;

	Json::array array = json.array_items();

	for (Json &item : array)
	{
		std::string title = item["title"].string_value();
		std::string url = item["url"].string_value();
		std::string objectName = item["objectName"].string_value();

		obs_frontend_add_dock_by_id(objectName.c_str(), title.c_str(), nullptr);

		if (auto dock = findDock(objectName))
		{
			static QCef *qcef = obs_browser_init_panel();

			QCefWidget *browser = qcef->create_widget(dock, url, nullptr);
			dock->setWidget(browser);
			dock->setWindowTitle(title.c_str());
			dock->setObjectName(objectName.c_str());
			dock->setProperty("isSlabs", true);

			dock->resize(460, 600);
			dock->setMinimumSize(80, 80);
			dock->setWindowTitle(title.c_str());
			dock->setAllowedAreas(Qt::AllDockWidgetAreas);
			dock->installEventFilter(new SlDockEventFilter(dock));
		}
		
		//dock->setFeatures(QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetFloatable);
	}
}

void PluginJsHandler::loadFonts()
{
	auto fontsDir = getFontsDir();

	if (fontsDir.empty())
		return;

	try
	{
		for (const auto &itr : std::filesystem::directory_iterator(fontsDir))
		{
			if (itr.path().extension() == ".ttf")
			{
				const std::string &filepath = itr.path().generic_u8string();

				if (WindowsFunctions::InstallFont(filepath.c_str()))
				{
					if (QFontDatabase::addApplicationFont(filepath.c_str()) == -1)
						blog(LOG_ERROR, "Streamlabs - QFontDatabase::addApplicationFont %s", filepath.c_str());
				}
				else
				{
					blog(LOG_ERROR, "Streamlabs - AddFontResourceA %s", filepath.c_str());
				}
			}
		}
	}
	catch (const std::filesystem::filesystem_error &)
	{}
}

void PluginJsHandler::JS_BROWSERSOURCE_SEND_MESSAGE(const json11::Json &params, std::string &out_jsonReturn)
{
	const std::string sourceName = params["param2"].string_value();

	if (sourceName.empty())
	{
		out_jsonReturn = Json(Json::object({{"error", "param2 (sourceName) is required"}})).dump();
		return;
	}

	// An omitted or non-string message would otherwise become "" and be delivered as one.
	// Nothing later can contradict that: the channel is one way, so this return value is the
	// only signal the caller gets. An explicit "" is still a string, and still allowed.
	if (!params["param3"].is_string())
	{
		out_jsonReturn = Json(Json::object({{"error", "param3 (message) must be a string"}})).dump();
		return;
	}

	const std::string message = params["param3"].string_value();

	OBSSourceAutoRelease source = obs_get_source_by_name(sourceName.c_str());

	if (!source)
	{
		out_jsonReturn = Json(Json::object({{"error", "Did not find a source with name " + sourceName}})).dump();
		return;
	}

	const char *sourceId = obs_source_get_id(source);

	if (!sourceId || std::string(sourceId) != "browser_source")
	{
		out_jsonReturn = Json(Json::object({{"error", sourceName + " is not a browser source"}})).dump();
		return;
	}

	// Desktop's MessageToBrowser envelope, overlays are written against this exact shape.
	const std::string payload = Json(Json::object({{"message", message}})).dump();

	// javascript_event queues a CEF task itself, so no main thread hop.
	calldata_t cd;
	calldata_init(&cd);
	calldata_set_string(&cd, "eventName", "messageFromApp");
	calldata_set_string(&cd, "jsonString", payload.c_str());

	const bool delivered = proc_handler_call(obs_source_get_proc_handler(source), "javascript_event", &cd);
	calldata_free(&cd);

	if (!delivered)
	{
		out_jsonReturn = Json(Json::object({{"error", "javascript_event is unavailable, OBS 29.1.0 or newer is required"}})).dump();
		return;
	}

	OBSDataAutoRelease settings = obs_source_get_settings(source);

	if (obs_data_get_bool(settings, "shutdown") && !obs_source_showing(source))
	{
		const std::string warning = sourceName + " is hidden and set to shut down when not visible, so no page is running to receive this";
		out_jsonReturn = Json(Json::object({{"success", true}, {"warning", warning}})).dump();
		return;
	}

	out_jsonReturn = Json(Json::object({{"success", true}})).dump();
}

/***
* Helpers
*/

/*
 * Both of these used std::wstring_convert, which throws on input it cannot represent. Nothing
 * between an api handler and the worker thread catches, so that throw ended the process - and a
 * javascript string is allowed to carry an unpaired surrogate, which reaches us as exactly the
 * kind of input it refuses. A page could take OBS down with one malformed argument.
 *
 * The Win32 conversions do not throw. Without MB_ERR_INVALID_CHARS an unconvertible sequence
 * becomes U+FFFD, so a malformed path turns into a path that is merely wrong, and is then
 * refused by the containment check or by the file operation like any other bad path.
 *
 * Fixing it here rather than at each call site is deliberate: this is the only thing in the
 * conversion that could throw, and a catch in one caller would leave the next one to be written
 * exposed again.
 */
std::string PluginJsHandler::ws_to_utf8(const std::wstring &str)
{
	if (str.empty())
		return std::string();

	const int needed = WideCharToMultiByte(CP_UTF8, 0, str.data(), (int)str.size(), nullptr, 0, nullptr, nullptr);

	if (needed <= 0)
		return std::string();

	std::string out((size_t)needed, '\0');
	WideCharToMultiByte(CP_UTF8, 0, str.data(), (int)str.size(), out.data(), needed, nullptr, nullptr);
	return out;
}

std::wstring PluginJsHandler::utf8_to_ws(const std::string &str)
{
	if (str.empty())
		return std::wstring();

	const int needed = MultiByteToWideChar(CP_UTF8, 0, str.data(), (int)str.size(), nullptr, 0);

	if (needed <= 0)
		return std::wstring();

	std::wstring out((size_t)needed, L'\0');
	MultiByteToWideChar(CP_UTF8, 0, str.data(), (int)str.size(), out.data(), needed);
	return out;
}

bool PluginJsHandler::resolveWithinDownloads(const std::wstring &downloadsDir, const std::string &inputPath, std::filesystem::path &out_resolved, std::string &out_error)
{
	if (downloadsDir.empty())
	{
		out_error = "File system can't access Local AppData folder";
		return false;
	}

	if (inputPath.empty())
	{
		out_error = "Invalid path: (empty)";
		return false;
	}

	std::filesystem::path root = std::filesystem::path(downloadsDir).lexically_normal();
	std::filesystem::path candidate = (root / utf8_to_ws(inputPath)).lexically_normal();

	std::wstring rootStr = root.wstring();
	std::wstring candStr = candidate.wstring();

	// Trailing separators on the root would throw off the boundary check below.
	while (!rootStr.empty() && (rootStr.back() == L'\\' || rootStr.back() == L'/'))
		rootStr.pop_back();

	auto toLower = [](std::wstring s) {
		std::transform(s.begin(), s.end(), s.begin(), [](wchar_t c) { return (wchar_t)::towlower(c); });
		return s;
	};

	const std::wstring rootLower = toLower(rootStr);
	const std::wstring candLower = toLower(candStr);

	const bool contained = (candLower == rootLower) || (candLower.size() > rootLower.size() && candLower.compare(0, rootLower.size(), rootLower) == 0 && (candLower[rootLower.size()] == L'\\' || candLower[rootLower.size()] == L'/'));

	if (!contained)
	{
		out_error = "Invalid path (escapes the Streamlabs folder): " + inputPath;
		return false;
	}

	out_resolved = candidate;
	return true;
}

bool PluginJsHandler::sha256File(const std::filesystem::path &filePath, std::string &out_hexDigest, std::string &out_error)
{
	std::ifstream file(filePath, std::ios::binary);

	if (!file)
	{
		out_error = "Unable to open file";
		return false;
	}

	BCRYPT_ALG_HANDLE hAlg = nullptr;
	BCRYPT_HASH_HANDLE hHash = nullptr;

	NTSTATUS status = BCryptOpenAlgorithmProvider(&hAlg, BCRYPT_SHA256_ALGORITHM, nullptr, 0);

	if (!BCRYPT_SUCCESS(status))
	{
		out_error = "BCryptOpenAlgorithmProvider failed";
		return false;
	}

	DWORD hashLen = 0;
	DWORD cbData = 0;
	status = BCryptGetProperty(hAlg, BCRYPT_HASH_LENGTH, (PUCHAR)&hashLen, sizeof(hashLen), &cbData, 0);

	if (!BCRYPT_SUCCESS(status))
	{
		BCryptCloseAlgorithmProvider(hAlg, 0);
		out_error = "BCryptGetProperty failed";
		return false;
	}

	status = BCryptCreateHash(hAlg, &hHash, nullptr, 0, nullptr, 0, 0);

	if (!BCRYPT_SUCCESS(status))
	{
		BCryptCloseAlgorithmProvider(hAlg, 0);
		out_error = "BCryptCreateHash failed";
		return false;
	}

	bool ok = true;
	std::vector<char> buffer(64 * 1024);

	while (file)
	{
		file.read(buffer.data(), (std::streamsize)buffer.size());
		std::streamsize got = file.gcount();

		if (got > 0)
		{
			status = BCryptHashData(hHash, (PUCHAR)buffer.data(), (ULONG)got, 0);

			if (!BCRYPT_SUCCESS(status))
			{
				out_error = "BCryptHashData failed";
				ok = false;
				break;
			}
		}
	}

	if (ok)
	{
		std::vector<unsigned char> digest(hashLen);
		status = BCryptFinishHash(hHash, digest.data(), hashLen, 0);

		if (BCRYPT_SUCCESS(status))
		{
			static const char *hex = "0123456789abcdef";
			out_hexDigest.clear();
			out_hexDigest.reserve((size_t)hashLen * 2);

			for (unsigned char b : digest)
			{
				out_hexDigest.push_back(hex[b >> 4]);
				out_hexDigest.push_back(hex[b & 0x0F]);
			}
		}
		else
		{
			out_error = "BCryptFinishHash failed";
			ok = false;
		}
	}

	BCryptDestroyHash(hHash);
	BCryptCloseAlgorithmProvider(hAlg, 0);
	return ok;
}