/**

 * libtransport -- C++ library for easy XMPP Transports development

 *

 * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>

 *

 * 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; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

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

 */

#pragma once

#include <string>

#include <map>

#include "Swiften/Swiften.h"

#include "transport/storagebackend.h"

#include "transport/config.h"

#include <sqlite3.h>

namespace Transport {

/// Used to store transport data into SQLite3 database.

class SQLite3Backend : public StorageBackend

{

	public:

		/// Creates new SQLite3Backend instance.

		/// \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

		SQLite3Backend(Config *config);

		/// Destructor.

		~SQLite3Backend();

		/// 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.

		/// \param barejid barejid of user

		/// \param user UserInfo object where user data will be stored

		/// \return true if user has been found in database

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

		/// Changes users online state variable in database.

		/// \param id id of user - UserInfo.id

		/// \param online online state

		void setUserOnline(long id, bool online);

		/// Removes user and all connected data from database.

		/// \param id id of user - UserInfo.id

		/// \return true if user has been found in database and removed

		bool removeUser(long id);

		/// Returns JIDs of all buddies in user's roster.

		/// \param id id of user - UserInfo.id

		/// \param roster string list used to store user's roster

		/// \return true if user has been found in database and roster has been fetched

		bool getBuddies(long id, std::list<std::string> &roster);

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

		void removeBuddy(long id) {}

		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_removeUser;

		sqlite3_stmt *m_removeUserBuddies;

		sqlite3_stmt *m_removeUserSettings;

		sqlite3_stmt *m_removeUserBuddiesSettings;

};

}

/**

 * XMPP - libpurple transport

 *

 * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>

 *

 * 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; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

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

 */

#include "transport/rostermanager.h"

#include "transport/rosterstorage.h"

#include "transport/storagebackend.h"

#include "transport/buddy.h"

#include "transport/usermanager.h"

#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(3000);

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

}

RosterManager::~RosterManager() {

	m_setBuddyTimer->stop();

	m_RIETimer->stop();

	if (m_rosterStorage)

		delete m_rosterStorage;

}

void RosterManager::setBuddy(Buddy *buddy) {

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

	m_setBuddyTimer->start();

}

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_component->getIQRouter(), m_user->getJID().toBare());

	request->onResponse.connect(boost::bind(&RosterManager::handleBuddyRosterPushResponse, this, _1, buddy->getName()));

	request->send();

}

void RosterManager::setBuddyCallback(Buddy *buddy) {

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

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

	onBuddySet(buddy);

	// In server mode the only way is to send jabber:iq:roster push.

	// In component mode we send RIE or Subscribe presences, based on features.

	if (m_component->inServerMode()) {

		sendBuddyRosterPush(buddy);

	}

	else {

	}

	if (m_setBuddyTimer->onTick.empty()) {

		m_setBuddyTimer->stop();

		if (true /*&& rie_is_supported*/) {

			m_RIETimer->start();

		}

	}

}

void RosterManager::unsetBuddy(Buddy *buddy) {

	m_buddies.erase(buddy->getName());

	if (m_rosterStorage)

		m_rosterStorage->removeBuddyFromQueue(buddy);

	onBuddyUnset(buddy);

}

void RosterManager::handleBuddyRosterPushResponse(Swift::ErrorPayload::ref error, const std::string &key) {

	if (m_buddies[key] != NULL) {

		m_buddies[key]->buddyChanged();

	}

}

Buddy *RosterManager::getBuddy(const std::string &name) {

	return m_buddies[name];

}

void RosterManager::sendRIE() {

	m_RIETimer->stop();

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

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

		Buddy *buddy = (*it).second;

		Swift::RosterItemExchangePayload::Item item;

		item.jid = buddy->getJID().toBare();

		item.name = buddy->getAlias();

		item.action = Swift::RosterItemExchangePayload::Add;

		item.groups = buddy->getGroups();

		payload->addItem(item);

	}

	boost::shared_ptr<Swift::GenericRequest<Swift::RosterItemExchangePayload> > request(new Swift::GenericRequest<Swift::RosterItemExchangePayload>(Swift::IQ::Set, m_user->getJID(), payload, m_component->getIQRouter()));

	request->send();

}

void RosterManager::handleSubscription(Swift::Presence::ref presence) {

	std::string legacyName = Buddy::JIDToLegacyName(presence->getTo());

}

void RosterManager::setStorageBackend(StorageBackend *storageBackend) {

	if (m_rosterStorage) {

		m_rosterStorage->storeBuddies();

		delete m_rosterStorage;

	}

	m_rosterStorage = new RosterStorage(m_user, storageBackend);

}

}

/**

 * libtransport -- C++ library for easy XMPP Transports development

 *

 * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>

 *

 * 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; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

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

 */

#include "transport/sqlite3backend.h"

#include <boost/bind.hpp>

#define SQLITE_DB_VERSION 3

#define CHECK_DB_RESPONSE(stmt) \

	if(stmt) { \

		sqlite3_exec(m_db, "ROLLBACK;", NULL, NULL, NULL); \

		return 0; \

	}

// Prepare the SQL statement

#define PREP_STMT(sql, str) \

	if(sqlite3_prepare_v2(m_db, std::string(str).c_str(), -1, &sql, NULL)) { \

		onStorageError(str, (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db))); \

		return false; \

	}

// Finalize the prepared statement

#define FINALIZE_STMT(prep) \

	if(prep != NULL) { \

		sqlite3_finalize(prep); \

	}

using namespace boost;

namespace Transport {

SQLite3Backend::SQLite3Backend(Config *config) {

	m_config = config;

	m_db = NULL;

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

}

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);

		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=?");

	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,"

					"  var varchar(50) NOT NULL,"

					"  type int(4) NOT NULL,"

					"  value varchar(255) NOT NULL,"

					"  PRIMARY KEY (buddy_id, var)"

					");");

		exec("CREATE INDEX IF NOT EXISTS user_id02 ON " + m_prefix + "buddies_settings (user_id);");

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

					"  id INTEGER PRIMARY KEY NOT NULL,"

					"  jid varchar(255) NOT NULL,"

					"  uin varchar(4095) NOT NULL,"

					"  password varchar(255) NOT NULL,"

					"  language varchar(25) NOT NULL,"

					"  encoding varchar(50) NOT NULL DEFAULT 'utf8',"

					"  last_login datetime,"

					"  vip int(1) NOT NULL DEFAULT '0',"

					"  online int(1) NOT NULL DEFAULT '0'"

					");");

		exec("CREATE UNIQUE INDEX IF NOT EXISTS jid ON " + m_prefix + "users (jid);");

		exec("CREATE TABLE " + m_prefix + "users_settings ("

					"  user_id int(10) NOT NULL,"

					"  var varchar(50) NOT NULL,"

					"  type int(4) NOT NULL,"

					"  value varchar(255) NOT NULL,"

					"  PRIMARY KEY (user_id, var)"

					");");

		exec("CREATE INDEX IF NOT EXISTS user_id03 ON " + m_prefix + "users_settings (user_id);");

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

			"  ver INTEGER NOT NULL DEFAULT '3'"

			");");

		exec("REPLACE INTO " + m_prefix + "db_version (ver) values(3)");

	}

	return true;

}

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

	char *errMsg = 0;

	int rc = sqlite3_exec(m_db, query.c_str(), NULL, 0, &errMsg);

	if (rc != SQLITE_OK) {

		onStorageError(query, errMsg);

		sqlite3_free(errMsg);

		return false;

	}

	return true;

}

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

	sqlite3_reset(m_setUser);

	sqlite3_bind_text(m_setUser, 1, user.jid.c_str(), -1, SQLITE_STATIC);

	sqlite3_bind_text(m_setUser, 2, user.uin.c_str(), -1, SQLITE_STATIC);

	sqlite3_bind_text(m_setUser, 3, user.password.c_str(), -1, SQLITE_STATIC);

	sqlite3_bind_text(m_setUser, 4, user.language.c_str(), -1, SQLITE_STATIC);

	sqlite3_bind_text(m_setUser, 5, user.encoding.c_str(), -1, SQLITE_STATIC);

	sqlite3_bind_int (m_setUser, 6, user.vip);

	if(sqlite3_step(m_setUser) != SQLITE_DONE) {

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

	}

}

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

// 	SELECT id, jid, uin, password, encoding, language, vip FROM " + m_prefix + "users WHERE jid=?

	sqlite3_reset(m_getUser);

	sqlite3_bind_text(m_getUser, 1, barejid.c_str(), -1, SQLITE_TRANSIENT);

	int ret;

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

		user.id = sqlite3_column_int(m_getUser, 0);

		user.jid = (const char *) sqlite3_column_text(m_getUser, 1);

		user.uin = (const char *) sqlite3_column_text(m_getUser, 2);

		user.password = (const char *) sqlite3_column_text(m_getUser, 3);

		user.encoding = (const char *) sqlite3_column_text(m_getUser, 4);

		user.language = (const char *) sqlite3_column_text(m_getUser, 5);

		user.vip = sqlite3_column_int(m_getUser, 6);

		return true;

	}

	if (ret != SQLITE_DONE) {

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

	}

	return false;

}

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

}

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

	return true;

}

bool SQLite3Backend::removeUser(long id) {

	sqlite3_reset(m_removeUser);

	sqlite3_bind_int(m_removeUser, 1, id);

	if(sqlite3_step(m_removeUser) != SQLITE_DONE) {

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

		return false;

	}

	sqlite3_reset(m_removeUserSettings);

	sqlite3_bind_int(m_removeUserSettings, 1, id);

	if(sqlite3_step(m_removeUserSettings) != SQLITE_DONE) {

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

		return false;

	}

	sqlite3_reset(m_removeUserBuddies);

	sqlite3_bind_int(m_removeUserBuddies, 1, id);

	if(sqlite3_step(m_removeUserBuddies) != SQLITE_DONE) {

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

		return false;

	}

	sqlite3_reset(m_removeUserBuddiesSettings);

	sqlite3_bind_int(m_removeUserBuddiesSettings, 1, id);

	if(sqlite3_step(m_removeUserBuddiesSettings) != SQLITE_DONE) {

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

		return false;

	}

	return true;

}

}