#include <boost/lambda/bind.hpp>

#include <boost/assign/list_of.hpp>

#include <iostream>

#include <Sluift/SluiftClient.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Elements/SoftwareVersion.h>

#include <Swiften/Elements/Message.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Elements/RawXMLPayload.h>

#include <Swiften/Elements/RosterItemPayload.h>

#include <Swiften/Elements/RosterPayload.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/MAMQuery.h>

#include <Swiften/Disco/ClientDiscoManager.h>

#include <Swiften/Queries/GenericRequest.h>

#include <Swiften/Presence/PresenceSender.h>

#include <Swiften/Roster/XMPPRoster.h>

#include <Swiften/Roster/SetRosterRequest.h>

#include <Swiften/Presence/SubscriptionManager.h>

#include <Swiften/Roster/XMPPRosterItem.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/Queries/Requests/GetSoftwareVersionRequest.h>

#include <Sluift/Lua/FunctionRegistration.h>

#include <Swiften/Base/foreach.h>

#include <Swiften/Base/IDGenerator.h>

#include <Sluift/Lua/Check.h>

#include <Sluift/Lua/Value.h>

#include <Sluift/Lua/Exception.h>

#include <Sluift/Lua/LuaUtils.h>

#include <Sluift/globals.h>

#include <Sluift/ElementConvertors/StanzaConvertor.h>

#include <Sluift/ElementConvertors/IQConvertor.h>

#include <Sluift/ElementConvertors/PresenceConvertor.h>

#include <Sluift/ElementConvertors/MessageConvertor.h>

using namespace Swift;

namespace lambda = boost::lambda;

static inline SluiftClient* getClient(lua_State* L) {

return *Lua::checkUserData<SluiftClient>(L, 1);

}

static inline int getGlobalTimeout(lua_State* L) {

lua_rawgeti(L, LUA_REGISTRYINDEX, Sluift::globals.moduleLibIndex);

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

int result = boost::numeric_cast<int>(lua_tointeger(L, -1));

lua_pop(L, 2);

return result;

}

static void addPayloadsToTable(lua_State* L, const std::vector<boost::shared_ptr<Payload> >& payloads) {

if (!payloads.empty()) {

lua_createtable(L, boost::numeric_cast<int>(payloads.size()), 0);

for (size_t i = 0; i < payloads.size(); ++i) {

Sluift::globals.elementConvertor.convertToLua(L, payloads[i]);

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

}

Lua::registerGetByTypeIndex(L, -1);

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

}

}

static boost::shared_ptr<Payload> getPayload(lua_State* L, int index) {

if (lua_type(L, index) == LUA_TTABLE) {

return boost::dynamic_pointer_cast<Payload>(Sluift::globals.elementConvertor.convertFromLua(L, index));

}

else if (lua_type(L, index) == LUA_TSTRING) {

return boost::make_shared<RawXMLPayload>(Lua::checkString(L, index));

}

subject = value;

}

payloads = getPayloadsFromTable(L, index);

}

if (!to.isValid()) {

throw Lua::Exception("Missing 'to'");

}

if ((!body || body->empty()) && !subject && payloads.empty()) {

throw Lua::Exception("Missing any of 'body', 'subject' or 'payloads'");

}

Message::ref message = boost::make_shared<Message>();

message->setTo(to);

if (body && !body->empty()) {

message->setBody(*body);

}

if (subject) {

message->setSubject(*subject);

}

message->addPayloads(payloads.begin(), payloads.end());

message->setType(type);

getClient(L)->getClient()->sendMessage(message);

return 0;

}

SLUIFT_LUA_FUNCTION_WITH_HELP(

Client, send_presence,

"Send presence.",

"self\n"

"body the text of the presence. Can alternatively be specified using the `status` option\n",

"to the JID to send the message to\n"

"status the text of the presence\n"

"priority the priority of the presence\n"

"type the type of message to send (`available`, `error`, `probe`, `subscribe`, `subscribed`, `unavailable`, `unsubscribe`, `unsubscribed`)\n"

"payloads payloads to add to the presence\n"

) {

Sluift::globals.eventLoop.runOnce();

boost::shared_ptr<Presence> presence = boost::make_shared<Presence>();

int index = 2;

if (lua_isstring(L, index)) {

presence->setStatus(lua_tostring(L, index));

++index;

}

if (lua_istable(L, index)) {

if (boost::optional<std::string> value = Lua::getStringField(L, index, "to")) {

presence->setTo(*value);

}

if (boost::optional<std::string> value = Lua::getStringField(L, index, "status")) {

presence->setStatus(*value);

}

if (boost::optional<int> value = Lua::getIntField(L, index, "priority")) {

presence->setPriority(*value);

}

if (boost::optional<std::string> value = Lua::getStringField(L, index, "type")) {

presence->setType(PresenceConvertor::convertPresenceTypeFromString(*value));

}

std::vector< boost::shared_ptr<Payload> > payloads = getPayloadsFromTable(L, index);

presence->addPayloads(payloads.begin(), payloads.end());

}

getClient(L)->getClient()->getPresenceSender()->sendPresence(presence);

lua_pushvalue(L, 1);

return 0;

}

static int sendQuery(lua_State* L, IQ::Type type) {

SluiftClient* client = getClient(L);

JID to;

if (boost::optional<std::string> toString = Lua::getStringField(L, 2, "to")) {

to = JID(*toString);

}

int timeout = getGlobalTimeout(L);

if (boost::optional<int> timeoutInt = Lua::getIntField(L, 2, "timeout")) {

timeout = *timeoutInt;

}

boost::shared_ptr<Payload> payload;

lua_getfield(L, 2, "query");

payload = getPayload(L, -1);

lua_pop(L, 1);

return client->sendRequest(

boost::make_shared< GenericRequest<Payload> >(type, to, payload, client->getClient()->getIQRouter()), timeout).convertToLuaResult(L);

}

#define DISPATCH_PUBSUB_PAYLOAD(payloadType, container, response) \

else if (boost::shared_ptr<payloadType> p = boost::dynamic_pointer_cast<payloadType>(payload)) { \

return client->sendPubSubRequest(type, to, p, timeout).convertToLuaResult(L); \

}