--- a/src/strategist.cc	Sun Feb 09 23:18:57 2025 -0500
+++ b/src/strategist.cc	Mon Feb 10 00:07:21 2025 -0500
@@ -11,8 +11,6 @@
  * anymore, and we just pass the result vector to different function that append
  * to the result (which is better imo) */
 
-namespace animone::internal {
-
 static bool ApplyWindowTitleFormat(const std::string& format, std::string& title) {
 	if (format.empty())
 		return false;
@@ -39,19 +37,18 @@
 	return true;
 }
 
-static MediaInfoType InferMediaInformationType(const std::string& str) {
+static animone::MediaInfoType InferMediaInformationType(const std::string& str) {
 	const std::regex path_pattern(R"(^(?:[A-Za-z]:[/\\]|\\\\)[^<>:"/\\|?*]+)");
-	return (std::regex_search(str, path_pattern)) ? MediaInfoType::File : MediaInfoType::Unknown;
+	return (std::regex_search(str, path_pattern)) ? animone::MediaInfoType::File : animone::MediaInfoType::Unknown;
 }
 
-static bool AddMedia(Result& result, const MediaInfo media_information) {
+static bool AddMedia(animone::Result *result, const animone::MediaInfo media_information) {
 	if (media_information.value.empty())
 		return false;
 
-	Media media = {
-		.information = {media_information}
-	};
-	result.media.push_back(std::move(media));
+	animone::Media media;
+	media.information = {media_information};
+	result->media.push_back(std::move(media));
 
 	return true;
 }
@@ -59,70 +56,78 @@
 /* ------------------------------------------------------------------------- */
 /* strategies */
 
-static bool ApplyWindowTitleStrategy(std::vector<Result>& results) {
+typedef bool (*strategy_spec_t)(animone::Result *results, size_t results_size);
+
+static bool ApplyWindowTitleStrategy(animone::Result *results, size_t results_size) {
 	bool success = false;
 
-	for (auto& result : results) {
-		auto title = result.window.text;
+	for (size_t i = 0; i < results_size; i++) {
+		auto title = results[i].window.text;
 		if (title.empty())
 			continue;
 
-		ApplyWindowTitleFormat(result.player.window_title_format, title);
+		ApplyWindowTitleFormat(results[i].player.window_title_format, title);
 
-		success |= AddMedia(result, {InferMediaInformationType(title), title});
+		success |= AddMedia(&results[i], {InferMediaInformationType(title), title});
 	}
 
 	return success;
 }
 
-static bool ApplyOpenFilesStrategy(std::vector<Result>& results) {
+static bool ApplyOpenFilesStrategy(animone::Result *results, size_t results_size) {
 	bool success = false;
 
-	/* map pids to our results, saves time with open_file_proc */
-	std::unordered_map<pid_t, Result*> pid_map;
-	std::set<pid_t> pids;
+	std::set<animone::internal::pid_t> pids;
+
+	for (size_t i = 0; i < results_size; i++)
+		pids.insert(results[i].process.pid);
+
+	auto open_file_proc = [&](const animone::internal::OpenFile& file) -> bool {
+		animone::Result *result = NULL;
 
-	for (Result& result : results) {
-		const pid_t pid = result.process.pid;
-		if (!pid)
-			continue;
+		for (size_t i = 0; i < results_size; i++) {
+			if (results[i].process.pid == file.pid) {
+				result = &results[i];
+				break;
+			}
+		}
 
-		pid_map.insert({pid, &result});
-		pids.insert(pid);
-	}
+		if (!result)
+			return false;
 
-	auto open_file_proc = [&](const OpenFile& file) -> bool {
-		success |= AddMedia(*pid_map[file.pid], {MediaInfoType::File, file.path});
+		success |= AddMedia(result, {animone::MediaInfoType::File, file.path});
 		return true;
 	};
 
-	EnumerateOpenFiles(pids, open_file_proc);
+	animone::internal::EnumerateOpenFiles(pids, open_file_proc);
 
 	return success;
 }
 
-static bool ApplyAccessibilityStrategy(std::vector<Result>& results) {
-	bool success = false;
+static bool ApplyAccessibilityStrategy(animone::Result *results, size_t results_size) {
+	int success = 0;
 
-	for (Result& result : results) {
-		auto web_browser_proc = [&result](const WebBrowserInformation& info) {
+	for (size_t i = 0; i < results_size; i++) {
+		// TODO refactor our processing function specs to take in userdata
+
+		auto web_browser_proc = [results, i](const animone::internal::WebBrowserInformation& info) -> void {
 			auto value = info.value;
 
 			switch (info.type) {
-				case WebBrowserInformationType::Address:
-					AddMedia(result, {MediaInfoType::Url, value});
-					break;
-				case WebBrowserInformationType::Title:
-					ApplyWindowTitleFormat(result.player.window_title_format, value);
-					AddMedia(result, {MediaInfoType::Title, value});
-					break;
-				case WebBrowserInformationType::Tab:
-					AddMedia(result, {MediaInfoType::Tab, value});
-					break;
+			case animone::internal::WebBrowserInformationType::Address:
+				AddMedia(&results[i], {animone::MediaInfoType::Url, value});
+				break;
+			case animone::internal::WebBrowserInformationType::Title:
+				ApplyWindowTitleFormat(results[i].player.window_title_format, value);
+				AddMedia(&results[i], {animone::MediaInfoType::Title, value});
+				break;
+			case animone::internal::WebBrowserInformationType::Tab:
+				AddMedia(&results[i], {animone::MediaInfoType::Tab, value});
+				break;
 			}
 		};
 
-		success |= GetWebBrowserInformation(result, web_browser_proc);
+		success |= animone::internal::GetWebBrowserInformation(results[i], web_browser_proc);
 	}
 
 	return success;
@@ -130,14 +135,19 @@
 
 /* ------------------------------------------------------------------------- */
 
-bool ApplyStrategies(std::vector<Result>& results) {
-	bool success = false;
+int animone_internal_ApplyStrategies(animone::Result *results, size_t results_size)
+{
+	static const strategy_spec_t strategies[] = {
+		ApplyWindowTitleStrategy,
+		ApplyOpenFilesStrategy,
+		ApplyAccessibilityStrategy
+	};
 
-	success |= ApplyWindowTitleStrategy(results);
-	success |= ApplyOpenFilesStrategy(results);
-	success |= ApplyAccessibilityStrategy(results);
+	int success = 0;
+
+	for (size_t i = 0; i < (sizeof(strategies)/sizeof(*strategies)); i++)
+		success |= strategies[i](results, results_size);
 
 	return success;
 }
 
-} // namespace animone::internal