#include "sys/signal.h"

#endif

#ifndef __FreeBSD__

#ifndef __MACH__

// malloc_trim

#include "malloc.h"

#endif

#endif

// Boost

#include <boost/algorithm/string.hpp>

using namespace boost::filesystem;

using namespace boost::program_options;

using namespace Transport;

DEFINE_LOGGER(logger, "Swiften");

DEFINE_LOGGER(logger_xml, "backend.xml");

// eventloop

Swift::SimpleEventLoop *loop_;

// Plugins

class SwiftenPlugin;

NetworkPlugin *np = NULL;

Swift::XMPPSerializer *serializer;

class ForwardIQHandler : public Swift::IQHandler {

	public:

		std::map <std::string, std::string> m_id2resource;

		ForwardIQHandler(NetworkPlugin *np, const std::string &user) {

			m_np = np;

			m_user = user;

		}

		bool handleIQ(boost::shared_ptr<Swift::IQ> iq) {

			if (iq->getPayload<Swift::RosterPayload>() != NULL) {

				return false;

			}

			if (iq->getType() == Swift::IQ::Get) {

				m_id2resource[iq->getID()] = iq->getFrom().getResource();

			}

			iq->setTo(m_user);

			std::string xml = safeByteArrayToString(serializer->serializeElement(iq));

			m_np->sendRawXML(xml);

			return true;

		}

	private:

		NetworkPlugin *m_np;

		std::string m_user;

};

class SwiftenPlugin : public NetworkPlugin, Swift::XMPPParserClient {

	public:

		Swift::BoostNetworkFactories *m_factories;

		Swift::BoostIOServiceThread m_boostIOServiceThread;

		boost::shared_ptr<Swift::Connection> m_conn;

		bool m_firstPing;

		Swift::FullPayloadSerializerCollection collection;

		Swift::XMPPParser *m_xmppParser;

		Swift::FullPayloadParserFactoryCollection m_collection2;

		SwiftenPlugin(Config *config, Swift::SimpleEventLoop *loop, const std::string &host, int port) : NetworkPlugin() {

			this->config = config;

			m_firstPing = true;

			m_factories = new Swift::BoostNetworkFactories(loop);

			m_conn = m_factories->getConnectionFactory()->createConnection();

			m_conn->onDataRead.connect(boost::bind(&SwiftenPlugin::_handleDataRead, this, _1));

			m_conn->connect(Swift::HostAddressPort(Swift::HostAddress(host), port));

#if HAVE_SWIFTEN_3

			serializer = new Swift::XMPPSerializer(&collection, Swift::ClientStreamType, false);

#else

			serializer = new Swift::XMPPSerializer(&collection, Swift::ClientStreamType);

#endif

			m_xmppParser = new Swift::XMPPParser(this, &m_collection2, m_factories->getXMLParserFactory());

			m_xmppParser->parse("<stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' to='localhost' version='1.0'>");

			LOG4CXX_INFO(logger, "Starting the plugin.");

		}

		// NetworkPlugin uses this method to send the data to networkplugin server

		void sendData(const std::string &string) {

			m_conn->write(Swift::createSafeByteArray(string));

		}

		// This method has to call handleDataRead with all received data from network plugin server

		void _handleDataRead(boost::shared_ptr<Swift::SafeByteArray> data) {

			if (m_firstPing) {

				m_firstPing = false;

				NetworkPlugin::PluginConfig cfg;

				cfg.setRawXML(true);

				sendConfig(cfg);

			}

			std::string d(data->begin(), data->end());

			handleDataRead(d);

		}

		void handleStreamStart(const Swift::ProtocolHeader&) {}

#if HAVE_SWIFTEN_3

		void handleElement(boost::shared_ptr<Swift::ToplevelElement> element) {

#else

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

#endif

			boost::shared_ptr<Swift::Stanza> stanza = boost::dynamic_pointer_cast<Swift::Stanza>(element);

			if (!stanza) {

				return;

			}

			std::string user = stanza->getFrom().toBare();

			boost::shared_ptr<Swift::Client> client = m_users[user];

			if (!client)

				return;

			stanza->setFrom(client->getJID());

			boost::shared_ptr<Swift::Message> message = boost::dynamic_pointer_cast<Swift::Message>(stanza);

			if (message) {

				client->sendMessage(message);

				return;

			}

			boost::shared_ptr<Swift::Presence> presence = boost::dynamic_pointer_cast<Swift::Presence>(stanza);

			if (presence) {

				client->sendPresence(presence);

				return;

			}

			boost::shared_ptr<Swift::IQ> iq = boost::dynamic_pointer_cast<Swift::IQ>(stanza);

			if (iq) {

				if (m_handlers[user]->m_id2resource.find(stanza->getID()) != m_handlers[user]->m_id2resource.end()) {

					std::string resource = m_handlers[user]->m_id2resource[stanza->getID()];

					if (resource.empty()) {

						iq->setTo(Swift::JID(iq->getTo().getNode(), iq->getTo().getDomain()));					

					} else {

						iq->setTo(Swift::JID(iq->getTo().getNode(), iq->getTo().getDomain(), resource));					

					}

					m_handlers[user]->m_id2resource.erase(stanza->getID());

				}

				client->getIQRouter()->sendIQ(iq);

				return;

			}

		}

		void handleStreamEnd() {}

		void handleRawXML(const std::string &xml) {

			m_xmppParser->parse(xml);

		}

		void handleSwiftDisconnected(const std::string &user, const boost::optional<Swift::ClientError> &error) {

			std::string message = "";

			bool reconnect = false;

			if (error) {

				switch(error->getType()) {

					case Swift::ClientError::UnknownError: message = ("Unknown Error"); reconnect = true; break;

					case Swift::ClientError::DomainNameResolveError: message = ("Unable to find server"); break;

					case Swift::ClientError::ConnectionError: message = ("Error connecting to server"); break;

					case Swift::ClientError::ConnectionReadError: message = ("Error while receiving server data"); reconnect = true; break;

					case Swift::ClientError::ConnectionWriteError: message = ("Error while sending data to the server"); reconnect = true; break;

					case Swift::ClientError::XMLError: message = ("Error parsing server data"); reconnect = true; break;

					case Swift::ClientError::AuthenticationFailedError: message = ("Login/password invalid"); break;

					case Swift::ClientError::CompressionFailedError: message = ("Error while compressing stream"); break;

					case Swift::ClientError::ServerVerificationFailedError: message = ("Server verification failed"); break;

					case Swift::ClientError::NoSupportedAuthMechanismsError: message = ("Authentication mechanisms not supported"); break;

					case Swift::ClientError::UnexpectedElementError: message = ("Unexpected response"); break;

					case Swift::ClientError::ResourceBindError: message = ("Error binding resource"); break;

					case Swift::ClientError::SessionStartError: message = ("Error starting session"); break;

					case Swift::ClientError::StreamError: message = ("Stream error"); break;

					case Swift::ClientError::TLSError: message = ("Encryption error"); break;

					case Swift::ClientError::ClientCertificateLoadError: message = ("Error loading certificate (Invalid password?)"); break;

					case Swift::ClientError::ClientCertificateError: message = ("Certificate not authorized"); break;

					case Swift::ClientError::UnknownCertificateError: message = ("Unknown certificate"); break;

					case Swift::ClientError::CertificateExpiredError: message = ("Certificate has expired"); break;

					case Swift::ClientError::CertificateNotYetValidError: message = ("Certificate is not yet valid"); break;

					case Swift::ClientError::CertificateSelfSignedError: message = ("Certificate is self-signed"); break;

					case Swift::ClientError::CertificateRejectedError: message = ("Certificate has been rejected"); break;

					case Swift::ClientError::CertificateUntrustedError: message = ("Certificate is not trusted"); break;

					case Swift::ClientError::InvalidCertificatePurposeError: message = ("Certificate cannot be used for encrypting your connection"); break;

					case Swift::ClientError::CertificatePathLengthExceededError: message = ("Certificate path length constraint exceeded"); break;

					case Swift::ClientError::InvalidCertificateSignatureError: message = ("Invalid certificate signature"); break;

					case Swift::ClientError::InvalidCAError: message = ("Invalid Certificate Authority"); break;

					case Swift::ClientError::InvalidServerIdentityError: message = ("Certificate does not match the host identity"); break;

				}

			}