/**

 * 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

 */

#pragma once

#include <vector>

#include "Swiften/Swiften.h"

#include "Swiften/Queries/Responder.h"

#include "Swiften/Elements/VCard.h"

namespace Transport {

class StorageBackend;

class UserManager;

class User;

class VCardResponder : public Swift::Responder<Swift::VCard> {

	public:

		VCardResponder(Swift::IQRouter *router, Swift::NetworkFactories *factories, UserManager *userManager);

		~VCardResponder();

		void sendVCard(unsigned int id, boost::shared_ptr<Swift::VCard> vcard);

		boost::signal<void (User *, const std::string &name, unsigned int id)> onVCardRequired;

		boost::signal<void (User *, boost::shared_ptr<Swift::VCard> vcard)> onVCardUpdated;

		void collectTimeouted();

	private:

		struct VCardData {

			Swift::JID from;

			Swift::JID to;

			std::string id;

			time_t received;

		};

		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::VCard> payload);

		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::VCard> payload);

		UserManager *m_userManager;

		std::map<unsigned int, VCardData> m_queries;

		unsigned int m_id;

		Swift::Timer::ref m_collectTimer;

};

/**

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

#include "transport/user.h"

#include "transport/transport.h"

#include "transport/storagebackend.h"

#include "transport/rostermanager.h"

#include "transport/usermanager.h"

#include "transport/conversationmanager.h"

#include "transport/localbuddy.h"

#include "transport/config.h"

#include "transport/conversation.h"

#include "transport/vcardresponder.h"

#include "transport/rosterresponder.h"

#include "transport/memoryreadbytestream.h"

#include "transport/logging.h"

#include "transport/admininterface.h"

#include "blockresponder.h"

#include "Swiften/Swiften.h"

#include "Swiften/Server/ServerStanzaChannel.h"

#include "Swiften/Elements/StreamError.h"

#include "Swiften/Network/BoostConnectionServer.h"

#include "Swiften/Elements/AttentionPayload.h"

#include "Swiften/Elements/XHTMLIMPayload.h"

#include "Swiften/Elements/InvisiblePayload.h"

#include "Swiften/Elements/SpectrumErrorPayload.h"

#include "transport/protocol.pb.h"

#include "transport/util.h"

#include "utf8.h"

#include <Swiften/FileTransfer/ReadBytestream.h>

#include <Swiften/Elements/StreamInitiationFileInfo.h>

#ifdef _WIN32

#include "windows.h"

#include <stdint.h>

#else

#include "sys/wait.h"

#include "sys/signal.h"

#include "popt.h"

#endif

using namespace Transport::Util;

namespace Transport {

static unsigned long backend_id;

static unsigned long bytestream_id;

DEFINE_LOGGER(logger, "NetworkPluginServer");

class NetworkConversation : public Conversation {

	public:

		NetworkConversation(ConversationManager *conversationManager, const std::string &legacyName, bool muc = false) : Conversation(conversationManager, legacyName, muc) {

		}

		// Called when there's new message to legacy network from XMPP network

		void sendMessage(boost::shared_ptr<Swift::Message> &message) {

			onMessageToSend(this, message);

		}

		boost::signal<void (NetworkConversation *, boost::shared_ptr<Swift::Message> &)> onMessageToSend;

};

class NetworkFactory : public Factory {

	public:

		NetworkFactory(NetworkPluginServer *nps) {

			m_nps = nps;

		}

		virtual ~NetworkFactory() {}

		// Creates new conversation (NetworkConversation in this case)

		Conversation *createConversation(ConversationManager *conversationManager, const std::string &legacyName) {

			NetworkConversation *nc = new NetworkConversation(conversationManager, legacyName);

			nc->onMessageToSend.connect(boost::bind(&NetworkPluginServer::handleMessageReceived, m_nps, _1, _2));

			return nc;

		}

		// Creates new LocalBuddy

		Buddy *createBuddy(RosterManager *rosterManager, const BuddyInfo &buddyInfo) {

			LocalBuddy *buddy = new LocalBuddy(rosterManager, buddyInfo.id, buddyInfo.legacyName, buddyInfo.alias, buddyInfo.groups, (BuddyFlag) buddyInfo.flags);

			if (!buddy->isValid()) {

				delete buddy;

				return NULL;

			}

			if (buddyInfo.subscription == "both") {

				buddy->setSubscription(Buddy::Both);

			}

			else {

				buddy->setSubscription(Buddy::Ask);

			}

			if (buddyInfo.settings.find("icon_hash") != buddyInfo.settings.end())

				buddy->setIconHash(buddyInfo.settings.find("icon_hash")->second.s);

			return buddy;

		}

	private:

		NetworkPluginServer *m_nps;

};

// Wraps google protobuf payload into WrapperMessage and serialize it to string

#define WRAP(MESSAGE, TYPE) 	pbnetwork::WrapperMessage wrap; \

	wrap.set_type(TYPE); \

	wrap.set_payload(MESSAGE); \

	wrap.SerializeToString(&MESSAGE);

// Executes new backend

static unsigned long exec_(const std::string& exePath, const char *host, const char *port, const char *cmdlineArgs) {

	// BACKEND_ID is replaced with unique ID. The ID is increasing for every backend.

	std::string finalExePath = boost::replace_all_copy(exePath, "BACKEND_ID", boost::lexical_cast<std::string>(backend_id++));	

#ifdef _WIN32

	// Add host and port.

	std::ostringstream fullCmdLine;

	fullCmdLine << "\"" << finalExePath << "\" --host " << host << " --port " << port;

	if (cmdlineArgs)

		fullCmdLine << " " << cmdlineArgs;

	LOG4CXX_INFO(logger, "Starting new backend " << fullCmdLine.str());

	// We must provide a non-const buffer to CreateProcess below

	std::vector<wchar_t> rawCommandLineArgs( fullCmdLine.str().size() + 1 );

	wcscpy_s(&rawCommandLineArgs[0], rawCommandLineArgs.size(), utf8ToUtf16(fullCmdLine.str()).c_str());

	STARTUPINFO         si;

	PROCESS_INFORMATION pi;

	ZeroMemory (&si, sizeof(si));

	si.cb=sizeof (si);

	if (! CreateProcess(

		utf8ToUtf16(finalExePath).c_str(),

		&rawCommandLineArgs[0],