* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA

 */

#pragma once

#include <string>

#include <algorithm>

#include "transport/transport.h"

#include "Swiften/Swiften.h"

namespace Transport {

class RosterManager;

typedef enum { 	BUDDY_NO_FLAG = 0,

				BUDDY_JID_ESCAPING = 2,

				BUDDY_IGNORE = 4,

				BUDDY_BLOCKED = 8,

			} BuddyFlag;

/// Represents one legacy network Buddy.

class Buddy {

	public:

		/// Constructor.

		/// \param rosterManager RosterManager associated with this buddy.

		/// \param id ID which identifies the buddy in database or -1 if it's new buddy which is

		/// not in database yet.

		Buddy(RosterManager *rosterManager, long id = -1);

		/// Destructor

		virtual ~Buddy();

		/// Sets unique ID used to identify this buddy by StorageBackend.

		/// This is set

		/// by RosterStorage class once the buddy is stored into database or when the

		/// buddy is loaded from database.

		/// You should not need to set this ID manually.

		/// \param id ID

		void setID(long id);

		/// Returns unique ID used to identify this buddy by StorageBackend.

		/// \return ID which identifies the buddy in database or -1 if it's new buddy which is

		/// not in database yet.

		long getID();

		/// Generates whole Presennce stanza with current status/show for this buddy.

		/// Presence stanza does not containt "to" attribute, it has to be added manually.

		/// \param features features used in returned stanza

		/// \param only_new if True, this function returns Presence stanza only if it's different

		/// than the previously generated one.

		/// \return Presence stanza or NULL.

		Swift::Presence::ref generatePresenceStanza(int features, bool only_new = false);

		void setBlocked(bool block) {

			if (block)

				m_flags = (BuddyFlag) (m_flags | BUDDY_BLOCKED);

			else

				m_flags = (BuddyFlag) (m_flags & ~BUDDY_BLOCKED);

		}

		bool isBlocked() {

			return (m_flags & BUDDY_BLOCKED)  != 0;

		}

		/// Sets current subscription.

		/// \param subscription "to", "from", "both", "ask"

		/// Returns current subscription

		/// \return subscription "to", "from", "both", "ask"

		/// Sets this buddy's flags.

		/// \param flags flags

		void setFlags(BuddyFlag flags);

		/// Returns this buddy's flags.

		/// \param flags flags

		BuddyFlag getFlags();

		/// Returns RosterManager associated with this buddy.

		/// \return RosterManager associated with this buddy.

		RosterManager *getRosterManager() { return m_rosterManager; }

		/// Returns legacy network username which does not contain unsafe characters,

		/// so it can be used in JIDs.

		std::string getSafeName();

		/// This method should be called whenever some information returned by virtual functions changes.

		/// This method sends presence to XMPP user.

		void handleBuddyChanged();

		/// \param statusMessage current status message is stored here

		/// \return true if status was stored successfully

		virtual bool getStatus(Swift::StatusShow &status, std::string &statusMessage) = 0;

		/// Returns SHA-1 hash of buddy icon (avatar) or empty string if there is no avatar for this buddy.

		/// \return avatar hash or empty string.

		virtual std::string getIconHash() = 0;

		/// Returns legacy name of buddy from JID.

		/// \param jid Jabber ID.

		/// \return legacy name of buddy from JID.

		static std::string JIDToLegacyName(const Swift::JID &jid);

		static BuddyFlag buddFlagsFromJID(const Swift::JID &jid);

	private:

		void generateJID();

		long m_id;

// 		Swift::Presence::ref m_lastPresence;

		Swift::JID m_jid;

		BuddyFlag m_flags;

		RosterManager *m_rosterManager;

};

}

 *

 * 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/buddy.h"

#include "transport/rostermanager.h"

#include "transport/user.h"

#include "transport/transport.h"

#include "transport/BlockPayload.h"

namespace Transport {

// 	m_rosterManager->setBuddy(this);

}

Buddy::~Buddy() {

// 	m_rosterManager->unsetBuddy(this);

}

void Buddy::generateJID() {

	m_jid = Swift::JID();

	m_jid = Swift::JID(getSafeName(), m_rosterManager->getUser()->getComponent()->getJID().toString(), "bot");

}

void Buddy::setID(long id) {

	m_id = id;

}

long Buddy::getID() {

	return m_id;

}

void Buddy::setFlags(BuddyFlag flags) {

	m_flags = flags;

// 	generateJID();

}

BuddyFlag Buddy::getFlags() {

	return m_flags;

}

const Swift::JID &Buddy::getJID() {

	if (!m_jid.isValid() || m_jid.getNode().empty()) {

		generateJID();

	}

	return m_jid;

}

}

}

Swift::Presence::ref Buddy::generatePresenceStanza(int features, bool only_new) {

	std::string alias = getAlias();

	std::string name = getSafeName();

	Swift::StatusShow s;

	std::string statusMessage;

	if (!getStatus(s, statusMessage))

		return Swift::Presence::ref();

	if (m_jid.getNode().empty()) {

		generateJID();

	}

	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)

			onMessageToSend(this, message);

		}

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

};

class NetworkFactory : public Factory {

	public:

		NetworkFactory(NetworkPluginServer *nps) {

			m_nps = nps;

		}

		// Creates new conversation (NetworkConversation in this case)

		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;

		}

		// Creates new LocalBuddy

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

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

			buddy->setAlias(buddyInfo.alias);

			buddy->setName(buddyInfo.legacyName);

			buddy->setGroups(buddyInfo.groups);

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

			if (buddyInfo.settings.find("icon_hash") != buddyInfo.settings.end())

				buddy->setIconHash(buddyInfo.settings.find("icon_hash")->second.s);

			return buddy;

		}

	private:

		NetworkPluginServer *m_nps;

};

// Wraps google protobuf payload into WrapperMessage and serialize it to string

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

	wrap.set_type(TYPE); \

	wrap.set_payload(MESSAGE); \

	wrap.SerializeToString(&MESSAGE);

// Executes new backend

static unsigned long exec_(std::string path, const char *host, const char *port, const char *config) {

	std::string original_path = path;

	// BACKEND_ID is replaced with unique ID. The ID is increasing for every backend.

	boost::replace_all(path, "BACKEND_ID", boost::lexical_cast<std::string>(backend_id++));

	// Add host and port.

}

RosterStorage::~RosterStorage() {

	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.id = buddy->getID();

		buddyInfo.flags = buddy->getFlags();

		buddyInfo.settings["icon_hash"].s = buddy->getIconHash();

		buddyInfo.settings["icon_hash"].type = TYPE_STRING;

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

// 		}

	}

		}

		// Called when there's new message to legacy network from XMPP network

		void sendMessage(boost::shared_ptr<Swift::Message> &message) {

		}

};

class TestingFactory : public Factory {

	public:

		TestingFactory() {

		}

		// Creates new conversation (NetworkConversation in this case)

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

			Conversation *nc = new TestingConversation(conversationManager, legacyName);

			return nc;

		}

		// Creates new LocalBuddy

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

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

			buddy->setAlias(buddyInfo.alias);

			buddy->setName(buddyInfo.legacyName);

			buddy->setGroups(buddyInfo.groups);

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

			if (buddyInfo.settings.find("icon_hash") != buddyInfo.settings.end())

				buddy->setIconHash(buddyInfo.settings.find("icon_hash")->second.s);

			return buddy;

		}

};

class BasicTest : public Swift::XMPPParserClient {

	public:

		void setMeUp (void);

		void tearMeDown (void);

	void handleDataReceived(const Swift::SafeByteArray &data);

	void handleStreamStart(const Swift::ProtocolHeader&);

	void handleElement(boost::shared_ptr<Swift::Element> element);

	void handleStreamEnd();

	void injectPresence(boost::shared_ptr<Swift::Presence> &response);