#include "transport/userregistry.h"

#include "transport/userregistration.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 <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 UserRegistrationTest : public CPPUNIT_NS :: TestFixture, public BasicTest {

	CPPUNIT_TEST_SUITE(UserRegistrationTest);

	CPPUNIT_TEST(getForm);

	CPPUNIT_TEST(getFormRegistered);

	CPPUNIT_TEST(registerUser);

	CPPUNIT_TEST(unregisterUser);

	CPPUNIT_TEST_SUITE_END();

	public:

		void setUp (void) {

			setMeUp();

			received.clear();

		}

		void tearDown (void) {

			received.clear();

			tearMeDown();

		}

		void getForm() {

			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", boost::shared_ptr<Swift::Payload>(new Swift::InBandRegistrationPayload()));

			iq->setFrom("user@localhost");

			injectIQ(iq);

			loop->processEvents();

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

			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));

			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());

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

			CPPUNIT_ASSERT_EQUAL(false, getStanza(received[0])->getPayload<Swift::InBandRegistrationPayload>()->isRegistered());

			CPPUNIT_ASSERT_EQUAL(std::string(""), *getStanza(received[0])->getPayload<Swift::InBandRegistrationPayload>()->getUsername());

			CPPUNIT_ASSERT_EQUAL(std::string(""), *getStanza(received[0])->getPayload<Swift::InBandRegistrationPayload>()->getPassword());

		}

		void getFormRegistered() {

			UserInfo user;

			user.id = -1;

			user.jid = "user@localhost";

			user.uin = "legacyname";

			user.password = "password";

			storage->setUser(user);

			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", boost::shared_ptr<Swift::Payload>(new Swift::InBandRegistrationPayload()));

			iq->setFrom("user@localhost");

			injectIQ(iq);

			loop->processEvents();

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

			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));

			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());

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

			CPPUNIT_ASSERT_EQUAL(true, getStanza(received[0])->getPayload<Swift::InBandRegistrationPayload>()->isRegistered());

			CPPUNIT_ASSERT_EQUAL(std::string("legacyname"), *getStanza(received[0])->getPayload<Swift::InBandRegistrationPayload>()->getUsername());

			CPPUNIT_ASSERT_EQUAL(std::string(""), *getStanza(received[0])->getPayload<Swift::InBandRegistrationPayload>()->getPassword());

		}

		void registerUser() {

			Swift::InBandRegistrationPayload *reg = new Swift::InBandRegistrationPayload();

			reg->setUsername("legacyname");

			reg->setPassword("password");

			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", boost::shared_ptr<Swift::Payload>(reg));

			iq->setFrom("user@localhost");

			injectIQ(iq);

			loop->processEvents();

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

			CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received[0])));

			CPPUNIT_ASSERT_EQUAL(Swift::Presence::Subscribe, dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getType());

			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[1])));

			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[1]))->getType());

			UserInfo user;

			CPPUNIT_ASSERT_EQUAL(true, storage->getUser("user@localhost", user));

			CPPUNIT_ASSERT_EQUAL(std::string("legacyname"), user.uin);

			CPPUNIT_ASSERT_EQUAL(std::string("password"), user.password);

		}

		void unregisterUser() {

			registerUser();

			received.clear();

			Swift::InBandRegistrationPayload *reg = new Swift::InBandRegistrationPayload();

			reg->setRemove(true);

			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", boost::shared_ptr<Swift::Payload>(reg));

			iq->setFrom("user@localhost");

			injectIQ(iq);

			loop->processEvents();

		}

};

CPPUNIT_TEST_SUITE_REGISTRATION (UserRegistrationTest);

/**

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

#include "transport/usermanager.h"

#include "transport/storagebackend.h"

#include "transport/transport.h"

#include "transport/rostermanager.h"

#include "transport/user.h"

#include "transport/logging.h"

#include "Swiften/Elements/ErrorPayload.h"

#include <boost/shared_ptr.hpp>

#include <boost/thread.hpp>

#include <boost/date_time/posix_time/posix_time.hpp>

#include <boost/regex.hpp> 

using namespace Swift;

namespace Transport {

DEFINE_LOGGER(logger, "UserRegistration");

UserRegistration::UserRegistration(Component *component, UserManager *userManager, StorageBackend *storageBackend) : Swift::Responder<Swift::InBandRegistrationPayload>(component->m_iqRouter) {

	m_component = component;

	m_config = m_component->m_config;

	m_storageBackend = storageBackend;

	m_userManager = userManager;

}

UserRegistration::~UserRegistration(){

}

bool UserRegistration::registerUser(const UserInfo &row) {

	UserInfo user;

	bool registered = m_storageBackend->getUser(row.jid, user);

	// This user is already registered

	if (registered)

		return false;

	m_storageBackend->setUser(row);

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

	response->setFrom(m_component->getJID());

	response->setTo(Swift::JID(row.jid));

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

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

	onUserRegistered(row);

	return true;

}

bool UserRegistration::unregisterUser(const std::string &barejid) {

	UserInfo userInfo;

	bool registered = m_storageBackend->getUser(barejid, userInfo);

	// This user is not registered

	if (!registered)

		return false;

	onUserUnregistered(userInfo);

	// We have to check if server supports remoteroster XEP and use it if it's supported or fallback to unsubscribe otherwise

	AddressedRosterRequest::ref request = AddressedRosterRequest::ref(new AddressedRosterRequest(m_component->getIQRouter(), barejid));

	request->onResponse.connect(boost::bind(&UserRegistration::handleUnregisterRemoteRosterResponse, this, _1, _2, barejid));

	request->send();

	return true;

}

void UserRegistration::handleUnregisterRemoteRosterResponse(boost::shared_ptr<Swift::RosterPayload> payload, Swift::ErrorPayload::ref remoteRosterNotSupported /*error*/, const std::string &barejid) {

	UserInfo userInfo;

	bool registered = m_storageBackend->getUser(barejid, userInfo);

	// This user is not registered

	if (!registered)

		return;

		std::list <BuddyInfo> roster;

		m_storageBackend->getBuddies(userInfo.id, roster);

		for(std::list<BuddyInfo>::iterator u = roster.begin(); u != roster.end() ; u++){

			std::string name = Swift::JID::getEscapedNode((*u).legacyName);

			Swift::Presence::ref response;

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

			response->setTo(Swift::JID(barejid));

			response->setFrom(Swift::JID(name, m_component->getJID().toString()));

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

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

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

			response->setTo(Swift::JID(barejid));

			response->setFrom(Swift::JID(name, m_component->getJID().toString()));

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

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

		}

	}

	else {

		BOOST_FOREACH(Swift::RosterItemPayload it, payload->getItems()) {

			Swift::RosterPayload::ref p = Swift::RosterPayload::ref(new Swift::RosterPayload());

			Swift::RosterItemPayload item;

			item.setJID(it.getJID());

			item.setSubscription(Swift::RosterItemPayload::Remove);

			p->addItem(item);

			Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(p, barejid, m_component->getIQRouter());

			request->send();

		}

	}

	// Remove user from database

	m_storageBackend->removeUser(userInfo.id);

	// Disconnect the user

	User *user = m_userManager->getUser(barejid);

	if (user) {

		m_userManager->removeUser(user);

	}

		Swift::Presence::ref response;

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

		response->setTo(Swift::JID(barejid));

		response->setFrom(m_component->getJID());

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

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

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

		response->setTo(Swift::JID(barejid));

		response->setFrom(m_component->getJID());

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

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

	}

	else {

		Swift::RosterPayload::ref payload = Swift::RosterPayload::ref(new Swift::RosterPayload());

		Swift::RosterItemPayload item;

		item.setJID(m_component->getJID());

		item.setSubscription(Swift::RosterItemPayload::Remove);

		payload->addItem(item);

		Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(payload, barejid, m_component->getIQRouter());

		request->send();

	}

}

bool UserRegistration::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::InBandRegistrationPayload> payload) {

	// TODO: backend should say itself if registration is needed or not...

	if (CONFIG_STRING(m_config, "service.protocol") == "irc") {

		sendError(from, id, ErrorPayload::BadRequest, ErrorPayload::Modify);

		return true;

	}

	std::string barejid = from.toBare().toString();

	if (!CONFIG_BOOL(m_config,"registration.enable_public_registration")) {

		std::vector<std::string> const &x = CONFIG_VECTOR(m_config,"service.allowed_servers");

		if (std::find(x.begin(), x.end(), from.getDomain()) == x.end()) {

			LOG4CXX_INFO(logger, barejid << ": This user has no permissions to register an account")

			sendError(from, id, ErrorPayload::BadRequest, ErrorPayload::Modify);

			return true;

		}

	}

	boost::shared_ptr<InBandRegistrationPayload> reg(new InBandRegistrationPayload());

	UserInfo res;

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

	std::string instructions = CONFIG_STRING(m_config, "registration.instructions");

	std::string usernameField = CONFIG_STRING(m_config, "registration.username_label");

	// normal jabber:iq:register

	reg->setInstructions(instructions);

	reg->setRegistered(registered);

	reg->setUsername(res.uin);

	if (CONFIG_STRING(m_config, "service.protocol") != "twitter" && CONFIG_STRING(m_config, "service.protocol") != "bonjour")

		reg->setPassword("");

	// form

	Form::ref form(new Form(Form::FormType));

	form->setTitle((("Registration")));

	form->setInstructions((instructions));

	HiddenFormField::ref type = HiddenFormField::create();

	type->setName("FORM_TYPE");

	type->setValue("jabber:iq:register");

	form->addField(type);

	TextSingleFormField::ref username = TextSingleFormField::create();

	username->setName("username");

	username->setLabel((usernameField));

	username->setValue(res.uin);

	username->setRequired(true);

	form->addField(username);

	if (CONFIG_STRING(m_config, "service.protocol") != "twitter" && CONFIG_STRING(m_config, "service.protocol") != "bonjour") {

		TextPrivateFormField::ref password = TextPrivateFormField::create();

		password->setName("password");

		password->setLabel((("Password")));

		password->setRequired(true);

		form->addField(password);

	}

	ListSingleFormField::ref language = ListSingleFormField::create();

	language->setName("language");

	language->setLabel((("Language")));

	language->addOption(Swift::FormField::Option(CONFIG_STRING(m_config, "registration.language"), CONFIG_STRING(m_config, "registration.language")));

	if (registered)

		language->setValue(res.language);

	else

		language->setValue(CONFIG_STRING(m_config, "registration.language"));

	form->addField(language);

//	TextSingleFormField::ref encoding = TextSingleFormField::create();

//	encoding->setName("encoding");