local st = require "util.stanza";
local errors = require "util.error";

describe("util.stanza", function()
	describe("#preserialize()", function()
		it("should work", function()
			local stanza = st.stanza("message", { type = "chat" }):text_tag("body", "Hello");
			local stanza2 = st.preserialize(stanza);
			assert.is_table(stanza2, "Preserialized stanza is a table");
			assert.is_nil(getmetatable(stanza2), "Preserialized stanza has no metatable");
			assert.is_string(stanza2.name, "Preserialized stanza has a name field");
			assert.equal(stanza.name, stanza2.name, "Preserialized stanza has same name as the input stanza");
			assert.same(stanza.attr, stanza2.attr, "Preserialized stanza same attr table as input stanza");
			assert.is_nil(stanza2.tags, "Preserialized stanza has no tag list");
			assert.is_nil(stanza2.last_add, "Preserialized stanza has no last_add marker");
			assert.is_table(stanza2[1], "Preserialized child element preserved");
			assert.equal("body", stanza2[1].name, "Preserialized child element name preserved");
		end);
	end);

	describe("#deserialize()", function()
		it("should work", function()
			local stanza = { name = "message", attr = { type = "chat" }, { name = "body", attr = { }, "Hello" } };
			local stanza2 = st.deserialize(st.preserialize(stanza));

			assert.is_table(stanza2, "Deserialized stanza is a table");
			assert.equal(st.stanza_mt, getmetatable(stanza2), "Deserialized stanza has stanza metatable");
			assert.is_string(stanza2.name, "Deserialized stanza has a name field");
			assert.equal(stanza.name, stanza2.name, "Deserialized stanza has same name as the input table");
			assert.same(stanza.attr, stanza2.attr, "Deserialized stanza same attr table as input table");
			assert.is_table(stanza2.tags, "Deserialized stanza has tag list");
			assert.is_table(stanza2[1], "Deserialized child element preserved");
			assert.equal("body", stanza2[1].name, "Deserialized child element name preserved");
		end);
	end);

	describe("#stanza()", function()
		it("should work", function()
			local s = st.stanza("foo", { xmlns = "myxmlns", a = "attr-a" });
			assert.are.equal(s.name, "foo");
			assert.are.equal(s.attr.xmlns, "myxmlns");
			assert.are.equal(s.attr.a, "attr-a");

			local s1 = st.stanza("s1");
			assert.are.equal(s1.name, "s1");
			assert.are.equal(s1.attr.xmlns, nil);
			assert.are.equal(#s1, 0);
			assert.are.equal(#s1.tags, 0);

			s1:tag("child1");
			assert.are.equal(#s1.tags, 1);
			assert.are.equal(s1.tags[1].name, "child1");

			s1:tag("grandchild1"):up();
			assert.are.equal(#s1.tags, 1);
			assert.are.equal(s1.tags[1].name, "child1");
			assert.are.equal(#s1.tags[1], 1);
			assert.are.equal(s1.tags[1][1].name, "grandchild1");

			s1:up():tag("child2");
			assert.are.equal(#s1.tags, 2, tostring(s1));
			assert.are.equal(s1.tags[1].name, "child1");
			assert.are.equal(s1.tags[2].name, "child2");
			assert.are.equal(#s1.tags[1], 1);
			assert.are.equal(s1.tags[1][1].name, "grandchild1");

			s1:up():text("Hello world");
			assert.are.equal(#s1.tags, 2);
			assert.are.equal(#s1, 3);
			assert.are.equal(s1.tags[1].name, "child1");
			assert.are.equal(s1.tags[2].name, "child2");
			assert.are.equal(#s1.tags[1], 1);
			assert.are.equal(s1.tags[1][1].name, "grandchild1");
		end);
		it("should work with unicode values", function ()
			local s = st.stanza("Объект", { xmlns = "myxmlns", ["Объект"] = "&" });
			assert.are.equal(s.name, "Объект");
			assert.are.equal(s.attr.xmlns, "myxmlns");
			assert.are.equal(s.attr["Объект"], "&");
		end);
		it("should allow :text() with nil and empty strings", function ()
			local s_control = st.stanza("foo");
			assert.same(st.stanza("foo"):text(), s_control);
			assert.same(st.stanza("foo"):text(nil), s_control);
			assert.same(st.stanza("foo"):text(""), s_control);
		end);
		it("validates names", function ()
			assert.has_error_match(function ()
				st.stanza("invalid\0name");
			end, "invalid tag name:")
			assert.has_error_match(function ()
				st.stanza("name", { ["foo\1\2\3bar"] = "baz" });
			end, "invalid attribute name: contains control characters")
			assert.has_error_match(function ()
				st.stanza("name", { ["foo"] = "baz\1\2\3\255moo" });
			end, "invalid attribute value: contains control characters")
		end)
		it("validates types", function ()
			assert.has_error_match(function ()
				st.stanza(1);
			end, "invalid tag name: expected string, got number")
			assert.has_error_match(function ()
				st.stanza("name", "string");
			end, "invalid attributes: expected table, got string")
			assert.has_error_match(function ()
				st.stanza("name",{1});
			end, "invalid attribute name: expected string, got number")
			assert.has_error_match(function ()
				st.stanza("name",{foo=1});
			end, "invalid attribute value: expected string, got number")
		end)
	end);

	describe("#message()", function()
		it("should work", function()
			local m = st.message();
			assert.are.equal(m.name, "message");
		end);
	end);

	describe("#iq()", function()
		it("should create an iq stanza", function()
			local i = st.iq({ type = "get", id = "foo" });
			assert.are.equal("iq", i.name);
			assert.are.equal("foo", i.attr.id);
			assert.are.equal("get", i.attr.type);
		end);

		it("should reject stanzas with no attributes", function ()
			assert.has.error_match(function ()
				st.iq();
			end, "attributes");
		end);


		it("should reject stanzas with no id", function ()
			assert.has.error_match(function ()
				st.iq({ type = "get" });
			end, "id attribute");
		end);

		it("should reject stanzas with no type", function ()
			assert.has.error_match(function ()
				st.iq({ id = "foo" });
			end, "type attribute");

		end);
	end);

	describe("#presence()", function ()
		it("should work", function()
			local p = st.presence();
			assert.are.equal(p.name, "presence");
		end);
	end);

	describe("#reply()", function()
		it("should work for <s>", function()
			-- Test stanza
			local s = st.stanza("s", { to = "touser", from = "fromuser", id = "123" })
				:tag("child1");
			-- Make reply stanza
			local r = st.reply(s);
			assert.are.equal(r.name, s.name);
			assert.are.equal(r.id, s.id);
			assert.are.equal(r.attr.to, s.attr.from);
			assert.are.equal(r.attr.from, s.attr.to);
			assert.are.equal(#r.tags, 0, "A reply should not include children of the original stanza");
		end);

		it("should work for <iq get>", function()
			-- Test stanza
			local s = st.stanza("iq", { to = "touser", from = "fromuser", id = "123", type = "get" })
				:tag("child1");
			-- Make reply stanza
			local r = st.reply(s);
			assert.are.equal(r.name, s.name);
			assert.are.equal(r.id, s.id);
			assert.are.equal(r.attr.to, s.attr.from);
			assert.are.equal(r.attr.from, s.attr.to);
			assert.are.equal(r.attr.type, "result");
			assert.are.equal(#r.tags, 0, "A reply should not include children of the original stanza");
		end);

		it("should work for <iq set>", function()
			-- Test stanza
			local s = st.stanza("iq", { to = "touser", from = "fromuser", id = "123", type = "set" })
				:tag("child1");
			-- Make reply stanza
			local r = st.reply(s);
			assert.are.equal(r.name, s.name);
			assert.are.equal(r.id, s.id);
			assert.are.equal(r.attr.to, s.attr.from);
			assert.are.equal(r.attr.from, s.attr.to);
			assert.are.equal(r.attr.type, "result");
			assert.are.equal(#r.tags, 0, "A reply should not include children of the original stanza");
		end);

		it("should reject not-stanzas", function ()
			assert.has.error_match(function ()
				st.reply(not "a stanza");
			end, "expected stanza");
		end);

		it("should reject not-stanzas", function ()
			assert.has.error_match(function ()
				st.reply({name="x"});
			end, "expected stanza");
		end);

	end);

	describe("#error_reply()", function()
		it("should work for <s>", function()
			-- Test stanza
			local s = st.stanza("s", { to = "touser", from = "fromuser", id = "123" })
				:tag("child1");
			-- Make reply stanza
			local r = st.error_reply(s, "cancel", "service-unavailable", nil, "host");
			assert.are.equal(r.name, s.name);
			assert.are.equal(r.id, s.id);
			assert.are.equal(r.attr.to, s.attr.from);
			assert.are.equal(r.attr.from, s.attr.to);
			assert.are.equal(#r.tags, 1);
			assert.are.equal(r.tags[1].tags[1].name, "service-unavailable");
			assert.are.equal(r.tags[1].attr.by, "host");
		end);

		it("should work for <iq get>", function()
			-- Test stanza
			local s = st.stanza("iq", { to = "touser", from = "fromuser", id = "123", type = "get" })
				:tag("child1");
			-- Make reply stanza
			local r = st.error_reply(s, "cancel", "service-unavailable");
			assert.are.equal(r.name, s.name);
			assert.are.equal(r.id, s.id);
			assert.are.equal(r.attr.to, s.attr.from);
			assert.are.equal(r.attr.from, s.attr.to);
			assert.are.equal(r.attr.type, "error");
			assert.are.equal(#r.tags, 1);
			assert.are.equal(r.tags[1].tags[1].name, "service-unavailable");
		end);

		it("should reject not-stanzas", function ()
			assert.has.error_match(function ()
				st.error_reply(not "a stanza", "modify", "bad-request");
			end, "expected stanza");
		end);

		it("should reject stanzas of type error", function ()
			assert.has.error_match(function ()
				st.error_reply(st.message({type="error"}), "cancel", "conflict");
			end, "got stanza of type error");
			assert.has.error_match(function ()
				st.error_reply(st.error_reply(st.message({type="chat"}), "modify", "forbidden"), "cancel", "service-unavailable");
			end, "got stanza of type error");
		end);

		describe("util.error integration", function ()
		it("should accept util.error objects", function ()
			local s = st.message({ to = "touser", from = "fromuser", id = "123", type = "chat" }, "Hello");
			local e = errors.new({ type = "modify", condition = "not-acceptable", text = "Bork bork bork" }, { by = "this.test" });
			local r = st.error_reply(s, e);

			assert.are.equal(r.name, s.name);
			assert.are.equal(r.id, s.id);
			assert.are.equal(r.attr.to, s.attr.from);
			assert.are.equal(r.attr.from, s.attr.to);
			assert.are.equal(r.attr.type, "error");
			assert.are.equal(r.tags[1].name, "error");
			assert.are.equal(r.tags[1].attr.type, e.type);
			assert.are.equal(r.tags[1].tags[1].name, e.condition);
			assert.are.equal(r.tags[1].tags[2]:get_text(), e.text);
			assert.are.equal("this.test", r.tags[1].attr.by);
		end);

		it("should accept util.error objects with an URI", function ()
			local s = st.message({ to = "touser", from = "fromuser", id = "123", type = "chat" }, "Hello");
			local gone = errors.new({ condition = "gone", extra = { uri = "file:///dev/null" } })
			local gonner = st.error_reply(s, gone);
			assert.are.equal("gone", gonner.tags[1].tags[1].name);
			assert.are.equal("file:///dev/null", gonner.tags[1].tags[1][1]);
		end);

		it("should accept util.error objects with application specific error", function ()
			local s = st.message({ to = "touser", from = "fromuser", id = "123", type = "chat" }, "Hello");
			local e = errors.new({ condition = "internal-server-error", text = "Namespaced thing happened",
				extra = {namespace="xmpp:example.test", condition="this-happened"} })
			local r = st.error_reply(s, e);
			assert.are.equal("xmpp:example.test", r.tags[1].tags[3].attr.xmlns);
			assert.are.equal("this-happened", r.tags[1].tags[3].name);

			local e2 = errors.new({ condition = "internal-server-error", text = "Namespaced thing happened",
				extra = {tag=st.stanza("that-happened", { xmlns = "xmpp:example.test", ["another-attribute"] = "here" })} })
			local r2 = st.error_reply(s, e2);
			assert.are.equal("xmpp:example.test", r2.tags[1].tags[3].attr.xmlns);
			assert.are.equal("that-happened", r2.tags[1].tags[3].name);
			assert.are.equal("here", r2.tags[1].tags[3].attr["another-attribute"]);
		end);
		end);
	end);

	describe("#get_error()", function ()
		describe("basics", function ()
			local s = st.message();
			local e = st.error_reply(s, "cancel", "not-acceptable", "UNACCEPTABLE!!!! ONE MILLION YEARS DUNGEON!")
				:tag("dungeon", { xmlns = "urn:uuid:c9026187-5b05-4e70-b265-c3b6338a7d0f", period="1000000years"});
			local typ, cond, text, extra = e:get_error();
			assert.equal("cancel", typ);
			assert.equal("not-acceptable", cond);
			assert.equal("UNACCEPTABLE!!!! ONE MILLION YEARS DUNGEON!", text);
			assert.not_nil(extra)
		end)
	end)

	describe("#add_error()", function ()
		describe("basics", function ()
			local s = st.stanza("custom", { xmlns = "urn:example:foo" });
			local e = s:add_error("cancel", "not-acceptable", "UNACCEPTABLE!!!! ONE MILLION YEARS DUNGEON!")
				:tag("dungeon", { xmlns = "urn:uuid:c9026187-5b05-4e70-b265-c3b6338a7d0f", period="1000000years"});
			assert.equal(s, e);
			local typ, cond, text, extra = e:get_error();
			assert.equal("cancel", typ);
			assert.equal("not-acceptable", cond);
			assert.equal("UNACCEPTABLE!!!! ONE MILLION YEARS DUNGEON!", text);
			assert.is_nil(extra);
		end)
	end)

	describe("should reject #invalid", function ()
		local invalid_names = {
			["empty string"] = "", ["characters"] = "<>";
		}
		local invalid_data = {
			["number"] = 1234, ["table"] = {};
			["utf8"] = string.char(0xF4, 0x90, 0x80, 0x80);
			["nil"] = "nil"; ["boolean"] = true;
			["control characters"] = "\0\1\2\3";
		};

		for value_type, value in pairs(invalid_names) do
			it(value_type.." in tag names", function ()
				assert.error_matches(function ()
					st.stanza(value);
				end, value_type);
			end);
			it(value_type.." in attribute names", function ()
				assert.error_matches(function ()
					st.stanza("valid", { [value] = "valid" });
				end, value_type);
			end);
		end
		for value_type, value in pairs(invalid_data) do
			if value == "nil" then value = nil; end
			it(value_type.." in tag names", function ()
				assert.error_matches(function ()
					st.stanza(value);
				end, value_type);
			end);
			it(value_type.." in attribute names", function ()
				assert.error_matches(function ()
					st.stanza("valid", { [value] = "valid" });
				end, value_type);
			end);
			if value ~= nil then
				it(value_type.." in attribute values", function ()
					assert.error_matches(function ()
						st.stanza("valid", { valid = value });
					end, value_type);
				end);
				it(value_type.." in text node", function ()
					assert.error_matches(function ()
						st.stanza("valid"):text(value);
					end, value_type);
				end);
			end
		end
	end);

	describe("#is_stanza", function ()
		-- is_stanza(any) -> boolean
		it("identifies stanzas as stanzas", function ()
			assert.truthy(st.is_stanza(st.stanza("x")));
		end);
		it("identifies strings as not stanzas", function ()
			assert.falsy(st.is_stanza(""));
		end);
		it("identifies numbers as not stanzas", function ()
			assert.falsy(st.is_stanza(1));
		end);
		it("identifies tables as not stanzas", function ()
			assert.falsy(st.is_stanza({}));
		end);
	end);

	describe("#remove_children", function ()
		it("should work", function ()
			local s = st.stanza("x", {xmlns="test"})
				:tag("y", {xmlns="test"}):up()
				:tag("z", {xmlns="test2"}):up()
				:tag("x", {xmlns="test2"}):up()

			s:remove_children("x");
			assert.falsy(s:get_child("x"))
			assert.truthy(s:get_child("z","test2"));
			assert.truthy(s:get_child("x","test2"));

			s:remove_children(nil, "test2");
			assert.truthy(s:get_child("y"))
			assert.falsy(s:get_child(nil,"test2"));

			s:remove_children();
			assert.falsy(s.tags[1]);
		end);
	end);

	describe("#maptags", function ()
		it("should work", function ()
			local s = st.stanza("test")
				:tag("one"):up()
				:tag("two"):up()
				:tag("one"):up()
				:tag("three"):up();

			local function one_filter(tag)
				if tag.name == "one" then
					return nil;
				end
				return tag;
			end
			assert.equal(4, #s.tags);
			s:maptags(one_filter);
			assert.equal(2, #s.tags);
		end);

		it("should work with multiple consecutive text nodes", function ()
			local s = st.deserialize({
				"\n";
				{
					"away";
					name = "show";
					attr = {};
				};
				"\n";
				{
					"I am away";
					name = "status";
					attr = {};
				};
				"\n";
				{
					"0";
					name = "priority";
					attr = {};
				};
				"\n";
				{
					name = "c";
					attr = {
						xmlns = "http://jabber.org/protocol/caps";
						node = "http://psi-im.org";
						hash = "sha-1";
					};
				};
				"\n";
				"\n";
				name = "presence";
				attr = {
					to = "user@example.com/jflsjfld";
					from = "room@chat.example.org/nick";
				};
			});

			assert.equal(4, #s.tags);

			s:maptags(function (tag) return tag; end);
			assert.equal(4, #s.tags);

			s:maptags(function (tag)
				if tag.name == "c" then
					return nil;
				end
				return tag;
			end);
			assert.equal(3, #s.tags);
		end);
		it("errors on invalid data - #981", function ()
			local s = st.message({}, "Hello");
			s.tags[1] = st.clone(s.tags[1]);
			assert.has_error_match(function ()
				s:maptags(function () end);
			end, "Invalid stanza");
		end);
	end);

	describe("get_child_with_attr", function ()
		local s = st.message({ type = "chat" })
			:text_tag("body", "Hello world", { ["xml:lang"] = "en" })
			:text_tag("body", "Bonjour le monde", { ["xml:lang"] = "fr" })
			:text_tag("body", "Hallo Welt", { ["xml:lang"] = "de" })

		it("works", function ()
			assert.equal(s:get_child_with_attr("body", nil, "xml:lang", "en"):get_text(), "Hello world");
			assert.equal(s:get_child_with_attr("body", nil, "xml:lang", "de"):get_text(), "Hallo Welt");
			assert.equal(s:get_child_with_attr("body", nil, "xml:lang", "fr"):get_text(), "Bonjour le monde");
			assert.is_nil(s:get_child_with_attr("body", nil, "xml:lang", "FR"));
			assert.is_nil(s:get_child_with_attr("body", nil, "xml:lang", "es"));
		end);

		it("supports normalization", function ()
			assert.equal(s:get_child_with_attr("body", nil, "xml:lang", "EN", string.upper):get_text(), "Hello world");
			assert.is_nil(s:get_child_with_attr("body", nil, "xml:lang", "ES", string.upper));
		end);
	end);

	describe("#clone", function ()
		it("works", function ()
			local s = st.message({type="chat"}, "Hello"):reset();
			local c = st.clone(s);
			assert.same(s, c);
		end);

		it("works", function ()
			assert.has_error(function ()
				st.clone("this is not a stanza");
			end);
		end);
	end);

	describe("top_tag", function ()
		local xml_parse = require "util.xml".parse;
		it("works", function ()
			local s = st.message({type="chat"}, "Hello");
			local top_tag = s:top_tag();
			assert.is_string(top_tag);
			assert.not_equal("/>", top_tag:sub(-2, -1));
			assert.equal(">", top_tag:sub(-1, -1));
			local s2 = xml_parse(top_tag.."</message>");
			assert(st.is_stanza(s2));
			assert.equal("message", s2.name);
			assert.equal(0, #s2);
			assert.equal(0, #s2.tags);
			assert.equal("chat", s2.attr.type);
		end);

		it("works with namespaced attributes", function ()
			local s = xml_parse[[<message foo:bar='true' xmlns:foo='my-awesome-ns'/>]];
			local top_tag = s:top_tag();
			assert.is_string(top_tag);
			assert.not_equal("/>", top_tag:sub(-2, -1));
			assert.equal(">", top_tag:sub(-1, -1));
			local s2 = xml_parse(top_tag.."</message>");
			assert(st.is_stanza(s2));
			assert.equal("message", s2.name);
			assert.equal(0, #s2);
			assert.equal(0, #s2.tags);
			assert.equal("true", s2.attr["my-awesome-ns\1bar"]);
		end);
	end);

	describe("indent", function ()
		local s = st.stanza("foo"):text("\n"):tag("bar"):tag("baz"):up():text_tag("cow", "moo");
		assert.equal("<foo>\n\t<bar>\n\t\t<baz/>\n\t\t<cow>moo</cow>\n\t</bar>\n</foo>", tostring(s:indent()));
		assert.equal("<foo>\n  <bar>\n    <baz/>\n    <cow>moo</cow>\n  </bar>\n</foo>", tostring(s:indent(1, "  ")));
		assert.equal("<foo>\n\t\t<bar>\n\t\t\t<baz/>\n\t\t\t<cow>moo</cow>\n\t\t</bar>\n\t</foo>", tostring(s:indent(2, "\t")));
	end);

	describe("find", function()
		it("works", function()
			local s = st.stanza("root", { attr = "value" }):tag("child",
				{ xmlns = "urn:example:not:same"; childattr = "thisvalue" }):text_tag("nested", "text"):reset();
			assert.equal("value", s:find("@attr"), "finds attr")
			assert.equal(s:get_child("child", "urn:example:not:same"), s:find("{urn:example:not:same}child"),
				"equivalent to get_child")
			assert.equal("thisvalue", s:find("{urn:example:not:same}child@childattr"), "finds child attr")
			assert.equal("text", s:find("{urn:example:not:same}child/nested#"), "finds nested text")
			assert.is_nil(s:find("child"), "respects namespaces")
		end);
	end);
end);