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

#include "Swiften/Roster/SetRosterRequest.h"

#include "Swiften/Elements/RosterPayload.h"

#include "Swiften/Elements/RosterItemPayload.h"

#include "Swiften/Elements/RosterItemExchangePayload.h"

#include "Swiften/Elements/Nickname.h"

#include "Swiften/Queries/IQRouter.h"

#include <boost/foreach.hpp>

#include <boost/make_shared.hpp>

#include <map>

#include <iterator>

namespace Transport {

DEFINE_LOGGER(logger, "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));

	m_supportRemoteRoster = false;

	if (!m_component->inServerMode()) {

		m_remoteRosterRequest = AddressedRosterRequest::ref(new AddressedRosterRequest(m_component->getIQRouter(), m_user->getJID().toBare()));

		m_remoteRosterRequest->onResponse.connect(boost::bind(&RosterManager::handleRemoteRosterResponse, this, _1, _2));

		m_remoteRosterRequest->send();

	}

}

RosterManager::~RosterManager() {

	m_setBuddyTimer->stop();

	m_RIETimer->stop();

	if (m_rosterStorage) {

		m_rosterStorage->storeBuddies();

	}

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

	if (m_remoteRosterRequest) {

		m_remoteRosterRequest->onResponse.disconnect_all_slots();

		m_component->getIQRouter()->removeHandler(m_remoteRosterRequest);

	}

	for (std::map<std::string, Buddy *, std::less<std::string>, boost::pool_allocator< std::pair<std::string, Buddy *> > >::iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {

		Buddy *buddy = (*it).second;

		if (!buddy) {

			continue;

		}

		delete buddy;

	}

	if (m_requests.size() != 0) {

		LOG4CXX_INFO(logger, m_user->getJID().toString() <<  ": Removing " << m_requests.size() << " unresponded IQs");

		BOOST_FOREACH(Swift::SetRosterRequest::ref request, m_requests) {

			request->onResponse.disconnect_all_slots();

			m_component->getIQRouter()->removeHandler(request);

		}

		m_requests.clear();

	}

	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::removeBuddy(const std::string &name) {

	Buddy *buddy = getBuddy(name);

	if (!buddy) {

		LOG4CXX_WARN(logger, m_user->getJID().toString() << ": Tried to remove unknown buddy " << name);

		return;

	}

		sendBuddyRosterRemove(buddy);

	}

	else {

		sendBuddyUnsubscribePresence(buddy);

	}

	if (m_rosterStorage)

		m_rosterStorage->removeBuddy(buddy);

	unsetBuddy(buddy);

	delete buddy;

}

void RosterManager::sendBuddyRosterRemove(Buddy *buddy) {

	Swift::RosterPayload::ref p = Swift::RosterPayload::ref(new Swift::RosterPayload());

	Swift::RosterItemPayload item;

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

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

	p->addItem(item);

	// In server mode we have to send pushes to all resources, but in gateway-mode we send it only to bare JID

	if (m_component->inServerMode()) {

		std::vector<Swift::Presence::ref> presences = m_component->getPresenceOracle()->getAllPresence(m_user->getJID().toBare());

		BOOST_FOREACH(Swift::Presence::ref presence, presences) {

			Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(p, presence->getFrom(), m_component->getIQRouter());

			request->send();

		}

	}

	else {

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

		request->send();

	}

}

void RosterManager::sendBuddyRosterPush(Buddy *buddy) {

	// user can't receive anything in server mode if he's not logged in.

	// He will ask for roster later (handled in rosterreponsder.cpp)

	if (m_component->inServerMode() && (!m_user->isConnected() || m_user->shouldCacheMessages()))

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

	// In server mode we have to send pushes to all resources, but in gateway-mode we send it only to bare JID

	if (m_component->inServerMode()) {

		std::vector<Swift::Presence::ref> presences = m_component->getPresenceOracle()->getAllPresence(m_user->getJID().toBare());

		BOOST_FOREACH(Swift::Presence::ref presence, presences) {

			Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(payload, presence->getFrom(), m_component->getIQRouter());

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

			request->send();

			m_requests.push_back(request);

		}

	}

	else {

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

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

		request->send();

		m_requests.push_back(request);

	}

	if (buddy->getSubscription() != Buddy::Both) {

		buddy->setSubscription(Buddy::Both);

		storeBuddy(buddy);

	}

}

void RosterManager::sendBuddyUnsubscribePresence(Buddy *buddy) {

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

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

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

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

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

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

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

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

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

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

}

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

	if (!buddy->getAlias().empty()) {

		response->addPayload(boost::make_shared<Swift::Nickname>(buddy->getAlias()));

	}

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