} BuddyFlag;

/// Represents one legacy network Buddy.

class Buddy {

	public:

		/// Constructor.

		Buddy(RosterManager *rosterManager, long id);

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

		/// \see Buddy::setID(long)

		/// \return ID

		long getID();

		/// Returns full JID of this buddy.

		/// \param hostname hostname used as domain in returned JID

		/// \return full JID of this buddy

		const Swift::JID &getJID();

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

		/// Marks this buddy as available.

		void setOnline();

		/// Marks this buddy as offline.

		void setOffline();

		/// Returns true if this buddy is marked as available/online.

		/// \return true if this buddy is marked as available/online.

		bool isOnline();

		/// Sets current subscription.

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

		void setSubscription(const std::string &subscription);

		/// Returns current subscription

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

		const std::string &getSubscription();

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

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

		void buddyChanged();

		/// Returns legacy network username of this buddy. (for example UIN for ICQ,

		/// JID for Jabber, ...).

		/// \return legacy network username

		virtual std::string getName() = 0;

		/// Returns alias (nickname) of this buddy.

		/// \return alias (nickname)

		virtual std::string getAlias() = 0;

		/// Returns list of groups this buddy is in.

		/// \return groups

		virtual std::vector<std::string> getGroups() = 0;

		/// Returns current legacy network status and statuMessage of this buddy.

		/// \param status current status/show is stored here

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

	private:

		void generateJID();

		long m_id;

		bool m_online;

		std::string m_subscription;

		Swift::Presence::ref m_lastPresence;

		Swift::JID m_jid;

		BuddyFlag m_flags;

		RosterManager *m_rosterManager;

};

}

	if (!m_jid.isValid()) {

		generateJID();

	}

	return m_jid;

}

void Buddy::setOnline() {

	m_online = true;

}

void Buddy::setOffline() {

	m_online = false;

	m_lastPresence = Swift::Presence::ref();

}

bool Buddy::isOnline() {

	return m_online;

}

void Buddy::setSubscription(const std::string &subscription) {

	m_subscription = subscription;

}

const std::string &Buddy::getSubscription() {

	return m_subscription;

}

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

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

		if (features & 0/*TRANSPORT_FEATURE_AVATARS*/) {

			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 {

		if (name.find_last_of("@") != std::string::npos) {

			name.replace(name.find_last_of("@"), 1, "%");

		}

	}

// 	if (name.empty()) {

// 		Log("SpectrumBuddy::getSafeName", "Name is EMPTY! Previous was " << getName() << ".");

// 	}

	return name;

}

void Buddy::buddyChanged() {

	Swift::Presence::ref presence = generatePresenceStanza(255);

	if (presence) {

		m_rosterManager->getUser()->getComponent()->getStanzaChannel()->sendPresence(presence);

	}

}

}

#include "Swiften/Elements/RosterPayload.h"

#include "Swiften/Elements/RosterItemPayload.h"

#include "Swiften/Elements/RosterItemExchangePayload.h"

namespace Transport {

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

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

}

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

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

}