}

	return "";

}

static std::vector<std::string> getGroups(PurpleBuddy *m_buddy) {

	std::vector<std::string> groups;

	groups.push_back(purple_group_get_name(purple_buddy_get_group(m_buddy)) ? std::string(purple_group_get_name(purple_buddy_get_group(m_buddy))) : std::string("Buddies"));

	return groups;

}

static void buddyListNewNode(PurpleBlistNode *node) {

	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))

		return;

	PurpleBuddy *buddy = (PurpleBuddy *) node;

	PurpleAccount *account = purple_buddy_get_account(buddy);

	Swift::StatusShow status;

	std::string message;

	getStatus(buddy, status, message);

	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy)[0], (int) status.getType(), message, getIconHash(buddy));

}

	PurpleAccount *account = purple_buddy_get_account(buddy);

	Swift::StatusShow status;

	std::string message;

	getStatus(buddy, status, message);

	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy)[0], (int) status.getType(), message, getIconHash(buddy));

}

static void NodeRemoved(PurpleBlistNode *node, void *data) {

	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))

		return;

// 	PurpleBuddy *buddy = (PurpleBuddy *) node;

}

static PurpleBlistUiOps blistUiOps =

{

	NULL,

	buddyListNewNode,

	NULL,

	NULL, //NodeRemoved,

	NULL,

	NULL,

	NULL, // buddyListAddBuddy,

	NULL,

	NULL,

	NULL, //buddyListSaveNode,

	NULL, //buddyListRemoveNode,

	NULL, //buddyListSaveAccount,

	NULL

};

static void conv_write_im(PurpleConversation *conv, const char *who, const char *message, PurpleMessageFlags flags, time_t mtime) {

	// Don't forwards our own messages.

	if (flags & PURPLE_MESSAGE_SEND || flags & PURPLE_MESSAGE_SYSTEM)

		return;

	PurpleAccount *account = purple_conversation_get_account(conv);

	char *striped = purple_markup_strip_html(message);

	std::string msg = striped;

	g_free(striped);

	std::string w = who;

	size_t pos = w.find("/");

		/* Good default preferences */

		/* The combination of these two settings mean that libpurple will never

		 * (of its own accord) set all the user accounts idle.

		 */

		purple_prefs_set_bool("/purple/away/away_when_idle", false);

		/*

		 * This must be set to something not "none" for idle reporting to work

		 * for, e.g., the OSCAR prpl. We don't implement the UI ops, so this is

		 * okay for now.

		 */

		purple_prefs_set_string("/purple/away/idle_reporting", "system");

		/* Disable all logging */

		purple_prefs_set_bool("/purple/logging/log_ims", false);

		purple_prefs_set_bool("/purple/logging/log_chats", false);

		purple_prefs_set_bool("/purple/logging/log_system", false);

// 		purple_signal_connect(purple_conversations_get_handle(), "received-im-msg", &conversation_handle, PURPLE_CALLBACK(newMessageReceived), NULL);

// 		purple_signal_connect(purple_conversations_get_handle(), "buddy-typing", &conversation_handle, PURPLE_CALLBACK(buddyTyping), NULL);

// 		purple_signal_connect(purple_conversations_get_handle(), "buddy-typed", &conversation_handle, PURPLE_CALLBACK(buddyTyped), NULL);

// 		purple_signal_connect(purple_conversations_get_handle(), "buddy-typing-stopped", &conversation_handle, PURPLE_CALLBACK(buddyTypingStopped), NULL);

		purple_signal_connect(purple_connections_get_handle(), "signed-on", &blist_handle,PURPLE_CALLBACK(signed_on), NULL);

// 		purple_signal_connect(purple_blist_get_handle(), "buddy-removed", &blist_handle,PURPLE_CALLBACK(buddyRemoved), NULL);

		purple_signal_connect(purple_blist_get_handle(), "blist-node-removed", &blist_handle,PURPLE_CALLBACK(NodeRemoved), NULL);

// 		purple_signal_connect(purple_conversations_get_handle(), "chat-topic-changed", &conversation_handle, PURPLE_CALLBACK(conv_chat_topic_changed), NULL);

// 

// 		purple_commands_init();

	}

	return ret;

}

int main(int argc, char **argv) {

	GError *error = NULL;

	GOptionContext *context;

	context = g_option_context_new("config_file_name or profile name");

	g_option_context_add_main_entries(context, options_entries, "");

	if (!g_option_context_parse (context, &argc, &argv, &error)) {

		std::cout << "option parsing failed: " << error->message << "\n";

		return -1;

	}

	if (ver) {

// 		std::cout << VERSION << "\n";

		std::cout << "verze\n";

		g_option_context_free(context);

		void updateUserSetting(long userId, const std::string &variable, const std::string &value);

		void beginTransaction();

		void commitTransaction();

	private:

		bool exec(const std::string &query);

		sqlite3 *m_db;

		Config *m_config;

		std::string m_prefix;

		// statements

		sqlite3_stmt *m_setUser;

		sqlite3_stmt *m_getUser;

		sqlite3_stmt *m_getUserSetting;

		sqlite3_stmt *m_setUserSetting;

		sqlite3_stmt *m_updateUserSetting;

		sqlite3_stmt *m_removeUser;

		sqlite3_stmt *m_removeUserBuddies;

		sqlite3_stmt *m_removeUserSettings;

		sqlite3_stmt *m_removeUserBuddiesSettings;

		sqlite3_stmt *m_addBuddy;

		sqlite3_stmt *m_updateBuddy;

		sqlite3_stmt *m_getBuddies;

		sqlite3_stmt *m_getBuddiesSettings;

};

}

	std::string alias = getAlias();

	std::string name = getSafeName();

	Swift::StatusShow s;

	std::string statusMessage;

	if (!getStatus(s, statusMessage))

		return Swift::Presence::ref();

	Swift::Presence::ref presence = Swift::Presence::create();

 	presence->setFrom(m_jid);

	presence->setTo(m_rosterManager->getUser()->getJID().toBare());

	presence->setType(Swift::Presence::Available);

	if (!statusMessage.empty())

		presence->setStatus(statusMessage);

	if (s.getType() == Swift::StatusShow::None)

		presence->setType(Swift::Presence::Unavailable);

	presence->setShow(s.getType());

	if (presence->getType() != Swift::Presence::Unavailable) {

		// caps

// 		presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::CapsInfo (CONFIG().caps)));

			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::VCardUpdate (getIconHash())));

	}

	if (only_new) {

		if (m_lastPresence)

			m_lastPresence->setTo(Swift::JID(""));

		if (m_lastPresence == presence) {

			return Swift::Presence::ref();

		}

		m_lastPresence = presence;

	}

	return presence;

}

std::string Buddy::getSafeName() {

	if (m_jid.isValid()) {

		return m_jid.getNode();

	}

	std::string name = getName();

// 	Transport::instance()->protocol()->prepareUsername(name, purple_buddy_get_account(m_buddy));

	if (getFlags() & BUDDY_JID_ESCAPING) {

		name = Swift::JID::getEscapedNode(name);

	}

	else {

		}

		boost::signal<void (NetworkConversation *, boost::shared_ptr<Swift::Message> &)> onMessageToSend;

};

class NetworkFactory : public Factory {

	public:

		NetworkFactory(NetworkPluginServer *nps) {

			m_nps = nps;

		}

		Conversation *createConversation(ConversationManager *conversationManager, const std::string &legacyName) {

			NetworkConversation *nc = new NetworkConversation(conversationManager, legacyName);

			nc->onMessageToSend.connect(boost::bind(&NetworkPluginServer::handleMessageReceived, m_nps, _1, _2));

			return nc;

		}

		Buddy *createBuddy(RosterManager *rosterManager, const BuddyInfo &buddyInfo) {

			LocalBuddy *buddy = new LocalBuddy(rosterManager, buddyInfo.id);

			buddy->setAlias(buddyInfo.alias);

			buddy->setName(buddyInfo.legacyName);

			buddy->setSubscription(buddyInfo.subscription);

			buddy->setGroups(buddyInfo.groups);

			buddy->setFlags((BuddyFlag) buddyInfo.flags);

			return buddy;

		}

	private:

		NetworkPluginServer *m_nps;

};

#define WRAP(MESSAGE, TYPE) 	pbnetwork::WrapperMessage wrap; \

	wrap.set_type(TYPE); \

	wrap.set_payload(MESSAGE); \

	wrap.SerializeToString(&MESSAGE);

static int exec_(const char *path, const char *host, const char *port, const char *config) {

// 	char *argv[] = {(char*)script_name, '\0'}; 

	int status = 0;

	pid_t pid = fork();

	if ( pid == 0 ) {

		// child process

		execlp(path, path, "--host", host, "--port", port, config, NULL);

		exit(1);

	} else if ( pid < 0 ) {

		// fork failed

		status = -1;

	}

	return status;

#include "transport/buddy.h"

#include "transport/user.h"

#include "Swiften/Roster/SetRosterRequest.h"

#include "Swiften/Elements/RosterPayload.h"

#include "Swiften/Elements/RosterItemPayload.h"

#include "Swiften/Elements/RosterItemExchangePayload.h"

namespace Transport {

RosterManager::RosterManager(User *user, Component *component){

	m_rosterStorage = NULL;

	m_user = user;

	m_component = component;

	m_setBuddyTimer = m_component->getFactories()->getTimerFactory()->createTimer(1000);

	m_RIETimer = m_component->getFactories()->getTimerFactory()->createTimer(5000);

	m_RIETimer->onTick.connect(boost::bind(&RosterManager::sendRIE, this));

}

RosterManager::~RosterManager() {

	m_setBuddyTimer->stop();

	m_RIETimer->stop();

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

		Buddy *buddy = (*it).second;

		delete buddy;

	}

	if (m_rosterStorage)

		delete m_rosterStorage;

}

void RosterManager::setBuddy(Buddy *buddy) {

// 	m_setBuddyTimer->onTick.connect(boost::bind(&RosterManager::setBuddyCallback, this, buddy));

// 	m_setBuddyTimer->start();

	setBuddyCallback(buddy);

}

void RosterManager::sendBuddyRosterPush(Buddy *buddy) {

	Swift::RosterPayload::ref payload = Swift::RosterPayload::ref(new Swift::RosterPayload());

	Swift::RosterItemPayload item;

	item.setJID(buddy->getJID().toBare());

	item.setName(buddy->getAlias());

	item.setGroups(buddy->getGroups());

	payload->addItem(item);

	Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(payload, m_user->getJID().toBare(), m_component->getIQRouter());

	m_storageTimer->stop();

}

void RosterStorage::storeBuddy(Buddy *buddy) {

	m_buddies[buddy->getName()] = buddy;

	m_storageTimer->start();

}

bool RosterStorage::storeBuddies() {

	if (m_buddies.size() == 0) {

		return false;

	}

	m_storageBackend->beginTransaction();

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

		Buddy *buddy = (*it).second;

		BuddyInfo buddyInfo;

		buddyInfo.alias = buddy->getAlias();

		buddyInfo.legacyName = buddy->getName();

		buddyInfo.groups = buddy->getGroups();

		buddyInfo.subscription = buddy->getSubscription();

		buddyInfo.id = buddy->getID();

		buddyInfo.flags = buddy->getFlags();

		// Buddy is in DB

		if (buddyInfo.id != -1) {

			m_storageBackend->updateBuddy(m_user->getUserInfo().id, buddyInfo);

		}

		else {

			buddyInfo.id = m_storageBackend->addBuddy(m_user->getUserInfo().id, buddyInfo);

			buddy->setID(buddyInfo.id);

		}

// 		Log("buddyListSaveNode", id << " " << name << " " << alias << " " << s_buddy->getSubscription());

// 		if (s_buddy->getBuddy() && id != -1) {

// 			PurpleBuddy *buddy = s_buddy->getBuddy();

// 			SaveData *s = new SaveData;

// 			s->user = user;

// 			s->id = id;

// 			g_hash_table_foreach(buddy->node.settings, save_settings, s);

// 			delete s;

// 		}

	}

	m_storageBackend->commitTransaction();

	return true;

}

SQLite3Backend::~SQLite3Backend(){

	if (m_db) {

		// Would be nice to use this:

		//

		//   sqlite3_stmt *pStmt;

		//   while((pStmt = sqlite3_next_stmt(db, 0)) != 0 ) {

		//    sqlite3_finalize(pStmt);

		//   }

		//

		// But requires SQLite3 >= 3.6.0 beta

		FINALIZE_STMT(m_setUser);

		FINALIZE_STMT(m_getUser);

		FINALIZE_STMT(m_removeUser);

		FINALIZE_STMT(m_removeUserBuddies);

		FINALIZE_STMT(m_removeUserSettings);

		FINALIZE_STMT(m_removeUserBuddiesSettings);

		FINALIZE_STMT(m_addBuddy);

		FINALIZE_STMT(m_updateBuddy);

		FINALIZE_STMT(m_getBuddies);

		FINALIZE_STMT(m_getBuddiesSettings);

		FINALIZE_STMT(m_getUserSetting);

		FINALIZE_STMT(m_setUserSetting);

		FINALIZE_STMT(m_updateUserSetting);

		sqlite3_close(m_db);

	}

}

bool SQLite3Backend::connect() {

	if (sqlite3_open(CONFIG_STRING(m_config, "database.database").c_str(), &m_db)) {

		sqlite3_close(m_db);

		return false;

	}

	if (createDatabase() == false)

		return false;

	PREP_STMT(m_setUser, "INSERT INTO " + m_prefix + "users (jid, uin, password, language, encoding, last_login, vip) VALUES (?, ?, ?, ?, ?, DATETIME('NOW'), ?)");

	PREP_STMT(m_getUser, "SELECT id, jid, uin, password, encoding, language, vip FROM " + m_prefix + "users WHERE jid=?");

	PREP_STMT(m_removeUser, "DELETE FROM " + m_prefix + "users WHERE id=?");

	PREP_STMT(m_removeUserBuddies, "DELETE FROM " + m_prefix + "buddies WHERE user_id=?");

	PREP_STMT(m_removeUserSettings, "DELETE FROM " + m_prefix + "users_settings WHERE user_id=?");

	PREP_STMT(m_removeUserBuddiesSettings, "DELETE FROM " + m_prefix + "buddies_settings WHERE user_id=?");

	PREP_STMT(m_addBuddy, "INSERT INTO " + m_prefix + "buddies (user_id, uin, subscription, groups, nickname, flags) VALUES (?, ?, ?, ?, ?, ?)");

	PREP_STMT(m_updateBuddy, "UPDATE " + m_prefix + "buddies SET groups=?, nickname=?, flags=?, subscription=? WHERE user_id=? AND uin=?");

	PREP_STMT(m_getBuddies, "SELECT id, uin, subscription, nickname, groups, flags FROM " + m_prefix + "buddies WHERE user_id=? ORDER BY id ASC");

	PREP_STMT(m_getBuddiesSettings, "SELECT buddy_id, type, var, value FROM " + m_prefix + "buddies_settings WHERE user_id=? ORDER BY buddy_id ASC");

	PREP_STMT(m_getUserSetting, "SELECT type, value FROM " + m_prefix + "users_settings WHERE user_id=? AND var=?");

	PREP_STMT(m_setUserSetting, "INSERT INTO " + m_prefix + "users_settings (user_id, var, type, value) VALUES (?,?,?,?)");

	PREP_STMT(m_updateUserSetting, "UPDATE " + m_prefix + "users_settings SET value=? WHERE user_id=? AND var=?");

	return true;

}

bool SQLite3Backend::createDatabase() {

	int not_exist = exec("CREATE TABLE " + m_prefix + "buddies ("

				"  id INTEGER PRIMARY KEY NOT NULL,"

				"  user_id int(10) NOT NULL,"

				"  uin varchar(255) NOT NULL,"

				"  subscription varchar(20) NOT NULL,"

				"  nickname varchar(255) NOT NULL,"

				"  groups varchar(255) NOT NULL,"

				"  flags int(4) NOT NULL DEFAULT '0'"

				");");

	if (not_exist) {

		exec("CREATE UNIQUE INDEX IF NOT EXISTS user_id ON " + m_prefix + "buddies (user_id, uin);");

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

					"  user_id int(10) NOT NULL,"

					"  buddy_id int(10) NOT NULL,"

		onStorageError("getUser query", (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));

	}

	return false;

}

void SQLite3Backend::setUserOnline(long id, bool online) {

}

long SQLite3Backend::addBuddy(long userId, const BuddyInfo &buddyInfo) {

// 	"INSERT INTO " + m_prefix + "buddies (user_id, uin, subscription, groups, nickname, flags) VALUES (?, ?, ?, ?, ?, ?)"

	BEGIN(m_addBuddy);

	BIND_INT(m_addBuddy, userId);

	BIND_STR(m_addBuddy, buddyInfo.legacyName);

	BIND_STR(m_addBuddy, buddyInfo.subscription);

	BIND_STR(m_addBuddy, buddyInfo.groups[0]); // TODO: serialize groups

	BIND_STR(m_addBuddy, buddyInfo.alias);

	BIND_INT(m_addBuddy, buddyInfo.flags);

	if(sqlite3_step(m_addBuddy) != SQLITE_DONE) {

		onStorageError("addBuddy query", (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));

		return -1;

	}

}

void SQLite3Backend::updateBuddy(long userId, const BuddyInfo &buddyInfo) {

// 	UPDATE " + m_prefix + "buddies SET groups=?, nickname=?, flags=?, subscription=? WHERE user_id=? AND uin=?

	BEGIN(m_updateBuddy);

	BIND_STR(m_updateBuddy, buddyInfo.groups[0]); // TODO: serialize groups

	BIND_STR(m_updateBuddy, buddyInfo.alias);

	BIND_INT(m_updateBuddy, buddyInfo.flags);

	BIND_STR(m_updateBuddy, buddyInfo.subscription);

	BIND_INT(m_updateBuddy, userId);

	BIND_STR(m_updateBuddy, buddyInfo.legacyName);

	EXECUTE_STATEMENT(m_updateBuddy, "updateBuddy query");

}

bool SQLite3Backend::getBuddies(long id, std::list<BuddyInfo> &roster) {

//	SELECT id, uin, subscription, nickname, groups, flags FROM " + m_prefix + "buddies WHERE user_id=? ORDER BY id ASC

	BEGIN(m_getBuddies);

	BIND_INT(m_getBuddies, id);

// 	"SELECT buddy_id, type, var, value FROM " + m_prefix + "buddies_settings WHERE user_id=? ORDER BY buddy_id ASC"

	BEGIN(m_getBuddiesSettings);

	BIND_INT(m_getBuddiesSettings, id);

	SettingVariableInfo var;

	long buddy_id = -1;

	std::string key;

	int ret;

	while((ret = sqlite3_step(m_getBuddies)) == SQLITE_ROW) {

		BuddyInfo b;

		RESET_GET_COUNTER(m_getBuddies);

		b.id = GET_INT(m_getBuddies);

		b.legacyName = GET_STR(m_getBuddies);

		b.subscription = GET_STR(m_getBuddies);

		b.alias = GET_STR(m_getBuddies);

		b.groups.push_back(GET_STR(m_getBuddies));

		b.flags = GET_INT(m_getBuddies);

		if (buddy_id == b.id) {

			std::cout << "Adding buddy info " << key << "\n";

			b.settings[key] = var;

			buddy_id = -1;

		}

		while(buddy_id == -1 && (ret = sqlite3_step(m_getBuddiesSettings)) == SQLITE_ROW) {

			buddy_id = GET_INT(m_getBuddiesSettings);

			var.type = GET_INT(m_getBuddiesSettings);

			key = GET_STR(m_getBuddiesSettings);

			std::string val = GET_STR(m_getBuddiesSettings);

			switch (var.type) {

				case TYPE_BOOLEAN:

					var.b = atoi(val.c_str());

					break;

				case TYPE_STRING:

					var.s = val;

					break;

				default:

					break;

			}

			if (buddy_id == b.id) {

				std::cout << "Adding buddy info " << key << "=" << val << "\n";

				b.settings[key] = var;

				buddy_id = -1;

			}

		}

// 		if (ret != SQLITE_DONE) {

// 			onStorageError("getBuddiesSettings query", (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));

// 			return false;

// 		}

		roster.push_back(b);

	}

	if (ret != SQLITE_DONE) {

		onStorageError("getBuddies query", (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));

		return false;

	}

	return true;

}