/**

 * XMPP - libpurple transport

 *

 * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>

 *

 * 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 <string>

#include <algorithm>

#include "transport/transport.h"

#include "Swiften/Swiften.h"

namespace Transport {

class RosterManager;

typedef enum { 	BUDDY_NO_FLAG = 0,

				BUDDY_JID_ESCAPING = 2,

				BUDDY_IGNORE = 4,

				BUDDY_BLOCKED = 8,

			} BuddyFlag;

/// Represents one legacy network Buddy.

class Buddy {

	public:

		/// Constructor.

		/// \param rosterManager RosterManager associated with this buddy.

		/// \param id ID which identifies the buddy in database or -1 if it's new buddy which is

		/// not in database yet.

		Buddy(RosterManager *rosterManager, long id = -1);

		/// Destructor

		virtual ~Buddy();

		/// Sets unique ID used to identify this buddy by StorageBackend.

		/// This is set

		/// by RosterStorage class once the buddy is stored into database or when the

		/// buddy is loaded from database.

		/// You should not need to set this ID manually.

		/// \param id ID

		void setID(long id);

		/// Returns unique ID used to identify this buddy by StorageBackend.

		/// \return ID which identifies the buddy in database or -1 if it's new buddy which is

		/// not in database yet.

		long getID();

		/// Returns full JID of this buddy.

		/// \param hostname hostname used as domain in returned JID

		/// \return full JID of this buddy

		const Swift::JID &getJID();

		/// Generates whole Presennce stanza with current status/show for this buddy.

		/// Presence stanza does not containt "to" attribute, it has to be added manually.

		/// \param features features used in returned stanza

		/// \param only_new if True, this function returns Presence stanza only if it's different

		/// than the previously generated one.

		/// \return Presence stanza or NULL.

		Swift::Presence::ref generatePresenceStanza(int features, bool only_new = false);

		void setBlocked(bool block) {

			if (block)

				m_flags = (BuddyFlag) (m_flags | BUDDY_BLOCKED);

			else

				m_flags = (BuddyFlag) (m_flags & ~BUDDY_BLOCKED);

		}

		bool isBlocked() {

			return (m_flags & BUDDY_BLOCKED)  != 0;

		}

		/// Sets current subscription.

		/// \param subscription "to", "from", "both", "ask"

		/// Returns current subscription

		/// \return subscription "to", "from", "both", "ask"

		/// Sets this buddy's flags.

		/// \param flags flags

		void setFlags(BuddyFlag flags);

		/// Returns this buddy's flags.

		/// \param flags flags

		BuddyFlag getFlags();

		/// Returns RosterManager associated with this buddy.

		/// \return RosterManager associated with this buddy.

		RosterManager *getRosterManager() { return m_rosterManager; }

		/// Returns legacy network username which does not contain unsafe characters,

		/// so it can be used in JIDs.

		std::string getSafeName();

		/// This method should be called whenever some information returned by virtual functions changes.

		/// This method sends presence to XMPP user.

		void handleBuddyChanged();

		/// Handles VCard from legacy network and forwards it to XMPP user.

		/// \param id ID used in IQ-result.

		/// \param vcard VCard which will be sent.

		void handleVCardReceived(const std::string &id, Swift::VCard::ref vcard);

		/// Returns legacy network username of this buddy. (for example UIN for ICQ, JID for Jabber, ...).

		/// \return legacy network username

		virtual std::string getName() = 0;

		/// Returns alias (nickname) of this buddy.

		/// \return alias (nickname)

		virtual std::string getAlias() = 0;

		/// Returns list of groups this buddy is in.

		/// \return groups

		virtual std::vector<std::string> getGroups() = 0;

		/// Returns current legacy network status and statuMessage of this buddy.

		/// \param status current status/show is stored here

		/// \param statusMessage current status message is stored here

		/// \return true if status was stored successfully

		virtual bool getStatus(Swift::StatusShow &status, std::string &statusMessage) = 0;

		/// Returns SHA-1 hash of buddy icon (avatar) or empty string if there is no avatar for this buddy.

		/// \return avatar hash or empty string.

		virtual std::string getIconHash() = 0;

		/// Returns legacy name of buddy from JID.

		/// \param jid Jabber ID.

		/// \return legacy name of buddy from JID.

		static std::string JIDToLegacyName(const Swift::JID &jid);

		static BuddyFlag buddFlagsFromJID(const Swift::JID &jid);

	private:

		void generateJID();

		long m_id;

// 		Swift::Presence::ref m_lastPresence;

		Swift::JID m_jid;

		BuddyFlag m_flags;

		RosterManager *m_rosterManager;

};

}

/**

 * XMPP - libpurple transport

 *

 * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>

 *

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

#include "transport/rostermanager.h"

#include "transport/user.h"

#include "transport/transport.h"

#include "transport/BlockPayload.h"

namespace Transport {

// 	m_rosterManager->setBuddy(this);

}

Buddy::~Buddy() {

// 	m_rosterManager->unsetBuddy(this);

}

void Buddy::generateJID() {

	m_jid = Swift::JID();

	m_jid = Swift::JID(getSafeName(), m_rosterManager->getUser()->getComponent()->getJID().toString(), "bot");

}

void Buddy::setID(long id) {

	m_id = id;

}

long Buddy::getID() {

	return m_id;

}

void Buddy::setFlags(BuddyFlag flags) {

	m_flags = flags;

// 	generateJID();

}

BuddyFlag Buddy::getFlags() {

	return m_flags;

}

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

	if (!m_jid.isValid() || m_jid.getNode().empty()) {

		generateJID();

	}

	return m_jid;

}

}

}

Swift::Presence::ref Buddy::generatePresenceStanza(int features, bool only_new) {

	std::string alias = getAlias();

	std::string name = getSafeName();

	Swift::StatusShow s;

	std::string statusMessage;

	if (!getStatus(s, statusMessage))

		return Swift::Presence::ref();

	if (m_jid.getNode().empty()) {

		generateJID();

	}

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

 	presence->setFrom(m_jid);

	presence->setTo(m_rosterManager->getUser()->getJID().toBare());

	presence->setType(Swift::Presence::Available);

	if (!statusMessage.empty())

		presence->setStatus(statusMessage);

	if (s.getType() == Swift::StatusShow::None)

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

	presence->setShow(s.getType());

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

		// caps

		presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::CapsInfo(m_rosterManager->getUser()->getComponent()->getBuddyCapsInfo())));

// 		if (features & 0/*TRANSPORT_FEATURE_AVATARS*/) {

			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::VCardUpdate (getIconHash())));

// 		}

		if (isBlocked()) {

			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Transport::BlockPayload ()));

		}

	}

// 	if (only_new) {

// 		if (m_lastPresence)

// 			m_lastPresence->setTo(Swift::JID(""));

// 		if (m_lastPresence == presence) {

// 			return Swift::Presence::ref();

// 		}

// 		m_lastPresence = presence;

// 	}

#include "windows.h"

#include <stdint.h>

#else

#include "sys/wait.h"

#include "sys/signal.h"

#include "popt.h"

#endif

using namespace log4cxx;

namespace Transport {

static unsigned long backend_id;

static unsigned long bytestream_id;

static LoggerPtr logger = Logger::getLogger("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;

		}

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

			buddy->setAlias(buddyInfo.alias);

			buddy->setName(buddyInfo.legacyName);

			buddy->setGroups(buddyInfo.groups);

			buddy->setFlags((BuddyFlag) (buddyInfo.flags));

			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_(std::string path, const char *host, const char *port, const char *config) {

	std::string original_path = path;

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

	boost::replace_all(path, "BACKEND_ID", boost::lexical_cast<std::string>(backend_id++));

	// Add host and port.

	path += std::string(" --host ") + host + " --port " + port + " " + config;

	LOG4CXX_INFO(logger, "Starting new backend " << path);

#ifdef _WIN32

	STARTUPINFO         si;

	PROCESS_INFORMATION pi;

	ZeroMemory (&si, sizeof(si));

	si.cb=sizeof (si);

	if (! CreateProcess(

	NULL,

	(LPSTR)path.c_str(),         // command line

	0,                    // process attributes

	0,                    // thread attributes

	0,                    // inherit handles

	0,                    // creation flags

	0,                    // environment

	0,                    // cwd

	&si,

	&pi

	)

	)  {

		LOG4CXX_ERROR(logger, "Could not start process");

// 	if (id != -1) {

// 		Transport::instance()->sql()->addBuddy(user->storageId(), name, s_buddy->getSubscription(), s_buddy->getGroup(), alias, s_buddy->getFlags());

// 	}

// 	else {

// 		id = Transport::instance()->sql()->addBuddy(user->storageId(), name, s_buddy->getSubscription(), s_buddy->getGroup(), alias, s_buddy->getFlags());

// 		s_buddy->setId(id);

// 	}

// 	Log("buddyListSaveNode", id << " " << name << " " << alias << " " << s_buddy->getSubscription());

// 	if (s_buddy->getBuddy() && id != -1) {

// 		PurpleBuddy *buddy = s_buddy->getBuddy();

// 		SaveData *s = new SaveData;

// 		s->user = user;

// 		s->id = id;

// 		g_hash_table_foreach(buddy->node.settings, save_settings, s);

// 		delete s;

// 	}

// 	return TRUE;

// }

RosterStorage::RosterStorage(User *user, StorageBackend *storageBackend) {

	m_user = user;

	m_storageBackend = storageBackend;

	m_storageTimer = m_user->getComponent()->getNetworkFactories()->getTimerFactory()->createTimer(5000);

	m_storageTimer->onTick.connect(boost::bind(&RosterStorage::storeBuddies, this));

}

RosterStorage::~RosterStorage() {

	m_storageTimer->stop();

}

void RosterStorage::storeBuddy(Buddy *buddy) {

	m_buddies[buddy->getName()] = buddy;

	m_storageTimer->start();

}

bool RosterStorage::storeBuddies() {

	if (m_buddies.size() == 0) {

		return false;

	}

	m_storageBackend->beginTransaction();

	for (std::map<std::string, Buddy *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {

		Buddy *buddy = (*it).second;

		BuddyInfo buddyInfo;

		buddyInfo.alias = buddy->getAlias();

		buddyInfo.legacyName = buddy->getName();

		buddyInfo.groups = buddy->getGroups();

		buddyInfo.id = buddy->getID();

		buddyInfo.flags = buddy->getFlags();

		buddyInfo.settings["icon_hash"].s = buddy->getIconHash();

		buddyInfo.settings["icon_hash"].type = TYPE_STRING;

		// Buddy is in DB

		if (buddyInfo.id != -1) {

			m_storageBackend->updateBuddy(m_user->getUserInfo().id, buddyInfo);

		}

		else {

			buddyInfo.id = m_storageBackend->addBuddy(m_user->getUserInfo().id, buddyInfo);

			buddy->setID(buddyInfo.id);

		}

// 		Log("buddyListSaveNode", id << " " << name << " " << alias << " " << s_buddy->getSubscription());

// 		if (s_buddy->getBuddy() && id != -1) {

// 			PurpleBuddy *buddy = s_buddy->getBuddy();

// 			SaveData *s = new SaveData;

// 			s->user = user;

// 			s->id = id;

// 			g_hash_table_foreach(buddy->node.settings, save_settings, s);

// 			delete s;

// 		}

	}

	m_storageBackend->commitTransaction();

	return true;

}

void RosterStorage::removeBuddyFromQueue(Buddy *buddy) {

	m_buddies.erase(buddy->getName());

}

}

#include "transport/conversationmanager.h"

#include "transport/userregistry.h"

#include "transport/config.h"

#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 <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"

using namespace Transport;

class TestingConversation : public Conversation {

	public:

		TestingConversation(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) {

		}

};

class TestingFactory : public Factory {

	public:

		TestingFactory() {

		}

		// Creates new conversation (NetworkConversation in this case)

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

			Conversation *nc = new TestingConversation(conversationManager, legacyName);

			return nc;

		}

		// Creates new LocalBuddy

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

			LocalBuddy *buddy = new LocalBuddy(rosterManager, buddyInfo.id);

			buddy->setAlias(buddyInfo.alias);

			buddy->setName(buddyInfo.legacyName);

			buddy->setGroups(buddyInfo.groups);

			buddy->setFlags((BuddyFlag) buddyInfo.flags);

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

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

			return buddy;

		}

};

class BasicTest : public Swift::XMPPParserClient {

	public:

		void setMeUp (void);

		void tearMeDown (void);

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

	void handleStreamStart(const Swift::ProtocolHeader&);

	void handleElement(boost::shared_ptr<Swift::Element> element);

	void handleStreamEnd();

	void injectPresence(boost::shared_ptr<Swift::Presence> &response);

	void injectIQ(boost::shared_ptr<Swift::IQ> iq);

	Swift::Stanza *getStanza(boost::shared_ptr<Swift::Element> element);

	protected:

		bool streamEnded;

		UserManager *userManager;

		boost::shared_ptr<Swift::ServerFromClientSession> serverFromClientSession;

		Swift::FullPayloadSerializerCollection* payloadSerializers;

		Swift::FullPayloadParserFactoryCollection* payloadParserFactories;

		Swift::XMPPParser *parser;

		UserRegistry *userRegistry;

		Config *cfg;

		Swift::Server *server;

		Swift::DummyNetworkFactories *factories;

		Swift::DummyEventLoop *loop;

		TestingFactory *factory;

		Component *component;

		std::vector<boost::shared_ptr<Swift::Element> > received;

};