* libtransport -- C++ library for easy XMPP Transports development

 *

 * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>

 *

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

#include <boost/bind.hpp>

#include "transport/storagebackend.h"

#include "transport/factory.h"

#include "transport/userregistry.h"

#include "discoinforesponder.h"

#include "discoitemsresponder.h"

#include "storageparser.h"

#include "Swiften/TLS/OpenSSL/OpenSSLServerContext.h"

#include "Swiften/TLS/PKCS12Certificate.h"

#include "Swiften/TLS/OpenSSL/OpenSSLServerContextFactory.h"

#include "Swiften/Parser/PayloadParsers/AttentionParser.h"

#include "Swiften/Serializer/PayloadSerializers/AttentionSerializer.h"

#include "Swiften/Parser/PayloadParsers/XHTMLIMParser.h"

#include "Swiften/Serializer/PayloadSerializers/XHTMLIMSerializer.h"

#include "Swiften/Parser/PayloadParsers/BlockParser.h"

#include "Swiften/Serializer/PayloadSerializers/BlockSerializer.h"

#include "Swiften/Parser/PayloadParsers/InvisibleParser.h"

#include "Swiften/Serializer/PayloadSerializers/InvisibleSerializer.h"

#include "log4cxx/logger.h"

#include "log4cxx/consoleappender.h"

#include "log4cxx/patternlayout.h"

#include "log4cxx/propertyconfigurator.h"

using namespace Swift;

using namespace boost;

using namespace log4cxx;

namespace Transport {

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

static LoggerPtr logger_xml = Logger::getLogger("Component.XML");

Component::Component(Swift::EventLoop *loop, Config *config, Factory *factory, Transport::UserRegistry *userRegistry) {

	m_component = NULL;

	m_userRegistry = NULL;

	m_server = NULL;

	m_reconnectCount = 0;

	m_config = config;

	m_factory = factory;

	m_loop = loop;

	m_userRegistry = userRegistry;

	if (CONFIG_STRING(m_config, "logging.config").empty()) {

		LoggerPtr root = Logger::getRootLogger();

		root->addAppender(new ConsoleAppender(new PatternLayout("%d %-5p %c: %m%n")));

	}

	else {

		log4cxx::PropertyConfigurator::configure(CONFIG_STRING(m_config, "logging.config"));

	}

	m_jid = Swift::JID(CONFIG_STRING(m_config, "service.jid"));

	m_factories = new BoostNetworkFactories(loop);

	m_reconnectTimer = m_factories->getTimerFactory()->createTimer(3000);

	m_reconnectTimer->onTick.connect(bind(&Component::start, this)); 

	if (CONFIG_BOOL(m_config, "service.server_mode")) {

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

		m_server = new Swift::Server(loop, m_factories, m_userRegistry, m_jid, CONFIG_INT(m_config, "service.port"));

		if (!CONFIG_STRING(m_config, "service.cert").empty()) {

			LOG4CXX_INFO(logger, "Using PKCS#12 certificate " << CONFIG_STRING(m_config, "service.cert"));

			TLSServerContextFactory *f = new OpenSSLServerContextFactory();

			m_server->addTLSEncryption(f, PKCS12Certificate(CONFIG_STRING(m_config, "service.cert"), createSafeByteArray(CONFIG_STRING(m_config, "service.cert_password"))));

		}

		else {

			LOG4CXX_WARN(logger, "No PKCS#12 certificate used. TLS is disabled.");

		}

// 		m_server->start();

		m_stanzaChannel = m_server->getStanzaChannel();

		m_iqRouter = m_server->getIQRouter();

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

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

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

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

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

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

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

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

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

		m_server->onDataWritten.connect(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(bind(&Component::handleConnectionError, this, _1));

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

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

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

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

	m_discoInfoResponder = new DiscoInfoResponder(m_iqRouter, m_config);

	m_discoInfoResponder->start();

	m_discoItemsResponder = new DiscoItemsResponder(m_iqRouter);

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

	delete m_discoItemsResponder;

	if (m_component)

		delete m_component;

	if (m_server) {

		m_server->stop();

		delete m_server;

	}

	delete m_factories;

}

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

	return m_stanzaChannel;

}

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

	return m_presenceOracle;

}

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

	m_discoInfoResponder->setTransportFeatures(features);

}

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

	}

}

void Component::stop() {

	if (m_component) {

		m_reconnectCount = 0;

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

	}

	m_conversationManager = new ConversationManager(this, m_component);

	LOG4CXX_INFO(logger, m_jid.toString() << ": Created");

	updateLastActivity();

}

User::~User(){

	LOG4CXX_INFO(logger, m_jid.toString() << ": Destroying");

	if (m_component->inServerMode()) {

		dynamic_cast<Swift::ServerStanzaChannel *>(m_component->getStanzaChannel())->finishSession(m_jid, boost::shared_ptr<Swift::Element>());

	}

	m_reconnectTimer->stop();

	delete m_rosterManager;

	delete m_conversationManager;

}

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

	return m_jid;

}

Swift::JID User::getJIDWithFeature(const std::string &feature) {

	Swift::JID jid;

	std::vector<Swift::Presence::ref> presences = m_presenceOracle->getAllPresence(m_jid);

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

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

			continue;

		Swift::DiscoInfo::ref discoInfo = m_entityCapsManager->getCaps(presence->getFrom());

		if (!discoInfo)

			continue;

		if (discoInfo->hasFeature(feature)) {

			LOG4CXX_INFO(logger, m_jid.toString() << ": Found JID with " << feature << " feature: " << presence->getFrom().toString());

			return presence->getFrom();

		}

	}

	LOG4CXX_INFO(logger, m_jid.toString() << ": No JID with " << feature << " feature");

	return jid;

}

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

	std::cout << "PRESENCE " << presence->getFrom().toString() << "\n";

	if (!m_connected) {

		// we are not connected to legacy network, so we should do it when disco#info arrive :)

		if (m_readyForConnect == false) {

			// Forward status message to legacy network, but only if it's sent from active resource

// 					if (m_activeResource == presence->getFrom().getResource().getUTF8String()) {

// 						forwardStatus(presenceShow, stanzaStatus);

// 					}

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

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

				if (m_entityCapsManager->getCaps(presence->getFrom()) != Swift::DiscoInfo::ref()) {

					LOG4CXX_INFO(logger, m_jid.toString() << ": Ready to be connected to legacy network");

					m_readyForConnect = true;

					onReadyToConnect();

				}

			}

			else if (m_component->inServerMode()) {

				LOG4CXX_INFO(logger, m_jid.toString() << ": Ready to be connected to legacy network");

				m_readyForConnect = true;

				onReadyToConnect();

			}

			else {

				m_reconnectTimer->start();

			}

		}

	}

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

	if (isMUC) {

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

			LOG4CXX_INFO(logger, m_jid.toString() << ": Going to left room " << presence->getTo().getNode());

			onRoomLeft(presence->getTo().getNode());

		}

		else {

			// force connection to legacy network to let backend to handle auto-join on connect.

			if (!m_readyForConnect) {

				LOG4CXX_INFO(logger, m_jid.toString() << ": Ready to be connected to legacy network");

				m_readyForConnect = true;

				onReadyToConnect();

			}

			LOG4CXX_INFO(logger, m_jid.toString() << ": Going to join room " << presence->getTo().getNode() << " as " << presence->getTo().getResource());

			onRoomJoined(presence->getTo().getNode(), presence->getTo().getResource(), "");

		}

		return;

	}

	Swift::Presence::ref highest = m_presenceOracle->getHighestPriorityPresence(m_jid.toBare());

	if (highest) {

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

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

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

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

		LOG4CXX_INFO(logger, m_jid.toString() << ": Changing legacy network presence to " << response->getType());

	}

	else {

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

		response->setTo(m_jid.toBare());

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

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

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

		onPresenceChanged(response);

	}

}

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

	m_rosterManager->handleSubscription(presence);

}

void User::onConnectingTimeout() {

	if (m_connected || m_readyForConnect)

		return;

	m_reconnectTimer->stop();

	m_readyForConnect = true;

	onReadyToConnect();

}

void User::setIgnoreDisconnect(bool ignoreDisconnect) {

	m_ignoreDisconnect = ignoreDisconnect;

	LOG4CXX_INFO(logger, m_jid.toString() << ": Setting ignoreDisconnect=" << m_ignoreDisconnect);

}

void User::handleDisconnected(const std::string &error) {

	if (m_ignoreDisconnect) {

		LOG4CXX_INFO(logger, m_jid.toString() << ": Disconnecting from legacy network ignored (probably moving between backends)");

		return;

	}

	if (error.empty()) {

		LOG4CXX_INFO(logger, m_jid.toString() << ": Disconnected from legacy network");

	}

	else {

		LOG4CXX_INFO(logger, m_jid.toString() << ": Disconnected from legacy network with error " << error);

	}

	onDisconnected();

	boost::shared_ptr<Swift::Message> msg(new Swift::Message());

	msg->setBody(error);

	msg->setTo(m_jid.toBare());

	msg->setFrom(m_component->getJID());

	m_component->getStanzaChannel()->sendMessage(msg);

	// In server mode, server finishes the session and pass unavailable session to userManager if we're connected to legacy network,

	// so we can't removeUser() in server mode, because it would be removed twice.

	// Once in finishSession and once in m_userManager->removeUser.

	if (m_component->inServerMode()) {

		// Remove user later just to be sure there won't be double-free.

		// We can't be sure finishSession sends unavailable presence everytime, so check if user gets removed

		// in finishSession(...) call and if not, remove it here.

		std::string jid = m_jid.toBare().toString();		

		dynamic_cast<Swift::ServerStanzaChannel *>(m_component->getStanzaChannel())->finishSession(m_jid, boost::shared_ptr<Swift::Element>(new Swift::StreamError()));

		if (m_userManager->getUser(jid) != NULL) {

			m_userManager->removeUser(this);

		}

	}

	else {

		m_userManager->removeUser(this);

	}

}

}