* 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

 */

#pragma once

#include <time.h>

#include "transport/protocol.pb.h"

// #include "conversation.h"

#include <iostream>

namespace Transport {

/// Represents Spectrum2 legacy network plugin.

/// This class is base class for all C++ legacy network plugins. It provides a way to connect 

/// Spectrum2 NetworkPluginServer and allows to use high-level API for legacy network plugins

/// development.

class NetworkPlugin {

	public:

		class PluginConfig {

			public:

				virtual ~PluginConfig() {}

				void setNeedPassword(bool needPassword = true) { m_needPassword = needPassword; }

				void setExtraFields(const std::vector<std::string> &fields) { m_extraFields = fields; }

			private:

				bool m_needPassword;

				std::vector<std::string> m_extraFields;

				friend class NetworkPlugin;

		};

		/// Creates new NetworkPlugin and connects the Spectrum2 NetworkPluginServer.

		/// \param loop Event loop.

		/// \param host Host where Spectrum2 NetworkPluginServer runs.

		/// \param port Port.

		NetworkPlugin();

		/// Destructor.

		virtual ~NetworkPlugin();

		void sendConfig(const PluginConfig &cfg);

		/// Call this function when legacy network buddy changed.

		/// \param user XMPP JID of user for which this event occurs. You can get it from NetworkPlugin::handleLoginRequest(). (eg. "user%gmail.com@xmpp.domain.tld")

		/// \param buddyName Name of legacy network buddy. (eg. "user2@gmail.com")

		/// \param alias Alias of legacy network buddy. If empty, then it's not changed on XMPP side.

		/// \param groups Groups in which buddy currently is. If empty, then it's not changed on XMPP side.

		/// \param status Status of this buddy.

		/// \param statusMessage Status message of this buddy.

		/// \param iconHash MD5 hash of buddy icon. Empty if none buddy icon.

	wrap.set_payload(MESSAGE); \

	wrap.SerializeToString(&MESSAGE);

template <class T> std::string stringOf(T object) {

	std::ostringstream os;

	os << object;

	return (os.str());

}

NetworkPlugin::NetworkPlugin() {

	m_pingReceived = false;

	double shared;

#ifndef WIN32

	process_mem_usage(shared, m_init_res);

#endif

}

NetworkPlugin::~NetworkPlugin() {

}

void NetworkPlugin::sendConfig(const PluginConfig &cfg) {

	std::string data = "[registration]";

	data += std::string("needPassword=") + (cfg.m_needPassword ? "1" : "0") + "\n";

	for (std::vector<std::string>::const_iterator it = cfg.m_extraFields.begin(); it != cfg.m_extraFields.end(); it++) {

		data += std::string("extraField=") + (*it) + "\n";

	}

	pbnetwork::BackendConfig m;

	m.set_config(data);

	std::string message;

	m.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BACKEND_CONFIG);

	send(message);

}

void NetworkPlugin::handleMessage(const std::string &user, const std::string &legacyName, const std::string &msg, const std::string &nickname, const std::string &xhtml) {

	pbnetwork::ConversationMessage m;

	m.set_username(user);

	m.set_buddyname(legacyName);

	m.set_message(msg);

	m.set_nickname(nickname);

	m.set_xhtml(xhtml);

	BOOST_FOREACH (const UnregisteredCont::value_type & varItem, m_unregistered) {

		if (boost::istarts_with(varItem.first, sectionSearchString))

			sectionValues[varItem.first] = varItem.second;

	}

	return sectionValues;

}

std::string Config::getCommandLineArgs() const {

	std::ostringstream commandLineArgs;

	// Return the command-line arguments that were passed to us originally (but remove the initial .exe part)

	for (int i = 1; i < m_argc; ++i) 	{

		commandLineArgs << "\"" << m_argv[i] << "\" ";

	}

	return commandLineArgs.str();

}

void Config::updateBackendConfig(const std::string &backendConfig) {

	options_description opts("Backend options");

	opts.add_options()

		("registration.needPassword", value<bool>()->default_value(true), "")

		("registration.extraField", value<std::vector<std::string> >()->multitoken(), "")

	;

	std::stringstream ifs(backendConfig);

	parsed_options parsed = parse_config_file(ifs, opts, true);

	store(parsed, m_backendConfig);

	notify(m_backendConfig);

}

Config *Config::createFromArgs(int argc, char **argv, std::string &error, std::string &host, int &port) {

	std::string jid;

	std::ostringstream os;

	std::string configFile;

	boost::program_options::variables_map vm;

	boost::program_options::options_description desc("Usage: spectrum <config_file.cfg>\nAllowed options");

	desc.add_options()

		("help", "help")

		("host,h", boost::program_options::value<std::string>(&host)->default_value(""), "Host to connect to")

		("port,p", boost::program_options::value<int>(&port)->default_value(10000), "Port to connect to")

		("no-daemonize,n", "Do not run spectrum as daemon")

		("no-debug,d", "Create coredumps on crash")

		("jid,j", boost::program_options::value<std::string>(&jid)->default_value(""), "Specify JID of transport manually")

		("config", boost::program_options::value<std::string>(&configFile)->default_value(""), "Config file")

#include "transport/storagebackend.h"

#include "transport/user.h"

#include "transport/transport.h"

#include "transport/conversation.h"

#include "transport/usermanager.h"

#include "transport/localbuddy.h"

#include <cppunit/TestFixture.h>

#include <cppunit/extensions/HelperMacros.h>

#include <Swiften/Swiften.h>

#include <Swiften/EventLoop/DummyEventLoop.h>

#include <Swiften/Server/Server.h>

#include <Swiften/Network/DummyNetworkFactories.h>

#include <Swiften/Network/DummyConnectionServer.h>

#include "Swiften/Server/ServerStanzaChannel.h"

#include "Swiften/Server/ServerFromClientSession.h"

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

#include "basictest.h"

using namespace Transport;

class UserManagerTest : public CPPUNIT_NS :: TestFixture, public BasicTest {

	CPPUNIT_TEST_SUITE(UserManagerTest);

	CPPUNIT_TEST(connectUser);

	CPPUNIT_TEST(connectUserTransportDisabled);

	CPPUNIT_TEST(handleProbePresence);

	CPPUNIT_TEST(disconnectUser);

	CPPUNIT_TEST_SUITE_END();

	public:

		void setUp (void) {

			setMeUp();

		}

		void tearDown (void) {

			tearMeDown();

		}

	void connectUserTransportDisabled() {

		addUser();

		storage->updateUserSetting(1, "enable_transport", "0");

		CPPUNIT_ASSERT_EQUAL(0, userManager->getUserCount());

		userRegistry->isValidUserPassword(Swift::JID("user@localhost/resource"), serverFromClientSession.get(), Swift::createSafeByteArray("password"));

		loop->processEvents();

		CPPUNIT_ASSERT_EQUAL(0, userManager->getUserCount());

		User *user = userManager->getUser("user@localhost");

		CPPUNIT_ASSERT(!user);

	}

	void handleProbePresence() {

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

		response->setTo("localhost");

		response->setFrom("user@localhost/resource");

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

		dynamic_cast<Swift::ServerStanzaChannel *>(component->getStanzaChannel())->onPresenceReceived(response);

		loop->processEvents();

		CPPUNIT_ASSERT_EQUAL(2, (int) received.size());

		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoInfo>());

		Swift::Presence *presence = dynamic_cast<Swift::Presence *>(getStanza(received[1]));

		CPPUNIT_ASSERT(presence);

		CPPUNIT_ASSERT_EQUAL(Swift::Presence::Unavailable, presence->getType());

	}

};

CPPUNIT_TEST_SUITE_REGISTRATION (UserManagerTest);

		}

		// No user and unavailable presence -> answer with unavailable

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

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

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

			response->setFrom(presence->getTo());

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

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

			// Set user offline in database

			if (m_storageBackend) {

				UserInfo res;

				bool registered = m_storageBackend->getUser(userkey, res);

				if (registered) {

					m_storageBackend->setUserOnline(res.id, false);

				}

			}

			return;

		}

		UserInfo res;

		bool registered = m_storageBackend ? m_storageBackend->getUser(userkey, res) : false;

		if (m_component->inServerMode()) {

			if (!registered) {

				res.password = "";

				res.uin = presence->getFrom().getNode();

				res.jid = userkey;

				if (res.uin.find_last_of("%") != std::string::npos) { // OK

					res.uin.replace(res.uin.find_last_of("%"), 1, "@"); // OK

				}

				if (m_storageBackend) {

					// store user and getUser again to get user ID.

					m_storageBackend->setUser(res);

					registered = m_storageBackend->getUser(userkey, res);

				}

				else {

					registered = true;

				}

			}

			res.password = m_userRegistry->getUserPassword(userkey);

		}

		// We allow auto_register feature in gateway-mode. This allows IRC user to register

		// the transport just by joining the room.

		if (!m_component->inServerMode()) {

			if (!registered && CONFIG_BOOL(m_component->getConfig(), "registration.auto_register")) {

				res.password = "";

				res.jid = userkey;