/*

* Copyright (c) 2014 Remko Tronçon

* Licensed under the GNU General Public License.

* See the COPYING file for more information.

*/

#include <Sluift/ElementConvertors/StatusShowConvertor.h>

#include <lua.hpp>

#include <boost/smart_ptr/make_shared.hpp>

#include <boost/numeric/conversion/cast.hpp>

#include <Sluift/Lua/Check.h>

#include <Sluift/Lua/Exception.h>

using namespace Swift;

StatusShowConvertor::StatusShowConvertor() : GenericLuaElementConvertor<StatusShow>("show") {

}

StatusShowConvertor::~StatusShowConvertor() {

}

boost::shared_ptr<StatusShow> StatusShowConvertor::doConvertFromLua(lua_State* L) {

boost::shared_ptr<StatusShow> result = boost::make_shared<StatusShow>();

lua_getfield(L, -1, "type");

if (lua_isstring(L, -1)) {

result->setType(convertStatusShowTypeFromString(lua_tostring(L, -1)));

}

lua_pop(L, 1);

return result;

}

void StatusShowConvertor::doConvertToLua(lua_State* L, boost::shared_ptr<StatusShow> payload) {

lua_createtable(L, 0, 0);

if (!show.empty()) {

lua_pushstring(L, show.c_str());

lua_setfield(L, -2, "type");

}

}

std::string StatusShowConvertor::convertStatusShowTypeToString(const StatusShow::Type &show) {

switch (show) {

}

assert(false);

return "";

}

StatusShow::Type StatusShowConvertor::convertStatusShowTypeFromString(const std::string& show) {

if (show == "online") {

return StatusShow::Online;

}

else if (show == "ffc") {

return StatusShow::FFC;

}

else if (show == "away") {

return StatusShow::Away;

}

else if (show == "xa") {

return StatusShow::XA;

}

else if (show == "dnd") {

return StatusShow::DND;

}

else {

throw Lua::Exception("Illegal status show: '" + show + "'");

}

}

/*

* Copyright (c) 2013-2014 Kevin Smith and Remko Tronçon

* Licensed under the GNU General Public License.

* See the COPYING file for more information.

*/

#include <Sluift/Helpers.h>

#include <Swiften/Client/ClientError.h>

#include <Swiften/Component/ComponentError.h>

using namespace Swift;

std::string Swift::getErrorString(const ClientError& error) {

switch(error.getType()) {

case ClientError::DomainNameResolveError: reason += "Unable to find server"; break;

case ClientError::CompressionFailedError: reason += "Error while compressing stream"; break;

case ClientError::ServerVerificationFailedError: reason += "Server verification failed"; break;

case ClientError::NoSupportedAuthMechanismsError: reason += "Authentication mechanisms not supported"; break;

case ClientError::ResourceBindError: reason += "Error binding resource"; break;

case ClientError::RevokedError: reason += "Certificate got revoked"; break;

case ClientError::RevocationCheckFailedError: reason += "Failed to do revokation check"; break;

case ClientError::SessionStartError: reason += "Error starting session"; break;

case ClientError::StreamError: reason += "Stream error"; break;

case ClientError::TLSError: reason += "Encryption error"; break;

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

case ClientError::ClientCertificateError: reason += "Certificate not authorized"; break;

case ClientError::UnknownCertificateError: reason += "Unknown certificate"; break;

case ClientError::CertificateCardRemoved: reason += "Certificate card removed"; break;

case ClientError::CertificateExpiredError: reason += "Certificate has expired"; break;

case ClientError::CertificateNotYetValidError: reason += "Certificate is not yet valid"; break;

case ClientError::CertificateSelfSignedError: reason += "Certificate is self-signed"; break;

case ClientError::CertificateRejectedError: reason += "Certificate has been rejected"; break;

case ClientError::CertificateUntrustedError: reason += "Certificate is not trusted"; break;

case ClientError::InvalidCertificatePurposeError: reason += "Certificate cannot be used for encrypting your connection"; break;

case ClientError::CertificatePathLengthExceededError: reason += "Certificate path length constraint exceeded"; break;

case ClientError::InvalidCertificateSignatureError: reason += "Invalid certificate signature"; break;

case ClientError::InvalidCAError: reason += "Invalid Certificate Authority"; break;

case ClientError::InvalidServerIdentityError: reason += "Certificate does not match the host identity"; break;

}

return reason;

}

std::string Swift::getErrorString(const ComponentError& error) {

}

/*

* Copyright (c) 2013-2014 Kevin Smith and Remko Tronçon

* Licensed under the GNU General Public License.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Base/API.h>

#include <string>

namespace Swift {

class ClientError;

class ComponentError;

std::string getErrorString(const ClientError& error);

std::string getErrorString(const ComponentError& error);

}

void SluiftComponent::setTraceEnabled(bool b) {

if (b && !tracer) {

tracer = new ComponentXMLTracer(component);

}

else if (!b && tracer) {

delete tracer;

tracer = NULL;

}

}

void SluiftComponent::waitConnected(int timeout) {

Watchdog watchdog(timeout, networkFactories->getTimerFactory());

while (!watchdog.getTimedOut() && !disconnectedError && !component->isAvailable()) {

eventLoop->runUntilEvents();

}

if (watchdog.getTimedOut()) {

component->disconnect();

throw Lua::Exception("Timeout while connecting");

}

if (disconnectedError) {

throw Lua::Exception(getErrorString(*disconnectedError));

}

}

bool SluiftComponent::isConnected() const {

return component->isAvailable();

}

void SluiftComponent::disconnect() {

component->disconnect();

while (component->isAvailable()) {

eventLoop->runUntilEvents();

}

}

component->setSoftwareVersion(name, version);

}

boost::optional<SluiftComponent::Event> SluiftComponent::getNextEvent(

int timeout, boost::function<bool (const Event&)> condition) {

Watchdog watchdog(timeout, networkFactories->getTimerFactory());

size_t currentIndex = 0;

while (true) {

// Look for pending events in the queue

while (currentIndex < pendingEvents.size()) {

Event event = pendingEvents[currentIndex];

if (!condition || condition(event)) {

pendingEvents.erase(

pendingEvents.begin()

+ boost::numeric_cast<int>(currentIndex));

return event;

}

++currentIndex;

}

// Wait for new events

while (!watchdog.getTimedOut() && currentIndex >= pendingEvents.size() && component->isAvailable()) {

eventLoop->runUntilEvents();

}

// Finish if we're disconnected or timed out

if (watchdog.getTimedOut() || !component->isAvailable()) {

return boost::optional<Event>();

}

}

}

void SluiftComponent::handleIncomingMessage(boost::shared_ptr<Message> stanza) {

pendingEvents.push_back(Event(stanza));

}

bool isConnected() const;

void setTraceEnabled(bool b);

template<typename REQUEST_TYPE>

Sluift::Response sendRequest(REQUEST_TYPE request, int timeout) {

boost::signals::scoped_connection c = request->onResponse.connect(

boost::bind(&SluiftComponent::handleRequestResponse, this, _1, _2));

return doSendRequest(request, timeout);

}

template<typename REQUEST_TYPE>

Sluift::Response sendVoidRequest(REQUEST_TYPE request, int timeout) {

boost::signals::scoped_connection c = request->onResponse.connect(

boost::bind(&SluiftComponent::handleRequestResponse, this, boost::shared_ptr<Payload>(), _1));

return doSendRequest(request, timeout);

}

void disconnect();

void setSoftwareVersion(const std::string& name, const std::string& version, const std::string& os);

boost::optional<SluiftComponent::Event> getNextEvent(int timeout,

boost::function<bool (const Event&)> condition = 0);

private:

Sluift::Response doSendRequest(boost::shared_ptr<Request> request, int timeout);

void handleIncomingMessage(boost::shared_ptr<Message> stanza);

void handleIncomingPresence(boost::shared_ptr<Presence> stanza);

void handleRequestResponse(boost::shared_ptr<Payload> response, boost::shared_ptr<ErrorPayload> error);

void handleError(const boost::optional<ComponentError>& error);

private:

NetworkFactories* networkFactories;

SimpleEventLoop* eventLoop;

Component* component;

ComponentXMLTracer* tracer;

std::deque<Event> pendingEvents;

boost::optional<ComponentError> disconnectedError;

bool requestResponseReceived;

boost::shared_ptr<Payload> requestResponse;

boost::shared_ptr<ErrorPayload> requestError;

};

}

}

}

void ChatsManager::handleMUCBookmarkAdded(const MUCBookmark& bookmark) {

std::map<JID, MUCController*>::iterator it = mucControllers_.find(bookmark.getRoom());

if (it == mucControllers_.end() && bookmark.getAutojoin()) {

handleJoinMUCRequest(bookmark.getRoom(), bookmark.getPassword(), bookmark.getNick(), false, false, false );

}

chatListWindow_->addMUCBookmark(bookmark);

}

void ChatsManager::handleMUCBookmarkRemoved(const MUCBookmark& bookmark) {

chatListWindow_->removeMUCBookmark(bookmark);

}

ChatListWindow::Chat ChatsManager::createChatListChatItem(const JID& jid, const std::string& activity, bool privateMessage) {

int unreadCount = 0;

if (mucRegistry_->isMUC(jid)) {

MUCController* controller = mucControllers_[jid.toBare()];

StatusShow::Type type = StatusShow::None;

std::string nick = "";

std::string password = "";

if (controller) {

unreadCount = controller->getUnreadCount();

if (controller->isJoined()) {

type = StatusShow::Online;

}

nick = controller->getNick();

if (controller->getPassword()) {

password = *controller->getPassword();

}

if (controller->isImpromptu()) {

ChatListWindow::Chat chat = ChatListWindow::Chat(jid, jid.toString(), activity, unreadCount, type, boost::filesystem::path(), true, privateMessage, nick, password);

std::map<std::string, JID> participants = controller->getParticipantJIDs();

chat.impromptuJIDs = participants;

return chat;

}

}

return ChatListWindow::Chat(jid, jid.toString(), activity, unreadCount, type, boost::filesystem::path(), true, privateMessage, nick, password);

} else {

ChatController* controller = getChatControllerIfExists(jid, false);

if (controller) {

unreadCount = controller->getUnreadCount();

}

JID bareishJID = mucRegistry_->isMUC(jid.toBare()) ? jid : jid.toBare();

Presence::ref presence = presenceOracle_->getHighestPriorityPresence(bareishJID);

StatusShow::Type type = presence ? presence->getShow() : StatusShow::None;

boost::filesystem::path avatarPath = avatarManager_ ? avatarManager_->getAvatarPath(bareishJID) : boost::filesystem::path();

return ChatListWindow::Chat(bareishJID, nickResolver_->jidToNick(bareishJID), activity, unreadCount, type, avatarPath, false, privateMessage);

}

}

void ChatsManager::handleChatActivity(const JID& jid, const std::string& activity, bool isMUC) {

const bool privateMessage = mucRegistry_->isMUC(jid.toBare()) && !isMUC;

ChatListWindow::Chat chat = createChatListChatItem(jid, activity, privateMessage);

/* FIXME: handle nick changes */

appendRecent(chat);

handleUnreadCountChanged(NULL);

saveRecents();

}

void ChatsManager::handleChatClosed(const JID& /*jid*/) {

cleanupPrivateMessageRecents();

chatListWindow_->setRecents(recentChats_);

}

void ChatsManager::handleUnreadCountChanged(ChatControllerBase* controller) {

int unreadTotal = 0;