CommandBuilderTypes.cpp

#include "CommandBuilderTypes.h"

#include <metahook.h>
#include <event_api.h>
#include <pmtrace.h>
#include <pm_defs.h>

#include <rapidjson/document.h>
#include <rapidjson/istreamwrapper.h>
#include <rapidjson/ostreamwrapper.h>
#include <rapidjson/stringbuffer.h>
#include <rapidjson/prettywriter.h>

#include <fstream>
#include <algorithm>
#include <ctime>
#include <cmath>
#include <cctype>

extern cl_enginefunc_t gEngfuncs;
extern IFileSystem* g_pFileSystem;

using namespace rapidjson;

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

// ---------------------------------------------------------
// Helper: SteamID Formatting
// ---------------------------------------------------------

std::string FormatSteamID2(uint64_t steamId64)
{
	if (steamId64 == 0)
		return "STEAM_ID_PENDING";

	uint64_t base = 76561197960265728ULL;
	if (steamId64 > base)
	{
		uint64_t accId = steamId64 - base;
		uint32_t y = (uint32_t)(accId % 2);
		uint32_t z = (uint32_t)(accId / 2);
		char buf[64];
		snprintf(buf, sizeof(buf), "STEAM_0:%u:%u", y, z);
		return buf;
	}

	char buf[64];
	snprintf(buf, sizeof(buf), "%llu", (unsigned long long)steamId64);
	return buf;
}

std::string FormatSteamID3(uint64_t steamId64)
{
	if (steamId64 == 0)
		return "[U:1:0]";

	uint32_t accId = (uint32_t)(steamId64 & 0xFFFFFFFF);
	char buf[64];
	snprintf(buf, sizeof(buf), "[U:1:%u]", accId);
	return buf;
}

// ---------------------------------------------------------
// Helper: Aim / Raycast Trace
// ---------------------------------------------------------

static void AngleVectors(const float* angles, float* forward, float* right, float* up)
{
	float angle;
	float sr, sp, sy, cr, cp, cy;

	angle = angles[1] * (float)(M_PI * 2.0 / 360.0);
	sy = sinf(angle); cy = cosf(angle);

	angle = angles[0] * (float)(M_PI * 2.0 / 360.0);
	sp = sinf(angle); cp = cosf(angle);

	angle = angles[2] * (float)(M_PI * 2.0 / 360.0);
	sr = sinf(angle); cr = cosf(angle);

	if (forward) {
		forward[0] = cp * cy;
		forward[1] = cp * sy;
		forward[2] = -sp;
	}
}

bool GetLocalPlayerAimVector(float outOrigin[3], float outAimPoint[3])
{
	outOrigin[0] = outOrigin[1] = outOrigin[2] = 0.0f;
	outAimPoint[0] = outAimPoint[1] = outAimPoint[2] = 0.0f;

	cl_entity_t* pLocal = gEngfuncs.GetLocalPlayer();
	if (!pLocal)
		return false;

	float angles[3] = { 0 };
	gEngfuncs.GetViewAngles(angles);

	float forward[3] = { 0 };
	AngleVectors(angles, forward, NULL, NULL);

	float start[3] = { pLocal->origin[0], pLocal->origin[1], pLocal->origin[2] + 17.0f }; // Camera view offset
	outOrigin[0] = start[0]; outOrigin[1] = start[1]; outOrigin[2] = start[2];

	float end[3];
	end[0] = start[0] + forward[0] * 8192.0f;
	end[1] = start[1] + forward[1] * 8192.0f;
	end[2] = start[2] + forward[2] * 8192.0f;

	pmtrace_t tr = {};
	if (gEngfuncs.pEventAPI && gEngfuncs.pEventAPI->EV_PlayerTrace)
	{
		gEngfuncs.pEventAPI->EV_PlayerTrace(start, end, PM_STUDIO_BOX, -1, &tr);
		outAimPoint[0] = tr.endpos[0];
		outAimPoint[1] = tr.endpos[1];
		outAimPoint[2] = tr.endpos[2];
		return true;
	}

	outAimPoint[0] = end[0]; outAimPoint[1] = end[1]; outAimPoint[2] = end[2];
	return false;
}

// ---------------------------------------------------------
// Helper: Case-Insensitive String Replacement
// ---------------------------------------------------------

static void ReplaceAllIC(std::string& str, const std::string& from, const std::string& to)
{
	if (from.empty()) return;
	size_t startPos = 0;
	while (startPos < str.length())
	{
		auto it = std::search(
			str.begin() + startPos, str.end(),
			from.begin(), from.end(),
			[](char ch1, char ch2) { return std::tolower((unsigned char)ch1) == std::tolower((unsigned char)ch2); }
		);

		if (it == str.end())
			break;

		size_t pos = std::distance(str.begin(), it);
		str.replace(pos, from.length(), to);
		startPos = pos + to.length();
	}
}

bool TemplateNeedsInput(const std::string& tmpl)
{
	std::string lower = tmpl;
	std::transform(lower.begin(), lower.end(), lower.begin(), [](unsigned char c) { return (char)std::tolower(c); });
	return (lower.find("{input}") != std::string::npos ||
		lower.find("%input%") != std::string::npos ||
		lower.find("{reason}") != std::string::npos ||
		lower.find("%reason%") != std::string::npos ||
		lower.find("{text}") != std::string::npos ||
		lower.find("%text%") != std::string::npos ||
		lower.find("{vec3}") != std::string::npos ||
		lower.find("%vec3%") != std::string::npos);
}

// ---------------------------------------------------------
// Macro Engine Resolution
// Single Standard: Unified Curly Brace {...} Macros
// ---------------------------------------------------------

std::string ResolveTemplate(const std::string& tmpl, const PlayerEntry* targetPl, const std::string& userInput)
{
	std::string out = tmpl;

	// Target Player Macros
	if (targetPl)
	{
		ReplaceAllIC(out, "{playername}", targetPl->name);
		ReplaceAllIC(out, "%PLAYERNAME%", targetPl->name);
		ReplaceAllIC(out, "{name}", targetPl->name);
		ReplaceAllIC(out, "%NAME%", targetPl->name);

		ReplaceAllIC(out, "{playernum}", std::to_string(targetPl->client));
		ReplaceAllIC(out, "%PLAYERNUM%", std::to_string(targetPl->client));
		ReplaceAllIC(out, "{client}", std::to_string(targetPl->client));
		ReplaceAllIC(out, "%CLIENT%", std::to_string(targetPl->client));
		ReplaceAllIC(out, "{id}", std::to_string(targetPl->client));
		ReplaceAllIC(out, "%ID%", std::to_string(targetPl->client));

		ReplaceAllIC(out, "{steamid}", targetPl->steamId2);
		ReplaceAllIC(out, "%STEAMID%", targetPl->steamId2);
		ReplaceAllIC(out, "{steamid2}", targetPl->steamId2);
		ReplaceAllIC(out, "%STEAMID2%", targetPl->steamId2);

		ReplaceAllIC(out, "{steamid64}", std::to_string(targetPl->steamId64));
		ReplaceAllIC(out, "%STEAMID64%", std::to_string(targetPl->steamId64));

		ReplaceAllIC(out, "{steamid3}", targetPl->steamId3);
		ReplaceAllIC(out, "%STEAMID3%", targetPl->steamId3);
	}
	else
	{
		ReplaceAllIC(out, "{playername}", "{player}");
		ReplaceAllIC(out, "%PLAYERNAME%", "{player}");
		ReplaceAllIC(out, "{steamid}", "{steamid}");
		ReplaceAllIC(out, "%STEAMID%", "{steamid}");
	}

	// Local Player Macros
	hud_player_info_t localInfo = {};
	cl_entity_t* pLocal = gEngfuncs.GetLocalPlayer();
	int localIndex = pLocal ? pLocal->index : 1;
	gEngfuncs.pfnGetPlayerInfo(localIndex, &localInfo);

	std::string myName = (localInfo.name && localInfo.name[0]) ? localInfo.name : "Me";
	std::string mySteamID2 = FormatSteamID2(localInfo.m_nSteamID);
	std::string mySteamID64 = std::to_string(localInfo.m_nSteamID);

	ReplaceAllIC(out, "{myname}", myName);
	ReplaceAllIC(out, "%MYNAME%", myName);
	ReplaceAllIC(out, "{me}", myName);
	ReplaceAllIC(out, "%ME%", myName);

	ReplaceAllIC(out, "{myclient}", std::to_string(localIndex));
	ReplaceAllIC(out, "%MYCLIENT%", std::to_string(localIndex));

	ReplaceAllIC(out, "{mysteamid}", mySteamID2);
	ReplaceAllIC(out, "%MYSTEAMID%", mySteamID2);
	ReplaceAllIC(out, "{mysteamid64}", mySteamID64);
	ReplaceAllIC(out, "%MYSTEAMID64%", mySteamID64);

	// Positional / Aim Raycast Macros
	float myOrigin[3] = { 0 };
	float aimPoint[3] = { 0 };
	GetLocalPlayerAimVector(myOrigin, aimPoint);

	char aimStr[128];
	snprintf(aimStr, sizeof(aimStr), "%.1f %.1f %.1f", aimPoint[0], aimPoint[1], aimPoint[2]);

	char origStr[128];
	snprintf(origStr, sizeof(origStr), "%.1f %.1f %.1f", myOrigin[0], myOrigin[1], myOrigin[2]);

	ReplaceAllIC(out, "{aim}", aimStr);
	ReplaceAllIC(out, "%AIM%", aimStr);

	char bufX[32], bufY[32], bufZ[32];
	snprintf(bufX, sizeof(bufX), "%.1f", aimPoint[0]);
	snprintf(bufY, sizeof(bufY), "%.1f", aimPoint[1]);
	snprintf(bufZ, sizeof(bufZ), "%.1f", aimPoint[2]);

	ReplaceAllIC(out, "{aim_x}", bufX);
	ReplaceAllIC(out, "{aim_y}", bufY);
	ReplaceAllIC(out, "{aim_z}", bufZ);

	ReplaceAllIC(out, "{myorigin}", origStr);
	ReplaceAllIC(out, "%MYORIGIN%", origStr);

	// Custom User Input / Vec3 Macro
	if (!userInput.empty())
	{
		ReplaceAllIC(out, "{input}", userInput);
		ReplaceAllIC(out, "%INPUT%", userInput);
		ReplaceAllIC(out, "{reason}", userInput);
		ReplaceAllIC(out, "%REASON%", userInput);
		ReplaceAllIC(out, "{text}", userInput);
		ReplaceAllIC(out, "%TEXT%", userInput);
		ReplaceAllIC(out, "{vec3}", userInput);
		ReplaceAllIC(out, "%VEC3%", userInput);
	}
	else
	{
		// Preview state: keep clean {input} tag so user sees exact position of parameter
		ReplaceAllIC(out, "{vec3}", aimStr);
		ReplaceAllIC(out, "%VEC3%", aimStr);
	}

	// Date & Time Macros
	time_t tNow = time(nullptr);
	tm tmNow = {};
#if defined(_WIN32)
	localtime_s(&tmNow, &tNow);
#else
	localtime_r(&tNow, &tmNow);
#endif

	char dateBuf[64];
	strftime(dateBuf, sizeof(dateBuf), "%Y-%m-%d", &tmNow);

	char dateShortBuf[64];
	strftime(dateShortBuf, sizeof(dateShortBuf), "%Y%m%d", &tmNow);

	char timeBuf[64];
	strftime(timeBuf, sizeof(timeBuf), "%H:%M:%S", &tmNow);

	ReplaceAllIC(out, "{date}", dateBuf);
	ReplaceAllIC(out, "%DATE%", dateBuf);
	ReplaceAllIC(out, "{currentdate}", dateShortBuf);
	ReplaceAllIC(out, "%CURRENTDATE%", dateShortBuf);

	ReplaceAllIC(out, "{time}", timeBuf);
	ReplaceAllIC(out, "%TIME%", timeBuf);
	ReplaceAllIC(out, "{currenttime}", timeBuf);
	ReplaceAllIC(out, "%CURRENTTIME%", timeBuf);

	ReplaceAllIC(out, "{unixtime}", std::to_string((long long)tNow));
	ReplaceAllIC(out, "%UNIXTIME%", std::to_string((long long)tNow));

	// Clean up double spaces
	while (out.find("  ") != std::string::npos)
	{
		ReplaceAllIC(out, "  ", " ");
	}

	return out;
}

// ---------------------------------------------------------
// Queue Building & Execution
// ---------------------------------------------------------

std::vector<QueuedCommand> BuildQueue(const Preset& preset, const std::vector<PlayerEntry*>& selectedPlayers, const std::string& userInput)
{
	std::vector<QueuedCommand> queue;

	if (!preset.perPlayer || selectedPlayers.empty())
	{
		QueuedCommand q;
		q.display = ResolveTemplate(preset.tmpl, nullptr, userInput);
		q.payload = q.display;
		queue.push_back(q);
		return queue;
	}

	for (auto* pPl : selectedPlayers)
	{
		QueuedCommand q;
		q.display = ResolveTemplate(preset.tmpl, pPl, userInput);
		q.payload = q.display;
		queue.push_back(q);
	}

	return queue;
}

void FlushQueue(std::vector<QueuedCommand>& queue)
{
	for (const auto& q : queue)
	{
		if (!q.payload.empty())
		{
			gEngfuncs.pfnClientCmd((char*)q.payload.c_str());
		}
	}
	queue.clear();
}

// ---------------------------------------------------------
// Preset Persistence & Defaults
// ---------------------------------------------------------

static Preset ParsePresetObject(const Value& j)
{
	Preset p;
	if (j.HasMember("id") && j["id"].IsString()) p.id = j["id"].GetString();
	if (j.HasMember("label") && j["label"].IsString()) p.label = j["label"].GetString();
	if (j.HasMember("category") && j["category"].IsString()) p.category = j["category"].GetString();
	if (j.HasMember("template") && j["template"].IsString()) p.tmpl = j["template"].GetString();
	if (j.HasMember("perPlayer") && j["perPlayer"].IsBool()) p.perPlayer = j["perPlayer"].GetBool(); else p.perPlayer = true;
	if (j.HasMember("description") && j["description"].IsString()) p.description = j["description"].GetString();

	// Backward compatibility for legacy JSON files with separate prefix
	if (j.HasMember("prefix") && j["prefix"].IsString())
	{
		std::string pref = j["prefix"].GetString();
		if (!pref.empty() && pref != "none")
		{
			p.tmpl = pref + " " + p.tmpl;
		}
	}

	return p;
}

std::vector<Preset> GetDefaultPresets()
{
	return {
		{ "tp_to_me", "Teleport Player to Me", "Teleport", "say !tp {playername} me", true, "Teleport target player to local player position" },
		{ "tp_to_aim", "Teleport Player to Aim", "Teleport", "say !tp {playername} {aim}", true, "Teleport target player to crosshair aim point" },
		{ "tp_me_aim", "Teleport Myself to Aim", "Teleport", "say !tp me {aim}", false, "Teleport local player to crosshair aim point" },
		{ "ban_5m", "Ban 5 Minutes", "Moderation", "amx_ban \"{steamid}\" 5 \"{input}\"", true, "Ban player by SteamID for 5 minutes" },
		{ "kick", "Kick Player", "Moderation", "amx_kick \"{playername}\" \"{input}\"", true, "Kick player with optional reason" },
		{ "slap_0", "Slap (0 DMG)", "Moderation", "amx_slap \"{playername}\" 0", true, "Slap player for 0 damage" },
		{ "slay", "Slay Player", "Moderation", "amx_slay \"{playername}\"", true, "Slay target player" },
		{ "record_demo", "Record Demo", "Utility", "record {playername}_{date}_{time}", false, "Start recording demo with player & timestamp" },
		{ "status", "Check Status", "Utility", "status", false, "Print server status info to console" },
		{ "say_all", "Say to All", "Chat", "say {input}", false, "Send public chat message" },
		{ "say_team", "Say to Team", "Chat", "say_team {input}", false, "Send team chat message" }
	};
}

std::vector<Preset> LoadPresets(const std::string& path)
{
	std::vector<Preset> presets;
	std::string jsonContent;
	bool loaded = false;

	// 1. Try reading via g_pFileSystem search path cascade ("GAME")
	if (g_pFileSystem)
	{
		const char* searchPaths[] = {
			path.c_str(),
			"commandbuilder/presets.json",
			"commandbuilder_presets.json",
			"svencoop/commandbuilder_presets.json"
		};

		for (const auto* p : searchPaths)
		{
			FileHandle_t f = g_pFileSystem->Open(p, "rb", "GAME");
			if (!f) f = g_pFileSystem->Open(p, "rb");
			if (f)
			{
				unsigned sz = g_pFileSystem->Size(f);
				if (sz > 0)
				{
					jsonContent.resize(sz);
					g_pFileSystem->Read(&jsonContent[0], sz, f);
					loaded = true;
				}
				g_pFileSystem->Close(f);
				break;
			}
		}
	}

	// 2. Fallback to std::ifstream for relative paths
	if (!loaded)
	{
		const char* fallbackPaths[] = {
			path.c_str(),
			"commandbuilder/presets.json",
			"commandbuilder_presets.json",
			"svencoop/commandbuilder_presets.json"
		};

		for (const auto* p : fallbackPaths)
		{
			std::ifstream f(p, std::ios::binary);
			if (f.is_open())
			{
				jsonContent.assign((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
				loaded = true;
				break;
			}
		}
	}

	if (!loaded || jsonContent.empty())
	{
		presets = GetDefaultPresets();
		SavePresets(path, presets);
		return presets;
	}

	Document doc;
	doc.Parse(jsonContent.c_str());
	if (doc.HasParseError() || !doc.IsObject() || !doc.HasMember("presets") || !doc["presets"].IsArray())
	{
		return GetDefaultPresets();
	}

	for (const auto& item : doc["presets"].GetArray())
	{
		if (item.IsObject())
		{
			presets.push_back(ParsePresetObject(item));
		}
	}

	if (presets.empty())
		presets = GetDefaultPresets();

	return presets;
}

bool SavePresets(const std::string& path, const std::vector<Preset>& presets)
{
	StringBuffer sb;
	PrettyWriter<StringBuffer> writer(sb);

	writer.StartObject();
	writer.Key("presets");
	writer.StartArray();
	for (const auto& p : presets)
	{
		writer.StartObject();
		writer.Key("id"); writer.String(p.id.c_str());
		writer.Key("label"); writer.String(p.label.c_str());
		writer.Key("category"); writer.String(p.category.c_str());
		writer.Key("template"); writer.String(p.tmpl.c_str());
		writer.Key("perPlayer"); writer.Bool(p.perPlayer);
		writer.Key("description"); writer.String(p.description.c_str());
		writer.EndObject();
	}
	writer.EndArray();
	writer.EndObject();

	std::string jsonStr = sb.GetString();

	// 1. Try writing via g_pFileSystem
	if (g_pFileSystem)
	{
		g_pFileSystem->CreateDirHierarchy("commandbuilder");
		FileHandle_t f = g_pFileSystem->Open("commandbuilder/presets.json", "wt");
		if (f)
		{
			g_pFileSystem->Write(jsonStr.c_str(), jsonStr.length(), f);
			g_pFileSystem->Close(f);
			return true;
		}
	}

	// 2. Fallback to std::ofstream
	std::ofstream ofs(path, std::ios::binary);
	if (!ofs.is_open())
		return false;

	ofs.write(jsonStr.c_str(), jsonStr.length());
	return true;
}

// ---------------------------------------------------------
// Active Player Retrieval
// ---------------------------------------------------------

static const int MAX_ENGINE_PLAYERS = 32;

std::vector<PlayerEntry> GetActivePlayers()
{
	std::vector<PlayerEntry> players;
	for (int i = 1; i <= MAX_ENGINE_PLAYERS; i++)
	{
		hud_player_info_t info = {};
		gEngfuncs.pfnGetPlayerInfo(i, &info);
		if (!info.name || !info.name[0])
			continue;

		PlayerEntry entry;
		entry.client = i;
		entry.name = info.name;
		entry.steamId64 = (uint64_t)info.m_nSteamID;
		entry.steamId2 = FormatSteamID2(info.m_nSteamID);
		entry.steamId3 = FormatSteamID3(info.m_nSteamID);
		entry.ping = info.ping;
		entry.spectator = (info.spectator != 0);

		players.push_back(entry);
	}
	return players;
}