* 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 <algorithm>

#include <map>

#include <boost/pool/pool_alloc.hpp>

#include <boost/pool/object_pool.hpp>

#include "Swiften/Swiften.h"

// #include "rosterstorage.h"

namespace Transport {

class Buddy;

class User;

class Component;

class StorageBackend;

class RosterStorage;

/// Manages roster of one XMPP user.

class RosterManager {

	public:

		/// Creates new RosterManager.

		/// \param user User associated with this RosterManager.

		/// \param component Transport instance associated with this roster.

		RosterManager(User *user, Component *component);

		/// Destructor.

		virtual ~RosterManager();

		/// Associates the buddy with this roster,

		/// and if the buddy is not already in XMPP user's server-side roster, the proper requests

		/// are sent to XMPP user (subscribe presences, Roster Item Exchange stanza or

		/// the buddy is added to server-side roster using remote-roster protoXEP).

		/// \param buddy Buddy

		void setBuddy(Buddy *buddy);

		/// Deassociates the buddy with this roster.

		/// \param buddy Buddy.

		void unsetBuddy(Buddy *buddy);

		Buddy *getBuddy(const std::string &name);

		void setStorageBackend(StorageBackend *storageBackend);

		void storeBuddy(Buddy *buddy);

		Swift::RosterPayload::ref generateRosterPayload();

		/// Returns user associated with this roster.

		/// \return User

		User *getUser() { return m_user; }

		/// Called when new Buddy is added to this roster.

		/// \param buddy newly added Buddy

		boost::signal<void (Buddy *buddy)> onBuddySet;

		/// Called when Buddy has been removed from this roster.

		/// \param buddy removed Buddy

		boost::signal<void (Buddy *buddy)> onBuddyUnset;

		boost::signal<void (Buddy *buddy)> onBuddyAdded;

		boost::signal<void (Buddy *buddy)> onBuddyRemoved;

		void handleBuddyChanged(Buddy *buddy);

		void handleSubscription(Swift::Presence::ref presence);

		void sendBuddyRosterPush(Buddy *buddy);

		void sendBuddySubscribePresence(Buddy *buddy);

		void sendCurrentPresences(const Swift::JID &to);

		void sendCurrentPresence(const Swift::JID &from, const Swift::JID &to);

		void sendUnavailablePresences(const Swift::JID &to);

	private:

		void setBuddyCallback(Buddy *buddy);

		void sendRIE();

		std::map<std::string, Buddy *, std::less<std::string>, boost::pool_allocator< std::pair<std::string, Buddy *> > > m_buddies;

		Component *m_component;

		RosterStorage *m_rosterStorage;

		User *m_user;

		Swift::Timer::ref m_setBuddyTimer;

		Swift::Timer::ref m_RIETimer;

};

}

/**

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

#include "log4cxx/logger.h"

using namespace log4cxx;

namespace Transport {

static LoggerPtr logger = Logger::getLogger("RosterManager");

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

	m_rosterStorage = NULL;

	m_user = user;

	m_component = component;

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

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

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

}

RosterManager::~RosterManager() {

	m_setBuddyTimer->stop();

	m_RIETimer->stop();

	if (m_rosterStorage) {

		m_rosterStorage->storeBuddies();

	}

	sendUnavailablePresences(m_user->getJID().toBare());

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

		Buddy *buddy = (*it).second;

		if (!buddy) {

			continue;

		}

		delete buddy;

	}

	boost::singleton_pool<boost::pool_allocator_tag, sizeof(unsigned int)>::release_memory();

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

	if (!m_user->isConnected())

		return;

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

	item.setSubscription(Swift::RosterItemPayload::Both);

	payload->addItem(item);

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

	request->send();

}

void RosterManager::sendBuddySubscribePresence(Buddy *buddy) {

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

	response->setTo(m_user->getJID());

	response->setFrom(buddy->getJID());

	response->setType(Swift::Presence::Subscribe);

// 	TODO: NICKNAME

	m_component->getStanzaChannel()->sendPresence(response);

}

void RosterManager::handleBuddyChanged(Buddy *buddy) {

	if (m_rosterStorage) {

		m_rosterStorage->storeBuddy(buddy);

	}

}

void RosterManager::setBuddyCallback(Buddy *buddy) {

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

	LOG4CXX_INFO(logger, "Associating buddy " << buddy->getName() << " with " << m_user->getJID().toString());

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

			// Send RIE only if there's resource which supports it.

			Swift::JID jidWithRIE = m_user->getJIDWithFeature("http://jabber.org/protocol/rosterx");

			if (jidWithRIE.isValid()) {

				m_RIETimer->start();

			}

			else {

				sendBuddySubscribePresence(buddy);

			}

		}

	}

	if (m_rosterStorage)

		m_rosterStorage->storeBuddy(buddy);

}

void RosterManager::unsetBuddy(Buddy *buddy) {

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

	if (m_rosterStorage)

		m_rosterStorage->removeBuddyFromQueue(buddy);

	onBuddyUnset(buddy);

}

void RosterManager::storeBuddy(Buddy *buddy) {

	if (m_rosterStorage) {

		m_rosterStorage->storeBuddy(buddy);

	}

}

	if (m_buddies[key] != NULL) {

		m_buddies[key]->handleBuddyChanged();

	}

}

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

	return m_buddies[name];

}

void RosterManager::sendRIE() {

	m_RIETimer->stop();

	// Check the feature, because proper resource could logout during RIETimer.

	Swift::JID jidWithRIE = m_user->getJIDWithFeature("http://jabber.org/protocol/rosterx");

	// fallback to normal subscribe

	if (!jidWithRIE.isValid()) {

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

			Buddy *buddy = (*it).second;

			if (!buddy) {

				continue;

			}

			sendBuddySubscribePresence(buddy);

		}

		return;

	}

	LOG4CXX_INFO(logger, "Sending RIE stanza to " << jidWithRIE.toString());

	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;

		if (!buddy) {

			continue;

		}

		Swift::RosterItemExchangePayload::Item item;

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

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

		item.setAction(Swift::RosterItemExchangePayload::Item::Add);

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

		payload->addItem(item);

	}

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

	request->send();

}

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

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

	// For server mode the subscription changes are handler in rosterresponder.cpp

	// using roster pushes.

	if (m_component->inServerMode()) {

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

		response->setTo(presence->getFrom());

		response->setFrom(presence->getTo());

		Buddy *buddy = getBuddy(Buddy::JIDToLegacyName(presence->getTo()));

		if (buddy) {

			LOG4CXX_INFO(logger, m_user->getJID().toString() << ": Subscription received and buddy " << Buddy::JIDToLegacyName(presence->getTo()) << " is already there => answering");

			switch (presence->getType()) {

				case Swift::Presence::Subscribe:

					onBuddyAdded(buddy);

					response->setType(Swift::Presence::Subscribed);

					break;

				case Swift::Presence::Unsubscribe:

					onBuddyRemoved(buddy);

					response->setType(Swift::Presence::Unsubscribed);

					break;

				case Swift::Presence::Subscribed:

					onBuddyAdded(buddy);

					break;

				default:

					return;

			}

			m_component->getStanzaChannel()->sendPresence(response);

		}

		else {

			BuddyInfo buddyInfo;

			switch (presence->getType()) {

				// buddy is not in roster, so add him

				case Swift::Presence::Subscribe:

					buddyInfo.id = -1;

					buddyInfo.alias = "";

					buddyInfo.legacyName = Buddy::JIDToLegacyName(presence->getTo());

					buddyInfo.subscription = "both";

					buddyInfo.flags = 0;

					LOG4CXX_INFO(logger, m_user->getJID().toString() << ": Subscription received for new buddy " << buddyInfo.legacyName << " => adding to legacy network");

					buddy = m_component->getFactory()->createBuddy(this, buddyInfo);

					setBuddy(buddy);

					onBuddyAdded(buddy);

					response->setType(Swift::Presence::Subscribed);

					break;

				case Swift::Presence::Subscribed:

					onBuddyAdded(buddy);

					break;

				// buddy is already there, so nothing to do, just answer

				case Swift::Presence::Unsubscribe: