#include "Swiften/Elements/Element.h"

#include "Swiften/Elements/Presence.h"

#include "Swiften/Elements/RosterPayload.h"

#include "Swiften/Network/NetworkFactories.h"

#include "Swiften/Session/SessionTracer.h"

#include "Swiften/Elements/IQ.h"

#include "Swiften/Elements/VCard.h"

#include "Swiften/Server/UserRegistry.h"

#include <string>

#include "Swiften/Network/ConnectionServer.h"

#include "Swiften/Network/ConnectionFactory.h"

#include "Swiften/Server/ServerFromClientSession.h"

#include "Swiften/Server/ServerStanzaChannel.h"

#include "Swiften/Queries/IQRouter.h"

#include <iostream>

namespace Swift {

Server::Server(

		EventLoop* eventLoop,

		NetworkFactories* networkFactories,

		UserRegistry *userRegistry,

		const JID& jid,

		int port) :

			userRegistry_(userRegistry),

			port_(port),

			eventLoop(eventLoop),

			networkFactories_(networkFactories),

			stopping(false),

			selfJID(jid),

	stanzaChannel_ = new ServerStanzaChannel();

	iqRouter_ = new IQRouter(stanzaChannel_);

	tlsFactory = NULL;

	parserFactory_ = new PlatformXMLParserFactory();

}

Server::~Server() {

	stop();

	delete iqRouter_;

	delete stanzaChannel_;

	delete parserFactory_;

}

void Server::start() {

	if (serverFromClientConnectionServer) {

		return;

	}

		serverFromClientConnectionServer = networkFactories_->getConnectionServerFactory()->createConnectionServer(port_);

	serverFromClientConnectionServerSignalConnections.push_back(

		serverFromClientConnectionServer->onNewConnection.connect(

				boost::bind(&Server::handleNewClientConnection, this, _1)));

// 	serverFromClientConnectionServerSignalConnections.push_back(

// 		serverFromClientConnectionServer->onStopped.connect(

// 				boost::bind(&Server::handleClientConnectionServerStopped, this, _1)));

	serverFromClientConnectionServer->start();

}

void Server::stop() {

	if (stopping) {

		return;

	}

	stopping = true;

// 	foreach(boost::shared_ptr<ServerFromClientSession> session, serverFromClientSessions) {

// 		session->finishSession();

// 	}

	serverFromClientSessions.clear();

	if (serverFromClientConnectionServer) {

		serverFromClientConnectionServer->stop();

#include "Swiften/Network/ConnectionServer.h"

#include "Swiften/Server/UserRegistry.h"

#include "Swiften/Server/ServerSession.h"

#include "Swiften/Base/IDGenerator.h"

#include "Swiften/Server/ServerFromClientSession.h"

#include "Swiften/JID/JID.h"

#include "Swiften/Base/ByteArray.h"

#include "Swiften/Entity/Entity.h"

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

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

#include <Swiften/TLS/CertificateWithKey.h>

#include <Swiften/Parser/PlatformXMLParserFactory.h>

namespace Swift {

	class ConnectionServer;

	class SessionTracer;

	class EventLoop;

	class NetworkFactories;

	class StanzaChannel;

	class IQRouter;

	class TLSServerContextFactory;

	class Server : public Entity {

		public:

			~Server();

			void start();

			void stop();

			int getPort() const {

				return port_;

			}

			StanzaChannel* getStanzaChannel() const {

				return stanzaChannel_;

			}

			IQRouter* getIQRouter() const {

				return iqRouter_;

			}

			boost::shared_ptr<ConnectionServer> getConnectionServer() const {

				return serverFromClientConnectionServer;

			}

			boost::signal<void (const SafeByteArray&)> onDataRead;

			boost::signal<void (const SafeByteArray&)> onDataWritten;

		private:

			void handleNewClientConnection(boost::shared_ptr<Connection> c);

			void handleSessionStarted(boost::shared_ptr<ServerFromClientSession>);

			void handleSessionFinished(boost::shared_ptr<ServerFromClientSession>);

			void handleElementReceived(boost::shared_ptr<Element> element, boost::shared_ptr<ServerFromClientSession> session);

			void handleDataRead(const SafeByteArray&);

			void handleDataWritten(const SafeByteArray&);

		private:

			IDGenerator idGenerator;

			UserRegistry *userRegistry_;

			int port_;

			EventLoop* eventLoop;

			NetworkFactories* networkFactories_;

			bool stopping;

			boost::shared_ptr<ConnectionServer> serverFromClientConnectionServer;

			std::vector<boost::bsignals::connection> serverFromClientConnectionServerSignalConnections;

			std::list<boost::shared_ptr<ServerFromClientSession> > serverFromClientSessions;

			JID selfJID;

			StanzaChannel *stanzaChannel_;

			IQRouter *iqRouter_;

			TLSServerContextFactory *tlsFactory;

			CertificateWithKey::ref cert;

			PlatformXMLParserFactory *parserFactory_;

	};

}

[service]

# 1 if Spectrum should run in server mode.

server_mode = 1

# The name of user/group Spectrum runs as.

#user=spectrum

#group=spectrum

# JID of Spectrum instance.

jid = localhost

# Password used to connect the XMPP server in gateway mode.

# In server mode, this option is ignored.

password = secret

# XMPP server to which Spectrum connects in gateway mode.

server = 127.0.0.1

# XMPP server port.

port = 5222

# Interface on which Spectrum listens for backends.

backend_host = localhost

# Port on which Spectrum listens for backends.

# By default Spectrum chooses random backend port and there's

# no need to change it normally

#backend_port=10001

# Full path to PKCS#12 cetficiate used for TLS in server mode.

#cert=

# Certificate password if any.

#cert_password= 

# Number of users per one legacy network backend.

users_per_backend=10

# Full path to backend binary.

backend=/usr/bin/spectrum2_libpurple_backend

	CPPUNIT_TEST_SUITE(UserRegistryTest);

	CPPUNIT_TEST(login);

	CPPUNIT_TEST(loginInvalidPassword);

	CPPUNIT_TEST(loginTwoClientsValidPasswords);

	CPPUNIT_TEST(loginTwoClientsDifferentPasswords);

	CPPUNIT_TEST(loginDisconnect);

	CPPUNIT_TEST(removeLater);

	CPPUNIT_TEST_SUITE_END();

	public:

		void setUp (void) {

			state1 = Init;

			state2 = Init;

			std::istringstream ifs;

			cfg = new Config();

			cfg->load(ifs);

			loop = new Swift::DummyEventLoop();

			factories = new Swift::DummyNetworkFactories(loop);

			userRegistry = new UserRegistry(cfg, factories);

			userRegistry->onConnectUser.connect(bind(&UserRegistryTest::handleConnectUser, this, _1));

			userRegistry->onDisconnectUser.connect(bind(&UserRegistryTest::handleDisconnectUser, this, _1));

			server->start();

			connectionServer = server->getConnectionServer();

			client1 = factories->getConnectionFactory()->createConnection();

			dynamic_cast<Swift::DummyConnectionServer *>(connectionServer.get())->acceptConnection(client1);

			dynamic_cast<Swift::DummyConnection *>(client1.get())->onDataSent.connect(boost::bind(&UserRegistryTest::handleDataReceived, this, _1, client1));

			client2 = factories->getConnectionFactory()->createConnection();

			dynamic_cast<Swift::DummyConnectionServer *>(connectionServer.get())->acceptConnection(client2);

			dynamic_cast<Swift::DummyConnection *>(client2.get())->onDataSent.connect(boost::bind(&UserRegistryTest::handleDataReceived, this, _1, client2));

			loop->processEvents();

		}

		void tearDown (void) {

			delete server;

			dynamic_cast<Swift::DummyConnection *>(client1.get())->onDataSent.disconnect(boost::bind(&UserRegistryTest::handleDataReceived, this, _1, client1));

			client1.reset();

			dynamic_cast<Swift::DummyConnection *>(client2.get())->onDataSent.disconnect(boost::bind(&UserRegistryTest::handleDataReceived, this, _1, client2));

			client2.reset();

			connectionServer.reset();

			delete userRegistry;

namespace Transport {

DEFINE_LOGGER(logger, "Component");

DEFINE_LOGGER(logger_xml, "Component.XML");

Component::Component(Swift::EventLoop *loop, Swift::NetworkFactories *factories, 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;

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

	m_factories = factories;

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

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

#ifndef _WIN32

//TODO: fix

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

			LOG4CXX_INFO(logger, "SSLv23_server_method used.");

			TLSServerContextFactory *f = new OpenSSLServerContextFactory();

			CertificateWithKey::ref certificate = boost::make_shared<PKCS12Certificate>(CONFIG_STRING(m_config, "service.cert"), createSafeByteArray(CONFIG_STRING(m_config, "service.cert_password")));

			m_server->addTLSEncryption(f, certificate);

#endif

		}

		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<Transport::BlockParser>("block", "urn:xmpp:block:0"));

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

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