local array = require "util.array";

local jid = require "util.jid";

local json = require "util.json";

local st = require "util.stanza";

local xml = require "util.xml";

local map = require "util.datamapper";

local schema do

	local f = assert(module:load_resource("res/schema-xmpp.json"));

	schema = json.decode(f:read("*a"))

	f:close();

	-- Copy common properties to all stanza kinds

	if schema._common then

		for key, prop in pairs(schema._common) do

			for _, copyto in pairs(schema.properties) do

				copyto.properties[key] = prop;

			end

		end

		schema.properties.message.properties.archive.properties.forward = schema.properties.message.properties.forwarded;

		schema.properties.message.properties.forwarded.properties.delay = schema._common.delay;

		schema.properties.message.properties.forwarded.properties.message = schema.properties.message;

		schema.properties.iq.properties.archive.properties.form = schema._common.dataform;

		schema.properties.iq.properties.archive.properties.page = schema._common.rsm;

		schema.properties.iq.properties.result.properties.page = schema._common.rsm;

		schema._common = nil;

	end

end

-- Some mappings that are still hard to do in a nice way with util.datamapper

local field_mappings; -- in scope for "func" mappings

field_mappings = {

	-- XEP-0071

	html = {

		type = "func", xmlns = "http://jabber.org/protocol/xhtml-im", tagname = "html",

		st2json = function (s) --> json string

			return (tostring(s:get_child("body", "http://www.w3.org/1999/xhtml")):gsub(" xmlns='[^']*'", "", 1));

		end;

		json2st = function (s) --> xml

			if type(s) == "string" then

				return assert(xml.parse("<x:html xmlns:x='http://jabber.org/protocol/xhtml-im' xmlns='http://www.w3.org/1999/xhtml'>" .. s .. "</x:html>"));

			end

		end;

	};

	-- XEP-0030

	disco = {

		type = "func", xmlns = "http://jabber.org/protocol/disco#info", tagname = "query",

		st2json = function (s) --> array of features

			if s.tags[1] == nil then

				return s.attr.node or true;

			end

			local identities, features, extensions = array(), array(), {};

			-- features and identities could be done with util.datamapper

			for tag in s:childtags() do

				if tag.name == "identity" and tag.attr.category and tag.attr.type then

					identities:push({ category = tag.attr.category, type = tag.attr.type, name = tag.attr.name });

				elseif tag.name == "feature" and tag.attr.var then

					features:push(tag.attr.var);

				end

			end

			-- Especially this would be hard to do with util.datamapper

			for form in s:childtags("x", "jabber:x:data") do

				local jform = field_mappings.formdata.st2json(form);

				local form_type = jform["FORM_TYPE"];

				if jform then

					jform["FORM_TYPE"] = nil;

					extensions[form_type] = jform;

				end

			end

			if next(extensions) == nil then extensions = nil; end

			return { node = s.attr.node, identities = identities, features = features, extensions = extensions };

		end;

		json2st = function (s)

			if type(s) == "table" and s ~= json.null then

				local disco = st.stanza("query", { xmlns = "http://jabber.org/protocol/disco#info", node = s.node });

				if s.identities then

					for _, identity in ipairs(s.identities) do

						disco:tag("identity", { category = identity.category, type = identity.type, name = identity.name }):up();

					end

				end

				if s.features then

					for _, feature in ipairs(s.features) do

						disco:tag("feature", { var = feature }):up();

					end

				end

				if s.extensions then

					for form_type, extension in pairs(s.extensions) do

						extension["FORM_TYPE"] = form_type;

						disco:add_child(field_mappings.formdata.json2st(extension));

					end

				end

				return disco;

			elseif type(s) == "string" then

				return st.stanza("query", { xmlns = "http://jabber.org/protocol/disco#info", node = s });

			else

				return st.stanza("query", { xmlns = "http://jabber.org/protocol/disco#info", });

			end

		end;

	};

	items = {

		type = "func", xmlns = "http://jabber.org/protocol/disco#items", tagname = "query",

		st2json = function (s) --> array of features | map with node

			if s.tags[1] == nil then

				return s.attr.node or true;

			end

			local items = array();

			for item in s:childtags("item") do

				items:push({ jid = item.attr.jid, node = item.attr.node, name = item.attr.name });

			end

			return items;

		end;

		json2st = function (s)

			if type(s) == "table" and s ~= json.null then

				local disco = st.stanza("query", { xmlns = "http://jabber.org/protocol/disco#items", node = s.node });

				for _, item in ipairs(s) do

					if type(item) == "string" then

						disco:tag("item", { jid = item });

					elseif type(item) == "table" then

						disco:tag("item", { jid = item.jid, node = item.node, name = item.name });

					end

				end

				return disco;

			elseif type(s) == "string" then

				return st.stanza("query", { xmlns = "http://jabber.org/protocol/disco#items", node = s });

			else

				return st.stanza("query", { xmlns = "http://jabber.org/protocol/disco#items", });

			end

		end;

	};

	-- XEP-0050: Ad-Hoc Commands

	command = { type = "func", xmlns = "http://jabber.org/protocol/commands", tagname = "command",

		st2json = function (s)

			local cmd = {

				action = s.attr.action,

				node = s.attr.node,

				sessionid = s.attr.sessionid,

				status = s.attr.status,

			};

			local actions = s:get_child("actions");

			local note = s:get_child("note");

			local form = s:get_child("x", "jabber:x:data");

			if actions then

				cmd.actions = {

					execute = actions.attr.execute,

				};

				for action in actions:childtags() do

					cmd.actions[action.name] = true

				end

			elseif note then

				cmd.note = {

					type = note.attr.type;

					text = note:get_text();

				};

			end

			if form then

				cmd.form = field_mappings.dataform.st2json(form);

			end

			return cmd;

		end;

		json2st = function (s)

			if type(s) == "table" and s ~= json.null then

				local cmd = st.stanza("command", {

					xmlns = "http://jabber.org/protocol/commands",

					action = s.action,

					node = s.node,

					sessionid = s.sessionid,

					status = s.status,

				});

				if type(s.actions) == "table" then

					cmd:tag("actions", { execute = s.actions.execute });

					do

						if s.actions.next == true then

							cmd:tag("next"):up();

						end

						if s.actions.prev == true then

							cmd:tag("prev"):up();

						end

						if s.actions.complete == true then

							cmd:tag("complete"):up();

						end

					end

					cmd:up();

				elseif type(s.note) == "table" then

					cmd:text_tag("note", s.note.text, { type = s.note.type });

				end

				if s.form then

					cmd:add_child(field_mappings.dataform.json2st(s.form));

				elseif s.data then

					cmd:add_child(field_mappings.formdata.json2st(s.data));

				end

				return cmd;

			elseif type(s) == "string" then -- assume node

				return st.stanza("command", { xmlns = "http://jabber.org/protocol/commands", node = s });

			end

			-- else .. missing required attribute

		end;

	};

	-- XEP-0066: Out of Band Data

	-- TODO Replace by oob.url in datamapper schema

	oob_url = { type = "func", xmlns = "jabber:x:oob", tagname = "x",

		-- XXX namespace depends on whether it's in an iq or message stanza

		st2json = function (s)

			return s:get_child_text("url");

		end;

		json2st = function (s)

			if type(s) == "string" then

				return st.stanza("x", { xmlns = "jabber:x:oob" }):text_tag("url", s);

			end

		end;

	};

	-- XEP-0004: Data Forms

	dataform = {

		-- Generic and complete dataforms mapping

		type = "func", xmlns = "jabber:x:data", tagname = "x",

		st2json = function (s)

			local fields = array();

			local form = {

				type = s.attr.type;

				title = s:get_child_text("title");

				instructions = s:get_child_text("instructions");

				fields = fields;

			};

			for field in s:childtags("field") do

				local i = {

					var = field.attr.var;

					type = field.attr.type;

					label = field.attr.label;

					desc = field:get_child_text("desc");

					required = field:get_child("required") and true or nil;

					value = field:get_child_text("value");

				};

				if field.attr.type == "jid-multi" or field.attr.type == "list-multi" or field.attr.type == "text-multi" then

					local value = array();

					for v in field:childtags("value") do

						value:push(v:get_text());

					end

					if field.attr.type == "text-multi" then

						i.value = value:concat("\n");

					else

						i.value = value;

					end

				end

				if field.attr.type == "list-single" or field.attr.type == "list-multi" then

					local options = array();

					for o in field:childtags("option") do

						options:push({ label = o.attr.label, value = o:get_child_text("value") });

					end

					i.options = options;

				end

				fields:push(i);

			end

			return form;

		end;

		json2st = function (x)

			if type(x) == "table" and x ~= json.null then

				local form = st.stanza("x", { xmlns = "jabber:x:data", type = x.type });

				if x.title then

					form:text_tag("title", x.title);

				end

				if x.instructions then

					form:text_tag("instructions", x.instructions);

				end

				if type(x.fields) == "table" then

					for _, f in ipairs(x.fields) do

						if type(f) == "table" then

							form:tag("field", { var = f.var, type = f.type, label = f.label });

							if f.desc then

								form:text_tag("desc", f.desc);

							end

							if f.required == true then

								form:tag("required"):up();

							end

							if type(f.value) == "string" then

								form:text_tag("value", f.value);

							elseif type(f.value) == "table" then

								for _, v in ipairs(f.value) do

									form:text_tag("value", v);

								end

							end

							if type(f.options) == "table" then

								for _, o in ipairs(f.value) do

									if type(o) == "table" then

										form:tag("option", { label = o.label });

										form:text_tag("value", o.value);

										form:up();

									end

								end

							end

						end

					end

				end

				return form;

			end

		end;

	};

	-- Simpler mapping of dataform from JSON map

	formdata = { type = "func", xmlns = "jabber:x:data", tagname = "",

		st2json = function (s)

			local r = {};

			for field in s:childtags("field") do

				if field.attr.var then

					local values = array();

					for value in field:childtags("value") do

						values:push(value:get_text());

					end

					if field.attr.type == "list-single" or field.attr.type == "list-multi" then

						r[field.attr.var] = values;

					elseif field.attr.type == "text-multi" then

						r[field.attr.var] = values:concat("\n");

					elseif field.attr.type == "boolean" then

						r[field.attr.var] = values[1] == "1" or values[1] == "true";

					elseif field.attr.type then

						r[field.attr.var] = values[1] or json.null;

					else -- type is optional, no way to know if multiple or single value is expected

						r[field.attr.var] = values;

					end

				end

			end

			return r;

		end,

		json2st = function (s, t)

			local form = st.stanza("x", { xmlns = "jabber:x:data", type = t });

			for k, v in pairs(s) do

				form:tag("field", { var = k });

				if type(v) == "string" then

					form:text_tag("value", v);

				elseif type(v) == "table" then

					for _, v_ in ipairs(v) do

						form:text_tag("value", v_);

					end

				end

				form:up();

			end

			return form;

		end

	};