/**

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

#include "SlackUser.h"

#include "SlackRTM.h"

#include "transport/Transport.h"

#include "transport/HTTPRequest.h"

#include "transport/Util.h"

#include "transport/Buddy.h"

#include <boost/foreach.hpp>

#include <boost/make_shared.hpp>

#include <boost/lexical_cast.hpp>

#include <boost/algorithm/string.hpp>

#include "Swiften/Elements/MUCPayload.h"

#include <map>

#include <iterator>

namespace Transport {

	m_component = component;

	m_storageBackend = storageBackend;

	m_rtm = new SlackRTM(component, storageBackend, uinfo);

// 	m_api = new SlackAPI(component, m_uinfo.encoding);

}

	delete m_rtm;

// 	delete m_api;

}

	LOG4CXX_INFO(logger, "SEND MESSAGE");

	if (message->getFrom().getResource() == "myfavouritebot") {

		return;

	}

	m_rtm->getAPI()->sendMessage(message->getFrom().getResource(), m_jid2channel[message->getFrom().toBare().toString()], message->getBody());

}

	if (m_ownerChannel != channel) {

		std::string to = m_channel2jid[channel];

		if (!to.empty()) {

			boost::shared_ptr<Swift::Message> msg(new Swift::Message());

			msg->setType(Swift::Message::Groupchat);

			msg->setTo(to);

			msg->setFrom(Swift::JID("", "spectrum2", "default"));

			msg->setBody("<" + user + "> " + message);

			m_component->getFrontend()->onMessageReceived(msg);

		}

		return;

	}

	std::vector<std::string> args;

	boost::split(args, message, boost::is_any_of(" "));

	if (args.size() < 2 || args[0] != ".spectrum2") {

		m_rtm->sendMessage(m_ownerChannel, "Unknown command. Use \".spectrum2 help\" for help.");

		return;

	}

	if (args[1] == "join") {

		// .spectrum2 join BotName #room irc.freenode.net channel

		LOG4CXX_INFO(logger, "Received JOIN request" << args.size());

		if (args.size() == 6) {

			LOG4CXX_INFO(logger, "Received JOIN request");

			if (args[4][0] == '<') {

				args[4] = args[4].substr(1, args[4].size() - 2);

				args[4] = args[4].substr(args[4].find("|") + 1);

				LOG4CXX_INFO(logger, args[4]);

			}

			if (args[5][0] == '<') {

				args[5] = args[5].substr(2, args[5].size() - 3);

			}

			m_uinfo.uin = args[2];

			m_storageBackend->setUser(m_uinfo);

			std::string to = args[3] + "%" + args[4] + "@localhost";

			m_jid2channel[to] = args[5];

			m_channel2jid[args[5]] = to;

			LOG4CXX_INFO(logger, "Setting transport between " << to << " and " << args[5]);

		// 	int type = (int) TYPE_STRING;

		// 	m_storageBackend->getUserSetting(user.id, "room", type, to);

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

			presence->setFrom(Swift::JID("", "spectrum2", "default"));

			presence->setTo(Swift::JID(to + "/" + args[2]));

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

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

			m_component->getFrontend()->onPresenceReceived(presence);

		}

	}

	else if (args[1] == "help") {

	}

	else {

		m_rtm->sendMessage(m_ownerChannel, "Unknown command. Use \".spectrum2 help\" for help.");

	}

}

	m_ownerChannel = m_rtm->getAPI()->getChannelId(req, ok, resp, data);

	LOG4CXX_INFO(logger, "Opened channel with team owner: " << m_ownerChannel);

	std::string msg;

	msg = "Hi, it seems you have enabled Spectrum 2 transport for your Team. As a Team owner, you should now configure it.";

	m_rtm->sendMessage(m_ownerChannel, msg);

	msg = "To configure IRC network you want to connect to, type: \".spectrum2 register <bot_name>@<ircnetwork>\". For example for Freenode, the command looks like \".spectrum2 register MySlackBot@irc.freenode.net\".";

	m_rtm->sendMessage(m_ownerChannel, msg);

}

	std::string ownerId;

	std::map<std::string, SlackUserInfo> &users = m_rtm->getUsers();

	for (std::map<std::string, SlackUserInfo>::iterator it = users.begin(); it != users.end(); it++) {

		SlackUserInfo &info = it->second;

		if (info.isPrimaryOwner) {

			ownerId = it->first;

			break;

		}

	}

}

}

/**

 * Spectrum 2 Slack Frontend

 *

 * Copyright (C) 2015, 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 "transport/StorageBackend.h"

#include "rapidjson/document.h"

#include <string>

#include <algorithm>

#include <map>

#include "Swiften/Elements/Message.h"

#include <boost/signal.hpp>

namespace Transport {

class Component;

class StorageBackend;

class HTTPRequest;

class SlackRTM;

class SlackAPI;

	public:

		boost::signal<void (const std::string &user)> onInstallationDone;

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

	private:

		void handleRTMStarted();

		void handleMessageReceived(const std::string &channel, const std::string &user, const std::string &message);

		void handleImOpen(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data);

	private:

		Component *m_component;

		StorageBackend *m_storageBackend;

		UserInfo m_uinfo;

		std::string m_ownerName;

		SlackRTM *m_rtm;

		std::string m_ownerChannel;

		SlackAPI *m_api;

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

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

};

}

/**

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

#include "SlackFrontend.h"

#include "transport/Transport.h"

#include "transport/UserManager.h"

#include "transport/Logging.h"

#include <boost/foreach.hpp>

#include <stdio.h>

#include <stdlib.h>

using namespace boost;

namespace Transport {

DEFINE_LOGGER(logger, "SlackUser");

SlackUser::SlackUser(const Swift::JID &jid, UserInfo &userInfo, Component *component, UserManager *userManager) : User(jid, userInfo, component, userManager) {

	m_jid = jid.toBare();

	m_component = component;

	m_userManager = userManager;

	m_userInfo = userInfo;

}

SlackUser::~SlackUser(){

}

void SlackUser::disconnectUser(const std::string &error, Swift::SpectrumErrorPayload::Error e) {

}

}

/**

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

#include <time.h>

namespace Transport {

class Component;

class RosterManager;

class ConversationManager;

class UserManager;

class PresenceOracle;

struct UserInfo;

class SlackUser : public User {

	public:

		SlackUser(const Swift::JID &jid, UserInfo &userInfo, Component * component, UserManager *userManager);

		virtual ~SlackUser();

		void disconnectUser(const std::string &error, Swift::SpectrumErrorPayload::Error e);

	private:

		Swift::JID m_jid;

		Component *m_component;

		UserManager *m_userManager;

		UserInfo m_userInfo;

};

}

/**

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

#include "SlackUserRegistration.h"

#include "SlackFrontend.h"

#include "transport/User.h"

#include "transport/Transport.h"

#include "transport/StorageBackend.h"

#include "transport/Logging.h"

namespace Transport {

DEFINE_LOGGER(logger, "SlackUserManager");

SlackUserManager::SlackUserManager(Component *component, UserRegistry *userRegistry, StorageBackend *storageBackend) : UserManager(component, userRegistry, storageBackend) {

	m_component = component;

	m_storageBackend = storageBackend;

    m_userRegistration = new SlackUserRegistration(component, this, storageBackend);

}

SlackUserManager::~SlackUserManager() {

    delete m_userRegistration;

}

void SlackUserManager::reconnectUser(const std::string &user) {

	UserInfo uinfo;

	if (!m_storageBackend->getUser(user, uinfo)) {

		LOG4CXX_ERROR(logger, "User " << user << " tried to reconnect, but he's not registered.");

		return;

	}

}

void SlackUserManager::sendVCard(unsigned int id, Swift::VCard::ref vcard) {

}

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

}

UserRegistration *SlackUserManager::getUserRegistration() {

	return m_userRegistration;

}

std::string SlackUserManager::handleOAuth2Code(const std::string &code, const std::string &state) {

	return static_cast<SlackUserRegistration *>(m_userRegistration)->handleOAuth2Code(code, state);

}

std::string SlackUserManager::getOAuth2URL(const std::vector<std::string> &args) {

	return static_cast<SlackUserRegistration *>(m_userRegistration)->createOAuth2URL(args);

}

}

/**

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

#include "Swiften/Elements/Message.h"

#include "Swiften/Elements/Presence.h"

#include "Swiften/Elements/DiscoInfo.h"

#include <string>

#include <map>

namespace Transport {

class Component;

class StorageBackend;

class StorageResponder;

class VCardResponder;

class XMPPUserRegistration;

class GatewayResponder;

class AdHocManager;

class SettingsAdHocCommandFactory;

class SlackUserManager : public UserManager {

	public:

		SlackUserManager(Component *component, UserRegistry *userRegistry, StorageBackend *storageBackend = NULL);

		virtual ~SlackUserManager();

		void reconnectUser(const std::string &user);

		virtual void sendVCard(unsigned int id, Swift::VCard::ref vcard);

		UserRegistration *getUserRegistration();

		std::string handleOAuth2Code(const std::string &code, const std::string &state);

		std::string getOAuth2URL(const std::vector<std::string> &args);

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

	private:

		Component *m_component;

		UserRegistration *m_userRegistration;

		StorageBackend *m_storageBackend;

};

}