/// \param config cofiguration, this class uses following Config values:

		/// 	- database.database - path to SQLite3 database file, database file is created automatically

		/// 	- service.prefix - prefix for tables created by createDatabase method

		MySQLBackend(Config *config);

		/// Destructor.

		~MySQLBackend();

		/// Connects to the database and creates it if it's needed. This method call createDatabase() function

		/// automatically.

		/// \return true if database is opened successfully.

		bool connect();

		/// Creates database structure.

		/// \see connect()

		/// \return true if database structure has been created successfully. Note that it returns True also if database structure

		/// already exists.

		bool createDatabase();

		/// Stores user into database.

		/// \param user user struct containing all information about user which have to be stored

		void setUser(const UserInfo &user);

		/// Gets user data from database and stores them into user reference.

		void beginTransaction();

		void commitTransaction();

	private:

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

		class Statement {

			public:

				Statement(MYSQL *conn, const std::string &format, const std::string &statement);

				~Statement();

				int fetch();

				// Pushes new data used as input for the statement.

				template <typename T>

				Statement& operator << (const T& t);

				Statement& operator << (const std::string& str);

				// Pulls fetched data by previous execute(); call.

				template <typename T>

				Statement& operator >> (T& t);

				Statement& operator >> (std::string& t);

			private:

				MYSQL_STMT *m_stmt;

				MYSQL *m_conn;

				std::vector<MYSQL_BIND> m_params;

				std::vector<MYSQL_BIND> m_results;

				int m_resultOffset;

				int m_offset;

				int m_error;

				std::string m_string;

		};

		MYSQL m_conn;

		Config *m_config;

		std::string m_prefix;

		// statements

// 		MYSQL_STMT *m_setUser;

		Statement *m_setUser;

		Statement *m_getUser;

		Statement *m_getUserSetting;

		Statement *m_setUserSetting;

		Statement *m_updateUserSetting;

		Statement *m_removeUser;

MySQLBackend::Statement::~Statement() {

	for (int i = 0; i < m_params.size(); i++) {

		free(m_params[i].buffer);

		free(m_params[i].length);

	}

	for (int i = 0; i < m_results.size(); i++) {

		free(m_results[i].buffer);

		free(m_results[i].length);

	}

	FINALIZE_STMT(m_stmt);

}

	// If statement has some input and doesn't have any output, we have

	// to clear the offset now, because operator>> will not be called.

	m_offset = 0;

	m_resultOffset = 0;

	int ret;

	if ((ret = mysql_stmt_execute(m_stmt)) != 0) {

		LOG4CXX_ERROR(logger, m_string << " " << mysql_stmt_error(m_stmt) << "; " << mysql_error(m_conn));

	}

}

int MySQLBackend::Statement::fetch() {

	return mysql_stmt_fetch(m_stmt);

}

template <typename T>

MySQLBackend::Statement& MySQLBackend::Statement::operator << (const T& t) {

	if (m_offset >= m_params.size())

		return *this;

	int *data = (int *) m_params[m_offset].buffer;

	*data = (int) t;

	return *this;

}

MySQLBackend::MySQLBackend(Config *config) {

	m_config = config;

	mysql_init(&m_conn);

	my_bool my_true = 1;

	mysql_options(&m_conn, MYSQL_OPT_RECONNECT, &my_true);

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

}

MySQLBackend::~MySQLBackend(){

	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;

	return true;

}

bool MySQLBackend::exec(const std::string &query) {

	if (mysql_query(&m_conn, query.c_str())) {

		LOG4CXX_ERROR(logger, query << " " << mysql_error(&m_conn));

		return false;

	}

	return true;

}

void MySQLBackend::setUser(const UserInfo &user) {

	*m_setUser << user.jid << user.uin << user.password << user.language << user.encoding << user.vip << user.password;

}

bool MySQLBackend::getUser(const std::string &barejid, UserInfo &user) {

	*m_getUser << barejid;

		return false;

	int ret = false;

	while (m_getUser->fetch() == 0) {

		ret = true;

		*m_getUser >> user.id >> user.jid >> user.uin >> user.password >> user.encoding >> user.language >> user.vip;

	}

	return ret;

}

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

	*m_setUserOnline << online << id;

}

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

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

	*m_addBuddy << userId << buddyInfo.legacyName << buddyInfo.subscription;

	*m_addBuddy << (buddyInfo.groups.size() == 0 ? "" : buddyInfo.groups[0]);

	*m_addBuddy << buddyInfo.alias << buddyInfo.flags;

	long id = (long) mysql_insert_id(&m_conn);

// 	INSERT OR REPLACE INTO " + m_prefix + "buddies_settings (user_id, buddy_id, var, type, value) VALUES (?, ?, ?, ?, ?)

	if (!buddyInfo.settings.find("icon_hash")->second.s.empty()) {

		*m_updateBuddySetting << userId << id << buddyInfo.settings.find("icon_hash")->first << (int) TYPE_STRING << buddyInfo.settings.find("icon_hash")->second.s << buddyInfo.settings.find("icon_hash")->second.s;

	}

	return id;

}

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

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

	*m_updateBuddy << (buddyInfo.groups.size() == 0 ? "" : buddyInfo.groups[0]);

	*m_updateBuddy << buddyInfo.alias << buddyInfo.flags << buddyInfo.subscription;

	*m_updateBuddy << userId << buddyInfo.legacyName;

}

bool MySQLBackend::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

	*m_getBuddies << id;

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

	*m_getBuddiesSettings << id;

	SettingVariableInfo var;

	long buddy_id = -1;

	std::string key;

		return false;

	while (m_getBuddies->fetch() == 0) {

		BuddyInfo b;

		std::string group;

		*m_getBuddies >> b.id >> b.legacyName >> b.subscription >> b.alias >> group >> b.flags;

		if (!group.empty())

			b.groups.push_back(group);

		roster.push_back(b);

	}

		return false;

	BOOST_FOREACH(BuddyInfo &b, roster) {

		if (buddy_id == b.id) {

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

			b.settings[key] = var;

			buddy_id = -1;

		}

		while(buddy_id == -1 && m_getBuddiesSettings->fetch() == 0) {

			std::string val;

			*m_getBuddiesSettings >> buddy_id >> var.type >> key >> val;

	}

	while(m_getBuddiesSettings->fetch() == 0) {

		// TODO: probably remove those settings, because there's no buddy for them.

		// It should not happend, but one never know...

	}

	return true;

}

bool MySQLBackend::removeUser(long id) {

	*m_removeUser << (int) id;

		return false;

	*m_removeUserSettings << (int) id;

		return false;

	*m_removeUserBuddies << (int) id;

		return false;

	*m_removeUserBuddiesSettings << (int) id;

		return false;

	return true;

}

void MySQLBackend::getUserSetting(long id, const std::string &variable, int &type, std::string &value) {

// 	"SELECT type, value FROM " + m_prefix + "users_settings WHERE user_id=? AND var=?"

	*m_getUserSetting << id << variable;

	if (m_getUserSetting->fetch() != 0) {

// 		"INSERT INTO " + m_prefix + "users_settings (user_id, var, type, value) VALUES (?,?,?,?)"

		*m_setUserSetting << id << variable << type << value;

	}

	else {

		*m_getUserSetting >> type >> value;

	}

}

void MySQLBackend::updateUserSetting(long id, const std::string &variable, const std::string &value) {

// 	"UPDATE " + m_prefix + "users_settings SET value=? WHERE user_id=? AND var=?"

	*m_updateUserSetting << value << id << variable;

}

void MySQLBackend::beginTransaction() {

	exec("START TRANSACTION;");

}

void MySQLBackend::commitTransaction() {

	exec("COMMIT;");

}

}