/*

* Licensed under the GNU General Public License.

* See the COPYING file for more information.

*/

#include <Sluift/SluiftClient.h>

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

#include <Swiften/Client/ClientXMLTracer.h>

#include <Swiften/Client/Client.h>

#include <Swiften/Roster/XMPPRoster.h>

#include <Sluift/SluiftGlobals.h>

#include <Sluift/Lua/Exception.h>

#include <Swiften/Elements/Message.h>

#include <Swiften/Elements/PubSubEvent.h>

#include <Swiften/Queries/RawRequest.h>

#include <Swiften/Elements/Presence.h>

using namespace Swift;

SluiftClient::SluiftClient(

const JID& jid,

const std::string& password,

NetworkFactories* networkFactories,

SimpleEventLoop* eventLoop) :

networkFactories(networkFactories),

eventLoop(eventLoop),

tracer(NULL) {

client = new Client(jid, password, networkFactories);

client->setAlwaysTrustCertificates();

client->onDisconnected.connect(boost::bind(&SluiftClient::handleDisconnected, this, _1));

client->onMessageReceived.connect(boost::bind(&SluiftClient::handleIncomingMessage, this, _1));

client->onPresenceReceived.connect(boost::bind(&SluiftClient::handleIncomingPresence, this, _1));

client->getPubSubManager()->onEvent.connect(boost::bind(&SluiftClient::handleIncomingPubSubEvent, this, _1, _2));

client->getRoster()->onInitialRosterPopulated.connect(boost::bind(&SluiftClient::handleInitialRosterPopulated, this));

}

SluiftClient::~SluiftClient() {

delete tracer;

delete client;

}

void SluiftClient::connect() {

rosterReceived = false;

disconnectedError = boost::optional<ClientError>();

client->connect(options);

}

void SluiftClient::connect(const std::string& host, int port) {

rosterReceived = false;

options.manualHostname = host;

options.manualPort = port;

disconnectedError = boost::optional<ClientError>();

client->connect(options);

}

void SluiftClient::setTraceEnabled(bool b) {

if (b && !tracer) {

tracer = new ClientXMLTracer(client, options.boshURL.isEmpty()? false: true);

}

else if (!b && tracer) {

delete tracer;

tracer = NULL;

}

}

void SluiftClient::waitConnected(int timeout) {

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

while (!watchdog.getTimedOut() && client->isActive() && !client->isAvailable()) {

eventLoop->runUntilEvents();

}

if (watchdog.getTimedOut()) {

client->disconnect();

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

}

if (disconnectedError) {

}

}

bool SluiftClient::isConnected() const {

return client->isAvailable();

}

void SluiftClient::disconnect() {

client->disconnect();

while (client->isActive()) {

eventLoop->runUntilEvents();

}

}

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

client->setSoftwareVersion(name, version, os);

}

boost::optional<SluiftClient::Event> SluiftClient::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;

}