--[[
	Copyright (c) 2013 Remko Tronçon
	Licensed under the GNU General Public License.
	See the COPYING file for more information.
--]]

local sluift = select(1, ...)
local _G = _G
local pairs, ipairs, print, tostring, type, error, assert, next, rawset, xpcall, unpack = pairs, ipairs, print, tostring, type, error, assert, next, rawset, xpcall, unpack
local setmetatable, getmetatable = setmetatable, getmetatable
local string = require "string"
local table = require "table"
local debug = require "debug"
_ENV = nil

--------------------------------------------------------------------------------
-- Table utility methods
--------------------------------------------------------------------------------

local function table_value_tostring(value)
	local result = tostring(value)
	if type(value) == 'number' then return result
	elseif type(value) == 'boolean' then return result
	elseif type(value) == 'string' then return "'" .. result .. "'"
	else return '<' .. result .. '>'
	end
end

local function table_tostring(table, print_functions, indent, accumulator, history)
	local INDENT = '  '
	local accumulator = accumulator or ''
	local history = history or {}
	local indent = indent or ''
	accumulator = accumulator .. '{'
	history[table] = true
	local is_first = true
	for key, value in pairs(table) do
		if print_functions or type(value) ~= 'function' then
			if not is_first then
				accumulator = accumulator .. ','
			end
			is_first = false
			accumulator = accumulator .. '\n' .. indent .. INDENT .. '[' .. table_value_tostring(key) .. '] = '
			if type(value) == 'table' then
				if history[value] then
					accumulator = accumulator .. "..."
				else
					accumulator = table_tostring(value, print_functions, indent .. INDENT, accumulator, history)
				end
			else
				accumulator = accumulator .. table_value_tostring(value)
			end
		end
	end
	history[table] = false
	if not is_first then
		accumulator = accumulator .. '\n' .. indent
	end
	accumulator = accumulator .. '}'
	return accumulator
end

local function register_table_tostring(table, print_functions)
	if type(table) == 'table' then
		local metatable = getmetatable(table)
		if not metatable then
			metatable = {}
			setmetatable(table, metatable)
		end
		if print_functions then
			metatable.__tostring = function(table) return table_tostring(table, true) end
		else
			metatable.__tostring = table_tostring
		end
	end
end

-- FIXME: Not really a good or efficiant equals, but does the trick for now
local function table_equals(t1, t2) 
	return tostring(t1) == tostring(t2) 
end

local function register_table_equals(table)
	if type(table) == 'table' then
		local metatable = getmetatable(table)
		if not metatable then
			metatable = {}
			setmetatable(table, metatable)
		end
		metatable.__eq = table_equals
	end
end

local function merge_tables(...)
	local result = {}
	for _, table in ipairs({...}) do
		for k, v in pairs(table) do
			result[k] = v
		end
	end
	return result
end

local function copy(object)
	if type(object) == 'table' then
		local copy = {}
		for key, value in pairs(object) do
			copy[key] = value
		end
		return copy
	else
		return object
	end
end

local function clear(table)
	setmetatable(table, nil)
	for key, value in pairs(table) do
		rawset(table, key, nil)
	end
end

local function trim(string)
	return string:gsub("^%s*(.-)%s*$", "%1")
end

local function keys(table)
	local result = {}
	for key in pairs(table) do
		result[#result+1] = key
	end
	return result
end

local function insert_all(table, values)
	for _, value in pairs(values) do
		table[#table+1] = value
	end
end

--------------------------------------------------------------------------------
-- Help
--------------------------------------------------------------------------------

-- Contains help for native methods that we want access to from here
local extra_help = {}
local help_data = {}
local help_classes = {}
local help_class_metatables = {}

local _H

local function get_synopsis(description) 
	return description:gsub("[\n\r].*", "")
end

local function format_description(text)
	local result = {}
	local trim_whitespace
	for line in (text .. "\n"):gmatch"(.-)\n" do
		if not trim_whitespace and line:find('[^%s]') then
			trim_whitespace = line:match("^(%s*)")
		end
		if trim_whitespace then
			line = line:gsub("^" .. trim_whitespace, "")
		end
		table.insert(result, line)
	end
	return trim(table.concat(result, "\n"))
end

local function strip_links(text)
	return text:gsub("(@{(%w*)})", "`%2`")
end

local function register_help(target, help) 
	assert(target)
	if not help then
		help = _H
	end
	assert(help)

	-- Transform description into canonical representation
	local parameters = {}
	for _, parameter in pairs(help.parameters or {}) do
		local parameter_description = parameter[2]
		if parameter_description and #parameter_description == 0 then
			parameter_description = nil
		end
		if type(parameter) == "table" then
			parameters[#parameters+1] = { name = parameter[1], description = parameter_description }
		else
			parameters[#parameters+1] = { name = parameter }
		end
	end
	local options = {}
	for option_name, option_description in pairs(help.options or {}) do
		if type(option_description) == "table" then
			options[#options+1] = { name = option_description.name, description = option_description.description }
		else
			options[#options+1] = { name = option_name, description = option_description }
		end
	end
	local description = format_description(help[1] or help.description or "")
	local synopsis = get_synopsis(description)
	if #description == 0 then
		synopsis = nil
		description = nil
	end
	local data = {
		description = description,
		synopsis = synopsis,
		parameters = parameters,
		options = options,
		classes = help.classes
	}
	register_table_tostring(data, true)
	help_data[target] = data
end

local function register_class_help(class, help)
	help_classes[#help_classes+1] = class
	register_help(class, help)
end

local function register_class_table_help(target, class, help)
	register_help(target, help)
	help_class_metatables[class] = target
	register_class_help(class, help)
end

_H = {
	[[ 
		Retrieves the help information from `target`.

		Returns a table with the following fields: 

		- `description`: the description of `target`
		- `parameters`: an array of parameters of `target` represented as tables with `name` and `description` fields.
		- `options`: an array of options (named parameters) of `target` represented as tables with `name` and 
		  `description` fields.
		- `methods`: an array of methods
		- `fields`: an array of fields
	]],
	parameters = { {"target", "The target to retrieve help of"} }
}
local function get_help(target) 
	if not target then error("Nil argument or argument missing") end
	local help = help_data[target] or help_data[getmetatable(target)] or {}

	-- Collect child methods and fields
	local children = {}
	if type(target) == "table" then children = target end
	local mt
	if type(target) == "string" then
		mt = help_class_metatables[target]
	else
		mt = getmetatable(target)
	end
	if mt and type(mt.__index) == "table" then
		children = merge_tables(children, mt.__index)
	end

	local methods = {}
	local fields = {}
	for name, value in pairs(children) do
		if name:sub(1, 1) ~= "_" then 
			if type(value) == "function" then
				methods[#methods+1] = { name = name, ref = value }
			else
				fields[#fields+1] = { name = name, description = nil }
			end
		end
	end
	if next(methods) ~= nil then
		help.methods = methods
	end
	if next(fields) ~= nil then
		help.fields = fields
	end
	if next(help) then
		return help
	else
		return nil
	end
end
register_help(get_help)

_H = {
	[[ 
		Prints the help of `target`.

		`target` can be any object. When `target` is a string, prints the help of the class with
		the given name.
	]],
	parameters = { {"target", "The target to retrieve help of"} }
}
local function help(target)
	print()
	if not target then 
		print("Call `help(target)` to get the help of a specific `target`.")
		print("`target` can be any object. When `target` is a string, prints")
		print("the help of the class with the given name.")
		print()
		print("For general information about sluift, type:")
		print("  help(sluift)")
		print()
		return
	end
	local data = get_help(target)
	if not data then
		print("No help available\n")
		return
	end

	-- Collect help of children
	local methods = {}
	for _, method in pairs(data.methods or {}) do
		local description
		local method_help = get_help(method.ref)
		if method_help and method_help.description then
			description = method_help.synopsis
		end
		methods[#methods+1] = { name = method.name, description = description }
	end
	local fields = copy(data.fields or {})

	table.sort(methods, function (a, b) return (a.name or "") < (b.name or "") end)
	table.sort(fields, function (a, b) return (a.name or "") < (b.name or "") end)

	local classes = {}
	for _, class in pairs(data.classes or {}) do
		classes[#classes+1] = { name = class, description = get_help(class).synopsis }
	end

	print(strip_links(data.description) or "(No description available)")
	for _, p in ipairs({
			{"Parameters", data.parameters}, {"Options", data.options}, {"Methods", methods}, {"Fields", fields}, {"Classes", classes}}) do
		if p[2] and next(p[2]) ~= nil then
			print()
			print(p[1] .. ":")
			for _, parameter in ipairs(p[2]) do
				if parameter.description then
					print("  " .. parameter.name .. ": " .. strip_links(parameter.description))
				else
					print("  " .. parameter.name)
				end
			end
		end
	end

	print()
end
register_help(help)

--------------------------------------------------------------------------------
-- Utility methods
--------------------------------------------------------------------------------

_H = {
	[[ Perform a shallow copy of `object`. ]],
	parameters = {{"object", "the object to copy"}}
}
register_help(copy)

_H = {
	[[ Pretty-print a table ]],
	parameters = {{"table", "the table to print"}}
}
local function tprint(table)
	print(table_tostring(table, true))
end
register_help(tprint)

local function remove_help_parameters(elements, table)
	if type(elements) ~= "table" then
		elements = {elements}
	end
	local result = copy(table)
	for k, v in ipairs(table) do
		for _, element in ipairs(elements) do
			if v.name == element then
				result[k] = nil
			end
		end
	end
	return result
end

local function parse_options(unnamed_parameters, arg1, arg2)
	local options = {}
	local f
	if type(arg1) == 'table' then
		options = arg1
		f = arg2
	elseif type(arg1) == 'function' then
		f = arg1
	end
	options.f = f or options.f
	return copy(options)
end


local function get_by_type(table, typ)
	for _, v in ipairs(table) do
		if v['_type'] == typ then
			return v
		end
	end
end

local function register_get_by_type_index(table)
	if type(table) == 'table' then
		local metatable = getmetatable(table)
		if not metatable then
			metatable = {}
			setmetatable(table, metatable)
		end
		metatable.__index = get_by_type
	end
	return table
end

local function call(options)
	local f = options[1]
	local result = { xpcall(f, debug.traceback) }
	if options.finally then
		options.finally()
	end
	if result[1] then
		table.remove(result, 1)
		return unpack(result)
	else
		error(result[2])
	end
end

--------------------------------------------------------------------------------
-- Metatables
--------------------------------------------------------------------------------

_H = {
	[[ Client interface ]]
}
local Client = {
	_with_prompt = function(client) return client:jid() end
}
Client.__index = Client
register_class_table_help(Client, "Client")


_H = {
	[[ Interface to communicate with a PubSub service ]]
}
local PubSub = {}
PubSub.__index = PubSub
register_class_table_help(PubSub, "PubSub")

_H = {
	[[ Interface to communicate with a PubSub node on a service ]]
}
local PubSubNode = {}
PubSubNode.__index = PubSubNode
register_class_table_help(PubSubNode, "PubSubNode")


--------------------------------------------------------------------------------
-- with
--------------------------------------------------------------------------------

local original_G

local function with (target, f)
	-- Dynamic scope
	if f then
		with(target)
		return call{f, finally = function() with() end}
	end

	-- No scope
	if target then
		if not original_G then
			original_G = copy(_G)
			setmetatable(original_G, getmetatable(_G))
			clear(_G)
		end

		setmetatable(_G, { 
			__index = function(_, key)
				local value = target[key]
				if value then
					if type(value) == 'function' then
						-- Add 'self' argument to all functions
						return function(...) return value(target, ...) end
					else
						return value
					end
				else
					return original_G[key]
				end
			end,
			__newindex = original_G,
			_completions = function ()
				local result = {}
				if type(target) == "table" then
					insert_all(result, keys(target))
				end
				local mt = getmetatable(target)
				if mt and type(mt.__index) == 'table' then
					insert_all(result, keys(mt.__index))
				end
				insert_all(result, keys(original_G))
				return result
			end
		})

		-- Set prompt
		local prompt = nil
		
		-- Try '_with_prompt' in metatable
		local target_metatable = getmetatable(target)
		if target_metatable then
			if type(target_metatable._with_prompt) == "function" then
				prompt = target_metatable._with_prompt(target)
			else
				prompt = target_metatable._with_prompt
			end
		end

		if not prompt then
			-- Use tostring()
			local target_string = tostring(target)
			if string.len(target_string) > 25 then
				prompt = string.sub(target_string, 0, 22) .. "..."
			else
				prompt = target_string
			end
		end
		rawset(_G, "_PROMPT", prompt .. '> ')
	else
		-- Reset _G
		clear(_G)
		for key, value in pairs(original_G) do
			_G[key] = value
		end
		setmetatable(_G, original_G)
	end
end

--------------------------------------------------------------------------------
-- Client
--------------------------------------------------------------------------------

extra_help = {
	["Client.get_next_event"] = {
		[[ Returns the next event. ]],
		parameters = { "self" },
		options = {
			type = "The type of event to return (`message`, `presence`, `pubsub`). When omitted, all event types are returned.",
			timeout = "The amount of time to wait for events.",
			["if"] = "A function to filter events. When this function, called with the event as a parameter, returns true, the event will be returned"
		}
	},
	["Client.get"] = {
		[[ Sends a `get` query. ]],
		parameters = { "self" },
		options = {
			to = "The JID of the target to send the query to",
			query = "The query to send",
			timeout = "The amount of time to wait for the query to finish",
		}
	},
	["Client.set"] = {
		[[ Sends a `set` query. ]],
		parameters = { "self" },
		options = {
			to = "The JID of the target to send the query to",
			query = "The query to send.",
			timeout = "The amount of time to wait for the query to finish.",
		}
	},
	["Client.async_connect"] = {
		[[ 
			Connect to the server asynchronously.
			
			This method immediately returns.
		]],
		parameters = { "self" },
		options = {
			host = "The host to connect to. When omitted, is determined by resolving the client JID.",
			port = "The port to connect to. When omitted, is determined by resolving the client JID."
		}
	}
}

_H = {
	[[
		Connect to the server.

		This method blocks until the connection has been established.
	]],
	parameters = { "self" },
	options = extra_help["Client.async_connect"].options
}
function Client:connect (...)
	local options = parse_options({}, ...)
	local f = options.f
	self:async_connect(options)
	self:wait_connected()
	if f then
		return call {function() return f(self) end, finally = function() self:disconnect() end}
	end
	return true
end
register_help(Client.connect)


_H = {
	[[
		Returns an iterator over all events.

		This function blocks until `timeout` is reached (or blocks forever if it is omitted).
	]],
	parameters = { "self" },
	options = extra_help["Client.get_next_event"].options
}
function Client:events (options)
	local function client_events_iterator(s)
		return s['client']:get_next_event(s['options'])
	end
	return client_events_iterator, {client = self, options = options}
end
register_help(Client.events)


_H = {
	[[
		Calls `f` for each event.
	]],
	parameters = { "self" },
	options = merge_tables(get_help(Client.events).options, {
		f = "The functor to call with each event. Required."
	})
}
function Client:for_each_event (...)
	local options = parse_options({}, ...)
	if not type(options.f) == 'function' then error('Expected function') end
	for event in self:events(options) do
		local result = options.f(event)
		if result then
			return result
		end
	end
end
register_help(Client.for_each_event)

for method, event_type in pairs({message = 'message', presence = 'presence', pubsub_event = 'pubsub'}) do
	_H = {
		"Call `f` for all events of type `" .. event_type .. "`.",
		parameters = { "self" },
		options = remove_help_parameters("type", get_help(Client.for_each_event).options)
	}
	Client['for_each_' .. method] = function (client, ...)
		local options = parse_options({}, ...)
		options['type'] = event_type
		return client:for_each_event (options)
	end
	register_help(Client['for_each_' .. method])

	_H = {
		"Get the next event of type `" .. event_type .. "`.",
		parameters = { "self" },
		options = remove_help_parameters("type", extra_help["Client.get_next_event"].options)
	}
	Client['get_next_' .. method] = function (client, ...)
		local options = parse_options({}, ...)
		options['type'] = event_type
		return client:get_next_event(options)
	end
	register_help(Client['get_next_' .. method])
end

for method, event_type in pairs({messages = 'message', pubsub_events = 'pubsub'}) do
	_H = {
		"Returns an iterator over all events of type `" .. event_type .. "`.",
		parameters = { "self" },
		options = remove_help_parameters("type", get_help(Client.for_each_event).options)
	}
	Client[method] = function (client, ...)
		local options = parse_options({}, ...)
		options['type'] = event_type
		return client:events (options)
	end
	register_help(Client[method])
end

_H = {
	[[ 
		Process all pending events
	]],
	parameters = { "self" }
}
function Client:process_events ()
	for event in self:events{timeout=0} do end
end
register_help(Client.process_events)


--
-- Register get_* and set_* convenience methods for some type of queries
--
-- Example usages:
--	client:get_software_version{to = 'alice@wonderland.lit'}
--	client:set_command{to = 'alice@wonderland.lit', command = { type = 'execute', node = 'uptime' }}
--
local get_set_shortcuts = {
	get = {'software_version', 'disco_items', 'xml', 'dom', 'vcard'},
	set = {'command'}
}
for query_action, query_types in pairs(get_set_shortcuts) do
	for _, query_type in ipairs(query_types) do
		_H = {
			"Sends a `" .. query_action .. "` query of type `" .. query_type .. "`.\n" ..
			"Apart from the options below, all top level elements of `" .. query_type .. "` can be passed.",
			parameters = { "self" },
			options = remove_help_parameters({"query", "type"}, extra_help["Client.get"].options),
		}
		local method = query_action .. '_' .. query_type
		Client[method] = function (client, options)
			options = options or {}
			if type(options) ~= 'table' then error('Invalid options: ' .. options) end 
			options['query'] = merge_tables({_type = query_type}, options[query_type] or {})
			return client[query_action](client, options)
		end
		register_help(Client[method])
	end
end

_H = {
	[[ Returns a @{PubSub} object for communicating with the PubSub service at `jid`. ]],
	parameters = { 
		"self", 
		{"jid", "The JID of the PubSub service"}
	}
}
function Client:pubsub (jid)
	local result = { client = self, jid = jid }
	setmetatable(result, PubSub)
	return result
end
register_help(Client.pubsub)

--------------------------------------------------------------------------------
-- PubSub
--------------------------------------------------------------------------------

local function process_pubsub_event (event)
	if event._type == 'pubsub_event_items' then
		-- Add 'item' shortcut to payload of first item
		event.item = event.items and event.items[1] and 
			event.items[1].data and event.items[1].data[1]
	end
end

function PubSub:list_nodes (options)
	return self.client:get_disco_items(merge_tables({to = self.jid}, options))
end

function PubSub:node (node)
	local result = { client = self.client, jid = self.jid, node = node }
	setmetatable(result, PubSubNode)
	return result
end

local simple_pubsub_queries = {
	get_default_configuration = 'pubsub_owner_default',
	get_subscriptions = 'pubsub_subscriptions',
	get_affiliations = 'pubsub_affiliations',
	get_default_subscription_options = 'pubsub_default',
}
for method, query_type in pairs(simple_pubsub_queries) do
	PubSub[method] = function (service, options)
		options = options or {}
		return service.client:query_pubsub(merge_tables(
			{ type = 'get', to = service.jid, query = { _type = query_type } },
			options))
	end
end

for _, method in ipairs({'events', 'get_next_event', 'for_each_event'}) do
	PubSub[method] = function (node, ...)
		local options = parse_options({}, ...)
		options['if'] = function (event) 
			return event.type == 'pubsub' and event.from == node.jid and event.node == node
		end
		return node.client[method](node.client, options)
	end
end

--------------------------------------------------------------------------------
-- PubSubNode
--------------------------------------------------------------------------------

local function pubsub_node_configuration_to_form(configuration)
	if not configuration then
		return
	end
	local fields = { {name = 'form_type', value = 'http://jabber.org/protocol/pubsub#node_config'} }
	for var, value in pairs(configuration) do
		fields[#fields+1] = { name = var, value = value }
	end
	return { type = "submit", fields = fields }
end

function PubSubNode:list_items (options)
	return self.client:get_disco_items(merge_tables({to = self.jid, disco_items = { node = self.node }}, options))
end

local simple_pubsub_node_queries = {
	get_configuration = 'pubsub_owner_configure',
	get_subscriptions = 'pubsub_subscriptions',
	get_affiliations = 'pubsub_affiliations',
	get_owner_subscriptions = 'pubsub_owner_subscriptions',
	get_owner_affiliations = 'pubsub_owner_affiliations',
	get_default_subscription_options = 'pubsub_default',
}
for method, query_type in pairs(simple_pubsub_node_queries) do
	PubSubNode[method] = function (node, options)
		return node.client:query_pubsub(merge_tables({ 
			type = 'get', to = node.jid, query = {
					_type = query_type, node = node.node 
			}}, options))
	end
end

function PubSubNode:get_items (...)
	local options = parse_options({}, ...)
	local items = options.items or {}
	if options.maximum_items then
		items = merge_tables({maximum_items = options.maximum_items}, items)
	end
	items = merge_tables({_type = 'pubsub_items', node = self.node}, items)
	return self.client:query_pubsub(merge_tables({ 
		type = 'get', to = self.jid, query = items}, options))
end

function PubSubNode:get_item (...)
	local options = parse_options({}, ...)
	if not type(options.id) == 'string' then error('Expected ID') end
	return self:get_items{items = {{id = options.id}}}
end

function PubSubNode:create (options)
	options = options or {}
	local configure
	if options['configuration'] then
		configure = { data = pubsub_node_configuration_to_form(options['configuration']) }
	end
	return self.client:query_pubsub(merge_tables(
		{ type = 'set', to = self.jid, query = { 
				_type = 'pubsub_create', node = self.node, configure = configure }
		}, options))
end

function PubSubNode:delete (options)
	options = options or {}
	local redirect
	if options['redirect'] then
		redirect = {uri = options['redirect']}
	end
	return self.client:query_pubsub(merge_tables({ type = 'set', to = self.jid, query = { 
			_type = 'pubsub_owner_delete', node = self.node, redirect = redirect 
		}}, options))
end

function PubSubNode:set_configuration(options)
	options = options or {}
	local configuration = pubsub_node_configuration_to_form(options['configuration'])
	return self.client:query_pubsub(merge_tables(
		{ type = 'set', to = self.jid, query = { 
				_type = 'pubsub_owner_configure', node = self.node, data = configuration }
		}, options))
end

function PubSubNode:set_owner_affiliations(...)
	local options = parse_options({}, ...)
	return self.client:query_pubsub(merge_tables({ 
		type = 'set', to = self.jid, query = merge_tables({
				_type = 'pubsub_owner_affiliations', node = self.node, 
		}, options.affiliations)}, options))
end


function PubSubNode:subscribe(...)
	local options = parse_options({}, ...)
	tprint(options)
	local jid = options.jid or sluift.jid.to_bare(self.client:jid())
	return self.client:query_pubsub(merge_tables(
		{ type = 'set', to = self.jid, query = { 
				_type = 'pubsub_subscribe', node = self.node, jid = jid }
		}, options))
end

function PubSubNode:unsubscribe(options)
	options = options or {}
	return self.client:query_pubsub(merge_tables(
		{ type = 'set', to = self.jid, query = { 
				_type = 'pubsub_unsubscribe', node = self.node, jid = options['jid'], 
				subscription_id = 'subscription_id'}
		}, options))
end

function PubSubNode:get_subscription_options (options)
	return self.client:query_pubsub(merge_tables(
		{ type = 'get', to = self.jid, query = { 
				_type = 'pubsub_options', node = self.node, jid = options['jid'] }
		}, options))
end

function PubSubNode:publish(...)
	local options = parse_options({}, ...)
	local items = options.items or {}
	if options.item then
		if type(options.item) == 'string' or options.item._type then
			items = {{id = options.id, data = { options.item } }}
			options.id = nil 
		else
			items = { options.item }
		end
		options.item = nil
	end
	return self.client:query_pubsub(merge_tables(
		{ type = 'set', to = self.jid, query = { 
				_type = 'pubsub_publish', node = self.node, items = items }
		}, options))
end

function PubSubNode:retract(...)
	local options = parse_options({}, ...)
	local items = options.items
	if options.id then
		items = {{id = options.id}}
	end
	return self.client:query_pubsub(merge_tables(
		{ type = 'set', to = self.jid, query = { 
				_type = 'pubsub_retract', node = self.node, items = items, notify = options['notify']
		}}, options))
end

function PubSubNode:purge(...)
	local options = parse_options({}, ...)
	return self.client:query_pubsub(merge_tables(
		{ type = 'set', to = self.jid, query = { 
				_type = 'pubsub_owner_purge', node = self.node
		}}, options))
end

-- Iterators over events
for _, method in ipairs({'events', 'get_next_event', 'for_each_event'}) do
	PubSubNode[method] = function (node, ...)
		local options = parse_options({}, ...)
		options['if'] = function (event) 
			return event.type == 'pubsub' and event.from == node.jid and event.node == node.node
		end
		return node.client[method](node.client, options)
	end
end

--------------------------------------------------------------------------------
-- Service discovery
--------------------------------------------------------------------------------

local disco = {
	features = {
		DISCO_INFO = 'http://jabber.org/protocol/disco#info',
		COMMANDS = 'http://jabber.org/protocol/commands',
		USER_LOCATION = 'http://jabber.org/protocol/geoloc',
		USER_TUNE = 'http://jabber.org/protocol/tune',
		USER_AVATAR_METADATA = 'urn:xmpp:avatar:metadata',
		USER_ACTIVITY = 'http://jabber.org/protocol/activity',
		USER_PROFILE = 'urn:xmpp:tmp:profile'
	}
}

--------------------------------------------------------------------------------

_H = nil

extra_help['sluift'] = {
	[[
		This module provides methods for XMPP communication.

		The main entry point of this module is the `new_client` method, which creates a
		new client for communicating with an XMPP server.
	]],
	classes = help_classes
}

return {
	Client = Client,
	register_help = register_help,
	register_class_help = register_class_help,
	register_table_tostring = register_table_tostring,
	register_table_equals = register_table_equals,
	register_get_by_type_index = register_get_by_type_index,
	process_pubsub_event = process_pubsub_event,
	tprint = tprint,
	disco = disco,
	get_help = get_help,
	help = help,
	extra_help = extra_help,
	copy = copy,
	with = with
}