/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <deque>

#include <boost/optional.hpp>

#include <boost/bind.hpp>

#include <boost/function.hpp>

#include <Swiften/Client/ClientOptions.h>

#include <Swiften/Elements/IQ.h>

#include <Swiften/Elements/Message.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Queries/GenericRequest.h>

#include <Swiften/Roster/XMPPRosterItem.h>

#include <Swiften/Client/ClientError.h>

#include <Swiften/Network/NetworkFactories.h>

#include <Swiften/Client/Client.h>

#include <Swiften/EventLoop/SimpleEventLoop.h>

#include <Sluift/Watchdog.h>

#include <Swiften/PubSub/PubSubManager.h>

#include <Sluift/Response.h>

namespace Swift {

struct SluiftGlobals;

class ClientXMLTracer;

class Client;

class Stanza;

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

void waitConnected(int timeout);

bool isConnected() const;

void setTraceEnabled(bool b);

template<typename T>

Sluift::Response sendPubSubRequest(

IQ::Type type, const JID& jid, boost::shared_ptr<T> payload, int timeout) {

return sendRequest(client->getPubSubManager()->createRequest(

type, jid, payload), timeout);

}

template<typename REQUEST_TYPE>

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

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

boost::bind(&SluiftClient::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(&SluiftClient::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<SluiftClient::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 handleIncomingPubSubEvent(const JID& from, boost::shared_ptr<PubSubEventPayload> event);

void handleInitialRosterPopulated();

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

void handleDisconnected(const boost::optional<ClientError>& error);

private:

NetworkFactories* networkFactories;

SimpleEventLoop* eventLoop;

Client* client;

ClientOptions options;

ClientXMLTracer* tracer;

bool rosterReceived;

std::deque<Event> pendingEvents;

boost::optional<ClientError> disconnectedError;

bool requestResponseReceived;

boost::shared_ptr<Payload> requestResponse;

boost::shared_ptr<ErrorPayload> requestError;

};

}