m_server->addPayloadSerializer(new Swift::AttentionSerializer());

		m_server->addPayloadSerializer(new Swift::XHTMLIMSerializer());

		m_server->addPayloadSerializer(new Transport::BlockSerializer());

		m_server->addPayloadSerializer(new Swift::InvisibleSerializer());

		m_server->addPayloadSerializer(new Swift::StatsSerializer());

		m_server->addPayloadSerializer(new Swift::SpectrumErrorSerializer());

		m_server->addPayloadSerializer(new Swift::GatewayPayloadSerializer());

		m_server->onDataRead.connect(boost::bind(&Component::handleDataRead, this, _1));

		m_server->onDataWritten.connect(boost::bind(&Component::handleDataWritten, this, _1));

	}

	else {

		LOG4CXX_INFO(logger, "Creating component in gateway mode");

		m_component = new Swift::Component(loop, m_factories, m_jid, CONFIG_STRING(m_config, "service.password"));

		m_component->setSoftwareVersion("", "");

		m_component->onConnected.connect(bind(&Component::handleConnected, this));

		m_component->onError.connect(boost::bind(&Component::handleConnectionError, this, _1));

		m_component->onDataRead.connect(boost::bind(&Component::handleDataRead, this, _1));

		m_component->onDataWritten.connect(boost::bind(&Component::handleDataWritten, this, _1));

		m_component->addPayloadParserFactory(new GenericPayloadParserFactory<StorageParser>("private", "jabber:iq:private"));

		m_component->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::AttentionParser>("attention", "urn:xmpp:attention:0"));

		m_component->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::XHTMLIMParser>("html", "http://jabber.org/protocol/xhtml-im"));

		m_component->addPayloadParserFactory(new GenericPayloadParserFactory<Transport::BlockParser>("block", "urn:xmpp:block:0"));

		m_component->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::InvisibleParser>("invisible", "urn:xmpp:invisible:0"));

		m_component->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::StatsParser>("query", "http://jabber.org/protocol/stats"));

		m_component->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::GatewayPayloadParser>("query", "jabber:iq:gateway"));

		m_component->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::MUCPayloadParser>("x", "http://jabber.org/protocol/muc"));

		m_component->addPayloadSerializer(new Swift::AttentionSerializer());

		m_component->addPayloadSerializer(new Swift::XHTMLIMSerializer());

		m_component->addPayloadSerializer(new Transport::BlockSerializer());

		m_component->addPayloadSerializer(new Swift::InvisibleSerializer());

		m_component->addPayloadSerializer(new Swift::StatsSerializer());

		m_component->addPayloadSerializer(new Swift::SpectrumErrorSerializer());

		m_component->addPayloadSerializer(new Swift::GatewayPayloadSerializer());

		m_stanzaChannel = m_component->getStanzaChannel();

		m_iqRouter = m_component->getIQRouter();

	}

	m_capsMemoryStorage = new CapsMemoryStorage();

	m_capsManager = new CapsManager(m_capsMemoryStorage, m_stanzaChannel, m_iqRouter);

	m_entityCapsManager = new EntityCapsManager(m_capsManager, m_stanzaChannel);

 	m_entityCapsManager->onCapsChanged.connect(boost::bind(&Component::handleCapsChanged, this, _1));

	m_presenceOracle = new Transport::PresenceOracle(m_stanzaChannel);

	m_presenceOracle->onPresenceChange.connect(bind(&Component::handlePresence, this, _1));

	m_discoInfoResponder = new DiscoInfoResponder(m_iqRouter, m_config);

	m_discoInfoResponder->start();

// 

// 	m_registerHandler = new SpectrumRegisterHandler(m_component);

// 	m_registerHandler->start();

}

Component::~Component() {

	delete m_presenceOracle;

	delete m_entityCapsManager;

	delete m_capsManager;

	delete m_capsMemoryStorage;

	delete m_discoInfoResponder;

	if (m_component)

		delete m_component;

	if (m_server) {

		m_server->stop();

		delete m_server;

	}

}

Swift::StanzaChannel *Component::getStanzaChannel() {

	return m_stanzaChannel;

}

Transport::PresenceOracle *Component::getPresenceOracle() {

	return m_presenceOracle;

}

void Component::setTransportFeatures(std::list<std::string> &features) {

	m_discoInfoResponder->setTransportFeatures(features);

}

Swift::CapsInfo &Component::getBuddyCapsInfo() {

		return m_discoInfoResponder->getBuddyCapsInfo();

}

void Component::setBuddyFeatures(std::list<std::string> &features) {

	// TODO: handle caps change

	m_discoInfoResponder->setBuddyFeatures(features);

}

void Component::start() {

	if (m_component && !m_component->isAvailable()) {

		LOG4CXX_INFO(logger, "Connecting XMPP server " << CONFIG_STRING(m_config, "service.server") << " port " << CONFIG_INT(m_config, "service.port"));

		m_reconnectCount++;

		m_component->connect(CONFIG_STRING(m_config, "service.server"), CONFIG_INT(m_config, "service.port"));

		m_reconnectTimer->stop();

	}

	else if (m_server) {

		LOG4CXX_INFO(logger, "Starting component in server mode on port " << CONFIG_INT(m_config, "service.port"));

		m_server->start();

		//Type casting to BoostConnectionServer since onStopped signal is not defined in ConnectionServer

		//Ideally, onStopped must be defined in ConnectionServer

		boost::dynamic_pointer_cast<Swift::BoostConnectionServer>(m_server->getConnectionServer())->onStopped.connect(boost::bind(&Component::handleServerStopped, this, _1));

		// We're connected right here, because we're in server mode...

		handleConnected();

	}

}

void Component::stop() {

	if (m_component) {

		m_reconnectCount = 0;

		// TODO: Call this once swiften will fix assert(!session_);

// 		m_component->disconnect();

		m_reconnectTimer->stop();

	}

	else if (m_server) {

		LOG4CXX_INFO(logger, "Stopping component in server mode on port " << CONFIG_INT(m_config, "service.port"));

		m_server->stop();

	}

}

void Component::handleConnected() {

	onConnected();

	m_reconnectCount = 0;

}

void Component::handleServerStopped(boost::optional<Swift::BoostConnectionServer::Error> e) {

	if(e != NULL ) {

		if(*e == Swift::BoostConnectionServer::Conflict)

			LOG4CXX_INFO(logger, "Port "<< CONFIG_INT(m_config, "service.port") << " already in use! Stopping server..");

		if(*e == Swift::BoostConnectionServer::UnknownError)

			LOG4CXX_INFO(logger, "Unknown error occured! Stopping server..");

		exit(1);

	}

}

void Component::handleConnectionError(const ComponentError &error) {

	onConnectionError(error);

// 	if (m_reconnectCount == 2)

// 		Component::instance()->userManager()->removeAllUsers();

	std::string str = "Unknown error";

	switch (error.getType()) {

		case ComponentError::UnknownError: str = "Unknown error"; break;

		case ComponentError::ConnectionError: str = "Connection error"; break;

		case ComponentError::ConnectionReadError: str = "Connection read error"; break;

		case ComponentError::ConnectionWriteError: str = "Connection write error"; break;

		case ComponentError::XMLError: str = "XML Error"; break;

		case ComponentError::AuthenticationFailedError: str = "Authentication failed error"; break;

		case ComponentError::UnexpectedElementError: str = "Unexpected element error"; break;

	}

	LOG4CXX_INFO(logger, "Disconnected from XMPP server. Error: " << str);

	m_reconnectTimer->start();

}

void Component::handleDataRead(const Swift::SafeByteArray &data) {

	std::string d = safeByteArrayToString(data);

	if (!boost::starts_with(d, "<auth")) {

		LOG4CXX_INFO(logger_xml, "XML IN " << d);

	}

}

void Component::handleDataWritten(const Swift::SafeByteArray &data) {

	LOG4CXX_INFO(logger_xml, "XML OUT " << safeByteArrayToString(data));

}

void Component::handlePresence(Swift::Presence::ref presence) {

	bool isMUC = presence->getPayload<MUCPayload>() != NULL || *presence->getTo().getNode().c_str() == '#';

	// filter out login/logout presence spam

	if (!presence->getTo().getNode().empty() && isMUC == false)

		return;

	// filter out bad presences

	if (!presence->getFrom().isValid()) {

		return;

	}

	// check if we have this client's capabilities and ask for them

	if (presence->getType() != Swift::Presence::Unavailable) {

		boost::shared_ptr<CapsInfo> capsInfo = presence->getPayload<CapsInfo>();

		if (capsInfo && capsInfo->getHash() == "sha-1") {

			/*haveFeatures = */m_entityCapsManager->getCaps(presence->getFrom()) != DiscoInfo::ref();

		}

#ifdef SUPPORT_LEGACY_CAPS

		else {

			GetDiscoInfoRequest::ref discoInfoRequest = GetDiscoInfoRequest::create(presence->getFrom(), m_iqRouter);