#include "Swiften/Disco/EntityCapsManager.h"

#include "Swiften/Disco/CapsManager.h"

#include "Swiften/Disco/CapsMemoryStorage.h"

#include "Swiften/Network/BoostTimerFactory.h"

#include "Swiften/Network/BoostIOServiceThread.h"

#include "Swiften/Server/UserRegistry.h"

#include "Swiften/Base/SafeByteArray.h"

#include "Swiften/Jingle/JingleSessionManager.h"

#include <boost/bind.hpp>

#include "transport/config.h"

#include "transport/factory.h"

#include "transport/presenceoracle.h"

#include <Swiften/Network/BoostConnectionServer.h>

namespace Transport {

	// typedef enum { 	CLIENT_FEATURE_ROSTERX = 2,

	// 				CLIENT_FEATURE_XHTML_IM = 4,

	// 				CLIENT_FEATURE_FILETRANSFER = 8,

	// 				CLIENT_FEATURE_CHATSTATES = 16

	// 				} SpectrumImportantFeatures;

	// 

	class StorageBackend;

	class DiscoInfoResponder;

	class Factory;

	class UserRegistry;

	/// Represents one transport instance.

	/// It's used to connect the Jabber server and provides transaction layer

	/// between Jabber server and other classes.

	///

	/// In server mode it represents Jabber server to which users can connect and use

	/// it as transport.

	class Component {

		public:

			/// Creates new Component instance.

			/// \param loop Main event loop.

			/// \param config Cofiguration; this class uses following Config values:

			/// 	- service.jid

			/// 	- service.password

			/// 	- service.server

			/// 	- service.port

			/// 	- service.server_mode

			/// \param factory Transport Abstract factory used to create basic transport structures.

			Component(Swift::EventLoop *loop, Swift::NetworkFactories *factories, Config *config, Factory *factory, Transport::UserRegistry *userRegistry = NULL);

			void handleConnected();

			void handleConnectionError(const Swift::ComponentError &error);

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

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

			void handleDataRead(const Swift::SafeByteArray &data);

			void handleDataWritten(const Swift::SafeByteArray &data);

			void handleDiscoInfoResponse(boost::shared_ptr<Swift::DiscoInfo> info, Swift::ErrorPayload::ref error, const Swift::JID& jid);

			void handleCapsChanged(const Swift::JID& jid);

			Swift::NetworkFactories *m_factories;

			Swift::Component *m_component;

			Swift::Server *m_server;

			Swift::Timer::ref m_reconnectTimer;

			Swift::EntityCapsManager *m_entityCapsManager;

			Swift::CapsManager *m_capsManager;

			Swift::CapsMemoryStorage *m_capsMemoryStorage;

			PresenceOracle *m_presenceOracle;

			Swift::StanzaChannel *m_stanzaChannel;

			Swift::IQRouter *m_iqRouter;

			Transport::UserRegistry *m_userRegistry;

			StorageBackend *m_storageBackend;

 			DiscoInfoResponder *m_discoInfoResponder;

			int m_reconnectCount;

			Config* m_config;

			std::string m_protocol;

			Swift::JID m_jid;

			Factory *m_factory;

			Swift::EventLoop *m_loop;

		friend class User;

		friend class UserRegistration;

		friend class NetworkPluginServer;

	};

}

#include "transport/config.h"

#include "transport/transport.h"

#include "transport/filetransfermanager.h"

#include "transport/usermanager.h"

#include "transport/logger.h"

#include "transport/sqlite3backend.h"

#include "transport/mysqlbackend.h"

#include "transport/pqxxbackend.h"

#include "transport/userregistration.h"

#include "transport/networkpluginserver.h"

#include "transport/admininterface.h"

#include "transport/statsresponder.h"

#include "transport/usersreconnecter.h"

#include "transport/util.h"

#include "transport/gatewayresponder.h"

#include "transport/logging.h"

#include "Swiften/EventLoop/SimpleEventLoop.h"

#include <boost/filesystem.hpp>

#include <boost/algorithm/string.hpp>

#ifndef WIN32

#include "sys/signal.h"

#include <pwd.h>

#include <grp.h>

#include <sys/resource.h>

#include "libgen.h"

#else

#include <windows.h>

#endif

#include <sys/stat.h>

using namespace Transport;

DEFINE_LOGGER(logger, "Spectrum");

Swift::SimpleEventLoop *eventLoop_ = NULL;

Component *component_ = NULL;

UserManager *userManager_ = NULL;

static void stop_spectrum() {

	userManager_->removeAllUsers(false);

	UserManager userManager(&transport, &userRegistry, storageBackend);

	userManager_ = &userManager;

	UserRegistration *userRegistration = NULL;

	UsersReconnecter *usersReconnecter = NULL;

	if (storageBackend) {

		userRegistration = new UserRegistration(&transport, &userManager, storageBackend);

		userRegistration->start();

		usersReconnecter = new UsersReconnecter(&transport, storageBackend);

	}

	FileTransferManager ftManager(&transport, &userManager);

	NetworkPluginServer plugin(&transport, &config, &userManager, &ftManager);

	AdminInterface adminInterface(&transport, &userManager, &plugin, storageBackend);

	StatsResponder statsResponder(&transport, &userManager, &plugin, storageBackend);

	statsResponder.start();

	GatewayResponder gatewayResponder(transport.getIQRouter(), &userManager);

	gatewayResponder.start();

	eventLoop_ = &eventLoop;

	eventLoop.run();

	if (userRegistration) {

		userRegistration->stop();

		delete userRegistration;

	}

	if (usersReconnecter) {

		delete usersReconnecter;

	}

	delete storageBackend;

	delete factories;

	return 0;

}

 *

 * 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 <boost/algorithm/string/predicate.hpp>

#include "transport/storagebackend.h"

#include "transport/factory.h"

#include "transport/userregistry.h"

#include "transport/logging.h"

#include "discoinforesponder.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/StatsParser.h"

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

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

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

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

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

#include "transport/BlockParser.h"

#include "transport/BlockSerializer.h"

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

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

#include "Swiften/Swiften.h"

using namespace Swift;

using namespace boost;

namespace Transport {

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

}