eqemu-server/common/rulesys.cpp

/*	EQEMu: Everquest Server Emulator
	Copyright (C) 2001-2006 EQEMu Development Team (http://eqemulator.net)

	This program is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; version 2 of the License.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY except by those people which sell it, which
	are required to give you total support for your newly bought product;
	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
	A PARTICULAR PURPOSE. See the GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

#include "rulesys.h"
#include "database.h"
#include "string_util.h"
#include <cstdlib>
#include <cstring>
#include <fmt/format.h>

/*
	Commands:
	#rules:
	current -> lists current set name
	switch (set name) -> change set in the DB, but dont reload
	load (set name) -> load set into this zone without changing the world
	wload (set name) -> tell world and all zones to load this rule set
	store [set name] -> store the current rules in this zone to the set (or active if not specified)
	reset -> reset all rule values to their defaults.
	list [catname]
	set (cat) (rule) (value)
	values [catname] -> show the values of all rules in the specified category/
*/

const char *RuleManager::s_categoryNames[_CatCount+1] = {
	#define RULE_CATEGORY(catname) \
		#catname ,
	#include "ruletypes.h"
	"InvalidCategory"
};

const RuleManager::RuleInfo RuleManager::s_RuleInfo[_IntRuleCount+_RealRuleCount+_BoolRuleCount+1] = {
	/* this is done in three steps so we can reliably get to them by index*/
	#define RULE_INT(cat, rule, default_value, notes) \
		{ #cat ":" #rule, Category__##cat, IntRule, Int__##rule, notes },
	#include "ruletypes.h"
	#define RULE_REAL(cat, rule, default_value, notes) \
		{ #cat ":" #rule, Category__##cat, RealRule, Real__##rule, notes },
	#include "ruletypes.h"
	#define RULE_BOOL(cat, rule, default_value, notes) \
		{ #cat ":" #rule, Category__##cat, BoolRule, Bool__##rule, notes },
	#include "ruletypes.h"
	{ "Invalid Rule", _CatCount, IntRule }
};

RuleManager::RuleManager()
:	m_activeRuleset(0),
	m_activeName("default")
{
	ResetRules(false);
}

RuleManager::CategoryType RuleManager::FindCategory(const char *catname) {
	int i;
	for (i = 0; i < _CatCount; i++) {
		if (strcasecmp(catname, s_categoryNames[i]) == 0)
			return((CategoryType)i);
	}
	return(InvalidCategory);
}

bool RuleManager::ListRules(const char *catname, std::vector<const char *> &into) {
	CategoryType cat = InvalidCategory;
	if (catname != nullptr) {
		cat = FindCategory(catname);
		if (cat == InvalidCategory) {
			Log(Logs::Detail, Logs::Rules, "Unable to find category '%s'", catname);
			return(false);
		}
	}
	int i;
	int rule_count = CountRules();
	for (i = 0; i < rule_count; i++) {
		const RuleInfo &rule = s_RuleInfo[i];
		if (catname == nullptr || cat == rule.category) {
			into.push_back(rule.name);
		}
	}
	return(true);
}

bool RuleManager::ListCategories(std::vector<const char *> &into) {
	int i;
	for (i = 0; i < _CatCount; i++) {
		into.push_back(s_categoryNames[i]);
	}
	return(true);
}

bool RuleManager::GetRule(const char *rule_name, std::string &return_value) {
	RuleType type;
	uint16 index;
	if (!_FindRule(rule_name, type, index))
		return false;

	char tmp[255] = "";
	switch(type) {
		case IntRule:
			sprintf(tmp, "%i", m_RuleIntValues[index]);
			break;
		case RealRule:
			sprintf(tmp, "%f", m_RuleRealValues[index]);
			break;
		case BoolRule:
			std::string tmp_val = m_RuleBoolValues[index] ? "true" : "false";
			sprintf(tmp, "%s", tmp_val.c_str());
			break;
	}

	return_value = tmp;

	return true;
}

bool RuleManager::SetRule(const char *rule_name, const char *rule_value, Database *database, bool db_save, bool reload) {
	if(rule_name == nullptr || rule_value == nullptr)
		return(false);

	RuleType type;
	uint16 index;
	if(!_FindRule(rule_name, type, index))
		return(false);

	if (reload) {
		if (strcasecmp(rule_name, "World:ExpansionSettings") == 0)
			return(false);
		if (strcasecmp(rule_name, "World:UseClientBasedExpansionSettings") == 0)
			return(false);
	}

	switch(type) {
		case IntRule:
			m_RuleIntValues[index] = atoi(rule_value);
			Log(Logs::Detail, Logs::Rules, "Set rule %s to value %d", rule_name, m_RuleIntValues[index]);
			break;
		case RealRule:
			m_RuleRealValues[index] = atof(rule_value);
			Log(Logs::Detail, Logs::Rules, "Set rule %s to value %.13f", rule_name, m_RuleRealValues[index]);
			break;
		case BoolRule:
			uint32 val = 0;
			if (!strcasecmp(rule_value, "on") || !strcasecmp(rule_value, "true") || !strcasecmp(rule_value, "yes") || !strcasecmp(rule_value, "enabled") || !strcmp(rule_value, "1"))
				val = 1;

			m_RuleBoolValues[index] = val;
			Log(Logs::Detail, Logs::Rules, "Set rule %s to value %s", rule_name, m_RuleBoolValues[index] == 1 ? "true" : "false");
			break;
	}

	if(db_save)
		_SaveRule(database, type, index);

	return(true);
}

void RuleManager::ResetRules(bool reload) {
	std::string expansion1;
	std::string expansion2;

	// these rules must not change during server runtime
	if (reload) {
		GetRule("World:ExpansionSettings", expansion1);
		GetRule("World:UseClientBasedExpansionSettings", expansion2);
	}

	Log(Logs::Detail, Logs::Rules, "Resetting running rules to default values");
	#define RULE_INT(cat, rule, default_value, notes) \
		m_RuleIntValues[ Int__##rule ] = default_value;
	#define RULE_REAL(cat, rule, default_value, notes) \
		m_RuleRealValues[ Real__##rule ] = default_value;
	#define RULE_BOOL(cat, rule, default_value, notes) \
		m_RuleBoolValues[ Bool__##rule ] = default_value;
	#include "ruletypes.h"

	// restore these rules to their pre-reset values
	if (reload) {
		SetRule("World:ExpansionSettings", expansion1.c_str(), nullptr, false, false);
		SetRule("World:UseClientBasedExpansionSettings", expansion2.c_str(), nullptr, false, false);
	}
}

bool RuleManager::_FindRule(const char *rule_name, RuleType &type_into, uint16 &index_into) {
	if (rule_name == nullptr)
		return(false);

	int i;
	int rule_count = CountRules();
	for (i = 0; i < rule_count; i++) {
		const RuleInfo &rule = s_RuleInfo[i];
		if (strcmp(rule_name, rule.name) == 0) {
			type_into = rule.type;
			index_into = rule.rule_index;
			return(true);
		}
	}
	Log(Logs::Detail, Logs::Rules, "Unable to find rule '%s'", rule_name);
	return(false);
}

//assumes index is valid!
const char *RuleManager::_GetRuleName(RuleType type, uint16 index) {
	switch (type) {
		case IntRule:
			return(s_RuleInfo[index].name);
		case RealRule:
			return(s_RuleInfo[index + _IntRuleCount].name);
		case BoolRule:
			return(s_RuleInfo[index + _IntRuleCount + _RealRuleCount].name);
	}
	//should never happen
	return("InvalidRule??");
}

//assumes index is valid!
const std::string &RuleManager::_GetRuleNotes(RuleType type, uint16 index) {
	switch (type) {
	case IntRule:
		return(s_RuleInfo[index].notes);
	case RealRule:
		return(s_RuleInfo[index + _IntRuleCount].notes);
	case BoolRule:
		return(s_RuleInfo[index + _IntRuleCount + _RealRuleCount].notes);
	}
	//should never happen
	return(std::string());
}

bool RuleManager::LoadRules(Database *database, const char *ruleset_name, bool reload) {

	int ruleset_id = this->GetRulesetID(database, ruleset_name);
	if (ruleset_id < 0) {
		Log(Logs::Detail, Logs::Rules, "Failed to find ruleset '%s' for load operation. Canceling.", ruleset_name);
		return (false);
	}

	m_activeRuleset = ruleset_id;
	m_activeName = ruleset_name;

	/* Load default ruleset values first if we're loading something other than default */
	if (strcasecmp(ruleset_name, "default") != 0) {

		std::string default_ruleset_name = "default";
		int         default_ruleset_id = GetRulesetID(database, default_ruleset_name.c_str());

		if (default_ruleset_id < 0) {
			Log(Logs::Detail,
				Logs::Rules,
				"Failed to find default ruleset '%s' for load operation. Canceling.",
				default_ruleset_name.c_str()
			);

			return (false);
		}

		Log(Logs::Detail, Logs::Rules, "Processing rule set '%s' (%d) load...", default_ruleset_name.c_str(), default_ruleset_id);

		std::string query = StringFormat(
			"SELECT `rule_name`, `rule_value` FROM `rule_values` WHERE `ruleset_id` = '%d'",
			default_ruleset_id
		);

		auto results = database->QueryDatabase(query);
		if (!results.Success()) {
			return false;
		}

		for (auto row = results.begin(); row != results.end(); ++row) {
			if (!SetRule(row[0], row[1], nullptr, false, reload)) {
				Log(Logs::Detail, Logs::Rules, "Unable to interpret rule record for '%s'", row[0]);
			}
		}
	}

	Log(Logs::Detail, Logs::Rules, "Processing rule set '%s' (%d) load...", ruleset_name, ruleset_id);

	std::string query = StringFormat("SELECT `rule_name`, `rule_value` FROM `rule_values` WHERE `ruleset_id` = '%d'", ruleset_id);

	auto results = database->QueryDatabase(query);
	if (!results.Success()) {
		return false;
	}

	for (auto row = results.begin(); row != results.end(); ++row) {
		if (!SetRule(row[0], row[1], nullptr, false, reload)) {
			Log(Logs::Detail, Logs::Rules, "Unable to interpret rule record for '%s'", row[0]);
		}
	}

	return true;
}

// convert this to a single REPLACE query (it can handle it - currently at 608 rules)
void RuleManager::SaveRules(Database *database, const char *ruleset_name) {
	// tbh, UpdateRules() can probably be called since it will handle deletions of
	// orphaned entries of existing rulesets as well as adding the new ones
	// (it already does it as a single REPLACE query)

	if (ruleset_name != nullptr) {
		//saving to a specific name
		if (m_activeName != ruleset_name) {
			//a new name...

			m_activeRuleset = _FindOrCreateRuleset(database, ruleset_name);
			if (m_activeRuleset == -1) {
				Log(Logs::Detail, Logs::Rules, "Unable to find or create rule set %s", ruleset_name);
				return;
			}
			m_activeName = ruleset_name;
		}
		Log(Logs::Detail, Logs::Rules, "Saving running rules into rule set %s (%d)", ruleset_name, m_activeRuleset);
	}
	else {
		Log(Logs::Detail, Logs::Rules, "Saving running rules into running rule set %s", m_activeName.c_str(), m_activeRuleset);
	}

	// this should be all that is needed..with the exception of handling expansion-based rules...
	// (those really need to be put somewhere else - probably variables)
	//UpdateRules(database, m_activeName.c_str(), m_activeRuleset, true);

	int i;
	for (i = 0; i < _IntRuleCount; i++) {
		_SaveRule(database, IntRule, i);
	}
	for (i = 0; i < _RealRuleCount; i++) {
		_SaveRule(database, RealRule, i);
	}
	for (i = 0; i < _BoolRuleCount; i++) {
		_SaveRule(database, BoolRule, i);
	}
}

void RuleManager::_SaveRule(Database *database, RuleType type, uint16 index) {
	char value_string[100];

	if (type == IntRule && strcasecmp(_GetRuleName(type, index), "World:ExpansionSettings") == 0)
		return;
	if (type == BoolRule && strcasecmp(_GetRuleName(type, index), "World:UseClientBasedExpansionSettings") == 0)
		return;
	
	switch (type) {
		case IntRule:
			sprintf(value_string, "%d", m_RuleIntValues[index]);
			break;
		case RealRule:
			sprintf(value_string, "%.13f", m_RuleRealValues[index]);
			break;
		case BoolRule:
			sprintf(value_string, "%s", m_RuleBoolValues[index] ? "true" : "false");
			break;
	}

	std::string query = StringFormat(
			"REPLACE INTO `rule_values`"
			"(`ruleset_id`, `rule_name`, `rule_value`, `notes`)"
			" VALUES('%d', '%s', '%s', '%s')",
			m_activeRuleset,
			_GetRuleName(type, index),
			value_string,
			EscapeString(_GetRuleNotes(type, index)).c_str()
	);

	database->QueryDatabase(query);
}

bool RuleManager::UpdateChangedRules(Database *db, const char *ruleset_name, bool quiet_update)
{
	return false;
}

bool RuleManager::UpdateInjectedRules(Database *db, const char *ruleset_name, bool quiet_update)
{
	std::vector<std::string> database_data;
	std::map<std::string, std::pair<std::string, const std::string *>> rule_data;
	std::vector<std::tuple<int, std::string, std::string, std::string>> injected_rule_entries;

	if (!db) {
		return false;
	}

	if (ruleset_name == nullptr) {
		return false;
	}

	int ruleset_id = GetRulesetID(db, ruleset_name);
	if (ruleset_id < 0) {
		return false;
	}

	// load database rule names
	std::string query(StringFormat("SELECT `rule_name` FROM `rule_values` WHERE `ruleset_id` = '%i'", ruleset_id));

	auto results = db->QueryDatabase(query);
	if (!results.Success()) {
		return false;
	}

	// build database data entries
	for (auto &row : results) {
		database_data.push_back(std::string(row[0]));
	}

	// build rule data entries
	for (const auto &ri_iter : s_RuleInfo) {
		if (strcasecmp(ri_iter.name, "Invalid Rule") == 0) {
			continue;
		}

		char buffer[100];

		switch (ri_iter.type) {
		case IntRule:
			sprintf(buffer, "%d", m_RuleIntValues[ri_iter.rule_index]);
			rule_data[ri_iter.name].first = buffer;
			rule_data[ri_iter.name].second = &ri_iter.notes;
			break;
		case RealRule:
			sprintf(buffer, "%.13f", m_RuleRealValues[ri_iter.rule_index]);
			rule_data[ri_iter.name].first = buffer;
			rule_data[ri_iter.name].second = &ri_iter.notes;
			break;
		case BoolRule:
			sprintf(buffer, "%s", (m_RuleBoolValues[ri_iter.rule_index] ? "true" : "false"));
			rule_data[ri_iter.name].first = buffer;
			rule_data[ri_iter.name].second = &ri_iter.notes;
			break;
		default:
			break;
		}
	}

	// build injected entries
	for (const auto &rd_iter : rule_data) {
		
		const auto &dd_iter = std::find(database_data.begin(), database_data.end(), rd_iter.first);
		if (dd_iter == database_data.end()) {

			injected_rule_entries.push_back(
				std::tuple<int, std::string, std::string, std::string>(
					ruleset_id,								// `ruleset_id`
					rd_iter.first,							// `rule_name`
					rd_iter.second.first,					// `rule_value`	
					EscapeString(*rd_iter.second.second)	// `notes`
				)
			);

			if (!quiet_update) {
				Log(Logs::General,
					Logs::Status,
					"New Rule '%s' found... Adding to `rule_values` table with ruleset '%s' (%i) and rule value '%s'...",
					rd_iter.first.c_str(),
					ruleset_name,
					ruleset_id,
					rd_iter.second.first.c_str()
				);
			}
		}
	}

	if (injected_rule_entries.size()) {
		return _UpdateRules(db, ruleset_name, ruleset_id, injected_rule_entries, std::vector<std::string>());
	}
	else {
		return true;
	}
}

bool RuleManager::UpdateOrphanedRules(Database *db, bool quiet_update)
{
	std::vector<std::string> rule_data;
	std::vector<std::string> orphaned_rule_entries;

	if (!db) {
		return false;
	}

	// load database rule names
	std::string query("SELECT `rule_name` FROM `rule_values` GROUP BY `rule_name`");

	auto results = db->QueryDatabase(query);
	if (!results.Success()) {
		return false;
	}

	// build rule data entries
	for (const auto &ri_iter : s_RuleInfo) {
		if (strcasecmp(ri_iter.name, "Invalid Rule") == 0) {
			continue;
		}

		rule_data.push_back(ri_iter.name);
	}

	// build orphaned entries
	for (auto &row : results) {
		
		const auto &rd_iter = std::find(rule_data.begin(), rule_data.end(), row[0]);
		if (rd_iter == rule_data.end()) {

			orphaned_rule_entries.push_back(std::string(row[0]));

			if (!quiet_update) {
				Log(Logs::General,
					Logs::Status,
					"Rule '%s' no longer exists... Deleting orphaned entry from `rule_values` table...",
					row[0]
				);
			}
		}
	}

	if (orphaned_rule_entries.size()) {
		return _UpdateRules(
			db,
			"All Rulesets",
			-1,
			std::vector<std::tuple<int, std::string, std::string, std::string>>(),
			orphaned_rule_entries
		);
	}
	else {
		return true;
	}
}

bool RuleManager::_UpdateRules(
	Database *db,
	const char *ruleset_name,
	const int ruleset_id,
	const std::vector<std::tuple<int, std::string, std::string, std::string>> &injected,
	const std::vector<std::string> &orphaned
)
{
	bool return_value = true;

	if (!db) {
		return false;
	}

	if (ruleset_name == nullptr) {
		return false;
	}

	if (injected.size()) {

		if (ruleset_id >= 0 && strcasecmp(ruleset_name, "All Rulesets") != 0) {

			std::string query(
				fmt::format(
					"REPLACE INTO `rule_values`(`ruleset_id`, `rule_name`, `rule_value`, `notes`) VALUES {}",
					implode(
						",",
						std::pair<char, char>('(', ')'),
						join_tuple(",", std::pair<char, char>('\'', '\''), injected)
					)
				)
			);

			if (!db->QueryDatabase(query).Success()) {
				return_value = false;
			}
			else {
				Log(Logs::General,
					Logs::Status,
					"%u New Command%s Added to ruleset '%s' (%i)",
					injected.size(),
					(injected.size() == 1 ? "" : "s"),
					ruleset_name,
					ruleset_id
				);
			}
		}
		else {
			return_value = false;
		}
	}

	if (orphaned.size()) {

		std::string query;

		if (ruleset_id < 0 && strcasecmp(ruleset_name, "All Rulesets") == 0) {

			query = fmt::format(
				"DELETE FROM `rule_values` WHERE `rule_name` IN ({})",
				implode(",", std::pair<char, char>('\'', '\''), orphaned)
			);
		}
		else if (ruleset_id >= 0 && strcasecmp(ruleset_name, "All Rulesets") != 0) {

			query = fmt::format(
				"DELETE FROM `rule_values` WHERE `ruleset_id` = '%i' AND `rule_name` IN ({})",
				ruleset_id,
				implode(",", std::pair<char, char>('\'', '\''), orphaned)
			);
		}
		
		if (query.size() > 0) {

			if (!db->QueryDatabase(query).Success()) {
				return_value = false;
			}
			else {
				Log(Logs::General,
					Logs::Status,
					"%u Orphaned Command%s Deleted from ruleset '%s' (%i)",
					orphaned.size(),
					(orphaned.size() == 1 ? "" : "s"),
					ruleset_name,
					ruleset_id
				);
			}
		}
		else {
			return_value = false;
		}
	}

	return return_value;
}

int RuleManager::GetRulesetID(Database *database, const char *ruleset_name) {

	uint32 len = static_cast<uint32>(strlen(ruleset_name));
	auto rst = new char[2 * len + 1];
	database->DoEscapeString(rst, ruleset_name, len);

	std::string query = StringFormat("SELECT ruleset_id FROM rule_sets WHERE name='%s'", rst);
	safe_delete_array(rst);
	auto results = database->QueryDatabase(query);
	if (!results.Success())
		return -1;

	if (results.RowCount() == 0)
		return -1;

	auto row = results.begin();

	return atoi(row[0]);
}

int RuleManager::_FindOrCreateRuleset(Database *database, const char *in_ruleset_name) {

	int ruleset_id = GetRulesetID(database, in_ruleset_name);
	if (ruleset_id >= 0)
		return ruleset_id;	//found and existing one...

	uint32 len = strlen(in_ruleset_name);
	auto ruleset_name = new char[2 * len + 1];
	database->DoEscapeString(ruleset_name, in_ruleset_name, len);

	std::string query = StringFormat("INSERT INTO rule_sets (ruleset_id, name) VALUES(0, '%s')", ruleset_name);
	safe_delete_array(ruleset_name);
	auto results = database->QueryDatabase(query);
	if (!results.Success())
		return -1;

	return results.LastInsertedID();
}

std::string RuleManager::GetRulesetName(Database *database, int ruleset_id) {
	std::string query = StringFormat("SELECT name FROM rule_sets WHERE ruleset_id=%d", ruleset_id);
	auto results = database->QueryDatabase(query);
	if (!results.Success())
		return "";

	if (results.RowCount() == 0)
		return "";

	auto row = results.begin();

	return row[0];
}

bool RuleManager::ListRulesets(Database *database, std::map<int, std::string> &into) {

	//start out with the default set which is always present.
	into[0] = "default";

	std::string query = "SELECT ruleset_id, name FROM rule_sets";
	auto results = database->QueryDatabase(query);
	if (results.Success())
		return false;

	for (auto row = results.begin(); row != results.end(); ++row)
		into[atoi(row[0])] = row[1];

	return true;
}

int32 RuleManager::GetIntRule(RuleManager::IntType t) const
{
	return (m_RuleIntValues[t]);
}

float RuleManager::GetRealRule(RuleManager::RealType t) const
{
	return (m_RuleRealValues[t]);
}

bool RuleManager::GetBoolRule(RuleManager::BoolType t) const
{
	return (m_RuleBoolValues[t] == 1);
}