* 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., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA

 */

#include "transport/admininterface.h"

#include "transport/user.h"

#include "transport/transport.h"

#include "transport/storagebackend.h"

#include "transport/conversationmanager.h"

#include "transport/rostermanager.h"

#include "transport/usermanager.h"

#include "transport/networkpluginserver.h"

#include "transport/logging.h"

#include "transport/userregistration.h"

#include "storageresponder.h"

#include "transport/memoryusage.h"

#include <boost/foreach.hpp>

namespace Transport {

DEFINE_LOGGER(logger, "AdminInterface");

static std::string getArg(const std::string &body) {

	std::string ret;

	if (body.find(" ") == std::string::npos)

		return ret;

	return body.substr(body.find(" ") + 1);

}

AdminInterface::AdminInterface(Component *component, UserManager *userManager, NetworkPluginServer *server, StorageBackend *storageBackend, UserRegistration *userRegistration) {

	m_component = component;

	m_storageBackend = storageBackend;

	m_userManager = userManager;

	m_server = server;

	m_userRegistration = userRegistration;

	m_start = time(NULL);

	m_component->getStanzaChannel()->onMessageReceived.connect(bind(&AdminInterface::handleMessageReceived, this, _1));

}

AdminInterface::~AdminInterface() {

}

void AdminInterface::handleQuery(Swift::Message::ref message) {

	message->setTo(message->getFrom());

	message->setFrom(m_component->getJID());

	if (message->getBody() == "status") {

		int users = m_userManager->getUserCount();

		int backends = m_server->getBackendCount();

		message->setBody("Running (" + boost::lexical_cast<std::string>(users) + " users connected using " + boost::lexical_cast<std::string>(backends) + " backends)");

	}

	else if (message->getBody() == "uptime") {

		message->setBody(boost::lexical_cast<std::string>(time(0) - m_start));

	}

	else if (message->getBody() == "online_users") {

		std::string lst;

		const std::map<std::string, User *> &users = m_userManager->getUsers();

		if (users.size() == 0)

			lst = "0";

		for (std::map<std::string, User *>::const_iterator it = users.begin(); it != users.end(); it ++) {

			lst += (*it).first + "\n";

		}

		message->setBody(lst);

	}

	else if (message->getBody() == "online_users_count") {

		int users = m_userManager->getUserCount();

		message->setBody(boost::lexical_cast<std::string>(users));

	}

	else if (message->getBody() == "reload") {

		bool done = m_component->getConfig()->reload();

		if (done) {

			message->setBody("Config reloaded");

		}

		else {

			message->setBody("Error during config reload");

		}

	}

	else if (message->getBody() == "online_users_per_backend") {

		std::string lst;

		int id = 1;

		const std::list <NetworkPluginServer::Backend *> &backends = m_server->getBackends();

		for (std::list <NetworkPluginServer::Backend *>::const_iterator b = backends.begin(); b != backends.end(); b++) {

			NetworkPluginServer::Backend *backend = *b;

			lst += "Backend " + boost::lexical_cast<std::string>(id) + " (ID=" + backend->id + ")";

			lst += backend->acceptUsers ? "" : " - not-accepting";

			lst += backend->longRun ? " - long-running" : "";

			lst += ":\n";

			if (backend->users.size() == 0) {

			lst += backend + "\n";

		}

		message->setBody(lst);

	}

	else if (message->getBody() == "crashed_backends_count") {

		message->setBody(boost::lexical_cast<std::string>(m_server->getCrashedBackends().size()));

	}

	else if (message->getBody() == "messages_from_xmpp") {

		int msgCount = m_userManager->getMessagesToBackend();

		message->setBody(boost::lexical_cast<std::string>(msgCount));

	}

	else if (message->getBody() == "messages_to_xmpp") {

		int msgCount = m_userManager->getMessagesToXMPP();

		message->setBody(boost::lexical_cast<std::string>(msgCount));

	}

	else if (message->getBody().find("register ") == 0 && m_userRegistration) {

		std::string body = message->getBody();

		std::vector<std::string> args;

		boost::split(args, body, boost::is_any_of(" "));

		if (args.size() == 4) {

			UserInfo res;

			res.jid = args[1];

			res.uin = args[2];

			res.password = args[3];

			res.language = "en";

			res.encoding = "utf-8";

			res.vip = 0;

			if (m_userRegistration->registerUser(res)) {

				message->setBody("User registered.");

			}

			else {

				message->setBody("Registration failed: User is already registered");

			}

		}

		else {

			message->setBody("Bad argument count. See 'help'.");

		}

	}

	else if (message->getBody().find("unregister ") == 0 && m_userRegistration) {

		std::string body = message->getBody();

		std::vector<std::string> args;

		boost::split(args, body, boost::is_any_of(" "));

		if (args.size() == 2) {

			if (m_userRegistration->unregisterUser(args[1])) {

				message->setBody("User '" + args[1] + "' unregistered.");

			}

			else {

			}

		}

		else {

			message->setBody("Bad argument count. See 'help'.");

		}

	}

	else if (message->getBody().find("help") == 0) {

		std::string help;

		help += "General:\n";

		help += "    status - shows instance status\n";

		help += "    reload - Reloads config file\n";

		help += "    uptime - returns ptime in seconds\n";

		help += "Users:\n";

		help += "    online_users - returns list of all online users\n";

		help += "    online_users_count - number of online users\n";

		help += "    online_users_per_backend - shows online users per backends\n";

		help += "    has_online_user <bare_JID> - returns 1 if user is online\n";

		if (m_userRegistration) {

			help += "    register <bare_JID> <legacyName> <password> - registers the new user\n";

			help += "    unregister <bare_JID> - unregisters existing user\n";

		}

		help += "Messages:\n";

		help += "    messages_from_xmpp - get number of messages received from XMPP users\n";

		help += "    messages_to_xmpp - get number of messages sent to XMPP users\n";

		help += "Backends:\n";

		help += "    backends_count - number of active backends\n";

		help += "    crashed_backends - returns IDs of crashed backends\n";

		help += "    crashed_backends_count - returns number of crashed backends\n";

		help += "Memory:\n";

		help += "    res_memory - Total RESident memory spectrum2 and its backends use in KB\n";

		help += "    shr_memory - Total SHaRed memory spectrum2 backends share together in KB\n";

		help += "    used_memory - (res_memory - shr_memory)\n";

		help += "    average_memory_per_user - (memory_used_without_any_user - res_memory)\n";

		help += "    res_memory_per_backend - RESident memory used by backends in KB\n";

		help += "    shr_memory_per_backend - SHaRed memory used by backends in KB\n";

		help += "    used_memory_per_backend - (res_memory - shr_memory) per backend\n";

		help += "    average_memory_per_user_per_backend - (memory_used_without_any_user - res_memory) per backend\n";

		message->setBody(help);

	}

	else {

		message->setBody("Unknown command. Try \"help\"");

	}

}

void AdminInterface::handleMessageReceived(Swift::Message::ref message) {

	if (!message->getTo().getNode().empty())

MySQLBackend::MySQLBackend(Config *config) {

	m_config = config;

	m_prefix = CONFIG_STRING(m_config, "database.prefix");

	mysql_init(&m_conn);

	my_bool my_true = 1;

	mysql_options(&m_conn, MYSQL_OPT_RECONNECT, &my_true);

}

MySQLBackend::~MySQLBackend(){

	disconnect();

}

void MySQLBackend::disconnect() {

	LOG4CXX_INFO(logger, "Disconnecting");

	delete m_setUser;

	delete m_getUser;

	delete m_removeUser;

	delete m_removeUserBuddies;

	delete m_removeUserSettings;

	delete m_removeUserBuddiesSettings;

	delete m_addBuddy;

	delete m_updateBuddy;

	delete m_getBuddies;

	delete m_getBuddiesSettings;

	delete m_getUserSetting;

	delete m_setUserSetting;

	delete m_updateUserSetting;

	delete m_updateBuddySetting;

	delete m_setUserOnline;

	delete m_getOnlineUsers;

	mysql_close(&m_conn);

}

bool MySQLBackend::connect() {

	LOG4CXX_INFO(logger, "Connecting MySQL server " << CONFIG_STRING(m_config, "database.server") << ", user " <<

		CONFIG_STRING(m_config, "database.user") << ", database " << CONFIG_STRING(m_config, "database.database") <<

		", port " << CONFIG_INT(m_config, "database.port")

	);

	if (!mysql_real_connect(&m_conn, CONFIG_STRING(m_config, "database.server").c_str(),

					   CONFIG_STRING(m_config, "database.user").c_str(),

					   CONFIG_STRING(m_config, "database.password").c_str(),

					   CONFIG_STRING(m_config, "database.database").c_str(),

					   CONFIG_INT(m_config, "database.port"), NULL, 0)) {

		LOG4CXX_ERROR(logger, "Can't connect database: " << mysql_error(&m_conn));

		return false;

	}

	createDatabase();

	m_setUser = new Statement(&m_conn, "sssssbss", "INSERT INTO " + m_prefix + "users (jid, uin, password, language, encoding, last_login, vip) VALUES (?, ?, ?, ?, ?, NOW(), ?) ON DUPLICATE KEY UPDATE uin=?, password=?");

	m_getUser = new Statement(&m_conn, "s|isssssb", "SELECT id, jid, uin, password, encoding, language, vip FROM " + m_prefix + "users WHERE jid=?");

	m_removeUser = new Statement(&m_conn, "i", "DELETE FROM " + m_prefix + "users WHERE id=?");

	m_removeUserBuddies = new Statement(&m_conn, "i", "DELETE FROM " + m_prefix + "buddies WHERE user_id=?");

	m_removeUserSettings = new Statement(&m_conn, "i", "DELETE FROM " + m_prefix + "users_settings WHERE user_id=?");

	m_removeUserBuddiesSettings = new Statement(&m_conn, "i", "DELETE FROM " + m_prefix + "buddies_settings WHERE user_id=?");

	m_addBuddy = new Statement(&m_conn, "issssi", "INSERT INTO " + m_prefix + "buddies (user_id, uin, subscription, groups, nickname, flags) VALUES (?, ?, ?, ?, ?, ?)");

	m_updateBuddy = new Statement(&m_conn, "ssisis", "UPDATE " + m_prefix + "buddies SET groups=?, nickname=?, flags=?, subscription=? WHERE user_id=? AND uin=?");

	m_getBuddies = new Statement(&m_conn, "i|issssi", "SELECT id, uin, subscription, nickname, groups, flags FROM " + m_prefix + "buddies WHERE user_id=? ORDER BY id ASC");

	m_getBuddiesSettings = new Statement(&m_conn, "i|iiss", "SELECT buddy_id, type, var, value FROM " + m_prefix + "buddies_settings WHERE user_id=? ORDER BY buddy_id ASC");

	m_updateBuddySetting = new Statement(&m_conn, "iisiss", "INSERT INTO " + m_prefix + "buddies_settings (user_id, buddy_id, var, type, value) VALUES (?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE value=?");

	m_getUserSetting = new Statement(&m_conn, "is|is", "SELECT type, value FROM " + m_prefix + "users_settings WHERE user_id=? AND var=?");

	m_setUserSetting = new Statement(&m_conn, "isis", "INSERT INTO " + m_prefix + "users_settings (user_id, var, type, value) VALUES (?,?,?,?)");

	m_updateUserSetting = new Statement(&m_conn, "sis", "UPDATE " + m_prefix + "users_settings SET value=? WHERE user_id=? AND var=?");

	m_setUserOnline = new Statement(&m_conn, "bi", "UPDATE " + m_prefix + "users SET online=?, last_login=NOW()  WHERE id=?");

	m_getOnlineUsers = new Statement(&m_conn, "|s", "SELECT jid FROM " + m_prefix + "users WHERE online=1");

	return true;

}

bool MySQLBackend::createDatabase() {

	int not_exist = exec("CREATE TABLE IF NOT EXISTS `" + m_prefix + "buddies` ("

							"`id` int(10) unsigned NOT NULL auto_increment,"

							"`user_id` int(10) unsigned NOT NULL,"

							"`uin` varchar(255) collate utf8_bin NOT NULL,"

							"`subscription` enum('to','from','both','ask','none') collate utf8_bin NOT NULL,"

							"`nickname` varchar(255) collate utf8_bin NOT NULL,"

							"`groups` varchar(255) collate utf8_bin NOT NULL,"

							"`flags` smallint(4) NOT NULL DEFAULT '0',"

							"PRIMARY KEY (`id`),"

							"UNIQUE KEY `user_id` (`user_id`,`uin`)"

						") ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;");

	if (not_exist) {

		exec("CREATE TABLE IF NOT EXISTS `" + m_prefix + "buddies_settings` ("

				"`user_id` int(10) unsigned NOT NULL,"

				"`buddy_id` int(10) unsigned NOT NULL,"

				"`var` varchar(50) collate utf8_bin NOT NULL,"

				"`type` smallint(4) unsigned NOT NULL,"

				"`value` varchar(255) collate utf8_bin NOT NULL,"

				"PRIMARY KEY (`buddy_id`,`var`),"

				"KEY `user_id` (`user_id`)"