#include <Sluift/ElementConvertors/SoftwareVersionConvertor.h>

#include <Sluift/ElementConvertors/VCardUpdateConvertor.h>

#include <Sluift/ElementConvertors/VCardConvertor.h>

#include <Sluift/ElementConvertors/BodyConvertor.h>

#include <Sluift/ElementConvertors/CommandConvertor.h>

#include <Sluift/ElementConvertors/StatusShowConvertor.h>

#include <Sluift/ElementConvertors/StatusConvertor.h>

#include <Sluift/ElementConvertors/DelayConvertor.h>

#include <Sluift/ElementConvertors/IQConvertor.h>

#include <Sluift/ElementConvertors/PresenceConvertor.h>

#include <Sluift/ElementConvertors/MessageConvertor.h>

#include <Sluift/ElementConvertors/ResultSetConvertor.h>

#include <Sluift/ElementConvertors/ForwardedConvertor.h>

#include <Sluift/ElementConvertors/MAMResultConvertor.h>

#include <Sluift/ElementConvertors/MAMQueryConvertor.h>

#include <Sluift/ElementConvertors/MAMArchivedConvertor.h>

#include <Sluift/Lua/LuaUtils.h>

#include <Sluift/Lua/Exception.h>

using namespace Swift;

LuaElementConvertors::LuaElementConvertors() {

registerConvertors();

convertors.push_back(boost::make_shared<StatusConvertor>());

convertors.push_back(boost::make_shared<StatusShowConvertor>());

convertors.push_back(boost::make_shared<DelayConvertor>());

convertors.push_back(boost::make_shared<CommandConvertor>(this));

convertors.push_back(boost::make_shared<PubSubEventConvertor>(this));

convertors.push_back(boost::make_shared<BodyConvertor>());

convertors.push_back(boost::make_shared<VCardConvertor>());

convertors.push_back(boost::make_shared<VCardUpdateConvertor>());

convertors.push_back(boost::make_shared<FormConvertor>());

convertors.push_back(boost::make_shared<SoftwareVersionConvertor>());

convertors.push_back(boost::make_shared<DiscoInfoConvertor>());

convertors.push_back(boost::make_shared<DiscoItemsConvertor>());

convertors.push_back(boost::make_shared<IQConvertor>(this));

convertors.push_back(boost::make_shared<PresenceConvertor>(this));

convertors.push_back(boost::make_shared<MessageConvertor>(this));

convertors.push_back(boost::make_shared<ResultSetConvertor>(this));

convertors.push_back(boost::make_shared<ForwardedConvertor>(this));

convertors.push_back(boost::make_shared<MAMResultConvertor>(this));

convertors.push_back(boost::make_shared<MAMQueryConvertor>(this));

convertors.push_back(boost::make_shared<MAMArchivedConvertor>(this));

}

LuaElementConvertors::~LuaElementConvertors() {

}

#include <Sluift/ElementConvertors/ElementConvertors.ipp>

boost::shared_ptr<Element> LuaElementConvertors::convertFromLua(lua_State* L, int index) {

if (lua_isstring(L, index)) {

return convertFromLuaUntyped(L, index, "xml");

}

else if (lua_istable(L, index)) {

lua_getfield(L, index, "_type");

if (lua_isstring(L, -1)) {

std::string type = lua_tostring(L, -1);

lua_pop(L, 1);

return convertFromLuaUntyped(L, index, type);

}

lua_pop(L, 1);

}

throw Lua::Exception("Unable to determine type");

}

boost::shared_ptr<Element> LuaElementConvertors::convertFromLuaUntyped(lua_State* L, int index, const std::string& type) {

index = Lua::absoluteOffset(L, index);

foreach (boost::shared_ptr<LuaElementConvertor> convertor, convertors) {

if (boost::shared_ptr<Element> result = convertor->convertFromLua(L, index, type)) {

return result;

}

}

return boost::shared_ptr<Element>();

}

int LuaElementConvertors::convertToLua(lua_State* L, boost::shared_ptr<Element> payload) {

client->getOptions().useTLS = (useTLS ? ClientOptions::UseTLSWhenAvailable : ClientOptions::NeverUseTLS);

}

lua_getfield(L, 2, "bosh_url");

if (!lua_isnil(L, -1)) {

client->getOptions().boshURL = URL::fromString(lua_tostring(L, -1));

}

lua_getfield(L, 2, "allow_plain_without_tls");

if (!lua_isnil(L, -1)) {

client->getOptions().allowPLAINWithoutTLS = lua_toboolean(L, -1);

}

lua_pushvalue(L, 1);

return 0;

}

SLUIFT_LUA_FUNCTION_WITH_HELP(

Client, send_mam_query,

"Builds and sends a MAM query.\n",

"self\n"

"mam_query parameters for the query\n"

"jid optional jid to set in the 'to' field of the IQ stanza",

"See help('MAMQuery') for details."

) {

if (!lua_istable(L, 2)) {

throw Lua::Exception("Missing MAMQuery");

}

if (boost::shared_ptr<MAMQuery> mamQuery = boost::dynamic_pointer_cast<MAMQuery>(Sluift::globals.elementConvertor.convertFromLuaUntyped(L, 2, "mam_query"))) {

IQRouter *router = getClient(L)->getClient()->getIQRouter();

JID jid;

lua_getfield(L, 2, "jid");

if (!lua_isnil(L, -1)) {

jid = JID(lua_tostring(L, -1));

}

}

else {

throw Lua::Exception("Illegal MAMQuery");

}

return 0;

}

static void pushEvent(lua_State* L, const SluiftClient::Event& event) {

switch (event.type) {

case SluiftClient::Event::MessageType: {

Message::ref message = boost::dynamic_pointer_cast<Message>(event.stanza);

Lua::Table result = boost::assign::map_list_of

("type", boost::make_shared<Lua::Value>(std::string("message")))

("from", boost::make_shared<Lua::Value>(message->getFrom().toString()))

("body", boost::make_shared<Lua::Value>(message->getBody()))

("message_type", boost::make_shared<Lua::Value>(MessageConvertor::convertMessageTypeToString(message->getType())));

Lua::pushValue(L, result);

addPayloadsToTable(L, message->getPayloads());

Lua::registerTableToString(L, -1);

break;

}

case SluiftClient::Event::PresenceType: {

Presence::ref presence = boost::dynamic_pointer_cast<Presence>(event.stanza);

Lua::Table result = boost::assign::map_list_of

("type", boost::make_shared<Lua::Value>(std::string("presence")))

("from", boost::make_shared<Lua::Value>(presence->getFrom().toString()))

("status", boost::make_shared<Lua::Value>(presence->getStatus()))

("presence_type", boost::make_shared<Lua::Value>(PresenceConvertor::convertPresenceTypeToString(presence->getType())));

Lua::pushValue(L, result);

addPayloadsToTable(L, presence->getPayloads());

Lua::registerTableToString(L, -1);

break;

}

case SluiftClient::Event::PubSubEventType: {

Sluift::globals.elementConvertor.convertToLua(L, event.pubsubEvent);