local ipairs, pairs = ipairs, pairs;

local setmetatable = setmetatable;

local tostring = tostring;

local next, unpack = next, table.unpack or unpack; --luacheck: ignore 113/unpack

local os_remove = os.remove;

local io_open = io.open;

local jid_bare = require "util.jid".bare;

local jid_prep = require "util.jid".prep;

local jid_join = require "util.jid".join;

local array = require "util.array";

local base64 = require "util.encodings".base64;

local dt = require "util.datetime";

local hex = require "util.hex";

local it = require "util.iterators";

local paths = require"util.paths";

local set = require "util.set";

local st = require "util.stanza";

local parse_xml_real = require "util.xml".parse;

local lfs = require "lfs";

local function default_get_user_xml(self, user, host) --luacheck: ignore 212/self

	local jid = jid_join(user, host);

	local path = paths.join(prosody.paths.data, jid..".xml");

	local f, err = io_open(path);

	if not f then

		module:log("debug", "Unable to load XML file for <%s>: %s", jid, err);

		return;

	end

	module:log("debug", "Loaded %s", path);

	local s = f:read("*a");

	f:close();

	return parse_xml_real(s);

end

	local jid = jid_join(user, host);

	local path = paths.join(prosody.paths.data, jid..".xml");

	local f, err = io_open(path, "w");

	if not f then return f, err; end

	if xml then

		local s = tostring(xml);

		f:write(s);

		f:close();

		return true;

	else

		f:close();

		return os_remove(path);

	end

end

local function getUserElement(xml)

	if xml and xml.name == "server-data" then

		local host = xml.tags[1];

		if host and host.name == "host" then

			local user = host.tags[1];

			if user and user.name == "user" then

				return user;

			end

		end

	end

	module:log("warn", "Unable to find user element");

end

local function createOuterXml(user, host)

	return st.stanza("server-data", {xmlns='urn:xmpp:pie:0'})

		:tag("host", {jid=host})

			:tag("user", {name = user});

end

local function hex_to_base64(s)

	return base64.encode(hex.from(s));

end

local function base64_to_hex(s)

	return base64.encode(hex.from(s));

end

local handlers = {};

-- In order to support custom account properties

local extended = "http://prosody.im/protocol/extended-xep0227\1";

local scram_hash_name = module:get_option_string("password_hash", "SHA-1");

local scram_properties = set.new({ "server_key", "stored_key", "iteration_count", "salt" });

handlers.accounts = {

	get = function(self, user)

		user = getUserElement(self:_get_user_xml(user, self.host));

		local scram_credentials = user and user:get_child_with_attr(

			"scram-credentials", "urn:xmpp:pie:0#scram",

			"mechanism", "SCRAM-"..scram_hash_name

		);

		if scram_credentials then

			return {

				iteration_count = tonumber(scram_credentials:get_child_text("iter-count"));

				server_key = base64_to_hex(scram_credentials:get_child_text("server-key"));

				stored_key = base64_to_hex(scram_credentials:get_child_text("stored-key"));

				salt = base64.decode(scram_credentials:get_child_text("salt"));

			};

		elseif user and user.attr.password then

			return { password = user.attr.password };

		elseif user then

			local data = {};

			for k, v in pairs(user.attr) do

				if k:sub(1, #extended) == extended then

					data[k:sub(#extended+1)] = v;

				end

			end

			return data;

		end

	end;

	set = function(self, user, data)

		if not data then

			return self:_set_user_xml(user, self.host, nil);

		end

		local xml = self:_get_user_xml(user, self.host);

		if not xml then xml = createOuterXml(user, self.host); end

		local usere = getUserElement(xml);

		local account_properties = set.new(it.to_array(it.keys(data)));

		-- Include SCRAM credentials if known

		if account_properties:contains_set(scram_properties) then

			local scram_el = st.stanza("scram-credentials", { xmlns = "urn:xmpp:pie:0#scram", mechanism = "SCRAM-"..scram_hash_name })

				:text_tag("server-key", hex_to_base64(data.server_key))

				:text_tag("stored-key", hex_to_base64(data.stored_key))

				:text_tag("iter-count", ("%d"):format(data.iteration_count))

				:text_tag("salt", base64.encode(data.salt));

			usere:add_child(scram_el);

			account_properties:exclude(scram_properties);

		end

		-- Include the password if present

		if account_properties:contains("password") then

			usere.attr.password = data.password;

			account_properties:remove("password");

		end

		-- Preserve remaining properties as namespaced attributes

		for property in account_properties do

			usere.attr[extended..property] = data[property];

		end

		return self:_set_user_xml(user, self.host, xml);

	end;

};

handlers.vcard = {

	get = function(self, user)

		user = getUserElement(self:_get_user_xml(user, self.host));

		if user then

			local vcard = user:get_child("vCard", 'vcard-temp');

			if vcard then

				return st.preserialize(vcard);

			end

		end

	end;

	set = function(self, user, data)

		local xml = self:_get_user_xml(user, self.host);

		local usere = xml and getUserElement(xml);

		if usere then

			usere:remove_children("vCard", "vcard-temp");

			if not data or not data.attr then

				-- No data to set, old one deleted, success

				return true;

			end

			local vcard = st.deserialize(data);

			usere:add_child(vcard);

			return self:_set_user_xml(user, self.host, xml);

		end

		return true;

	end;

};

handlers.private = {

	get = function(self, user)

		user = getUserElement(self:_get_user_xml(user, self.host));

		if user then

			local private = user:get_child("query", "jabber:iq:private");

			if private then

				local r = {};

				for _, tag in ipairs(private.tags) do

					r[tag.name..":"..tag.attr.xmlns] = st.preserialize(tag);

				end

				return r;

			end

		end

	end;

	set = function(self, user, data)

		local xml = self:_get_user_xml(user, self.host);

		local usere = xml and getUserElement(xml);

		if usere then

			usere:remove_children("query", "jabber:iq:private");

			if data and next(data) ~= nil then

				local private = st.stanza("query", {xmlns='jabber:iq:private'});

				for _,tag in pairs(data) do

					private:add_child(st.deserialize(tag));

				end

				usere:add_child(private);

			end

			return self:_set_user_xml(user, self.host, xml);

		end

		return true;

	end;

};

handlers.roster = {

	get = function(self, user)

		user = getUserElement(self:_get_user_xml(user, self.host));

		if user then

			local roster = user:get_child("query", "jabber:iq:roster");

			if roster then

				local r = {

					[false] = {

						version = roster.attr.version;

						pending = {};

					}

				};

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

					r[item.attr.jid] = {

						jid = item.attr.jid,

						subscription = item.attr.subscription,

						ask = item.attr.ask,

						name = item.attr.name,

						groups = {};

					};

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

						r[item.attr.jid].groups[group:get_text()] = true;

					end

					for pending in user:childtags("presence", "jabber:client") do

						r[false].pending[pending.attr.from] = true;

					end

				end

				return r;

			end

		end

	end;

	set = function(self, user, data)

		local xml = self:_get_user_xml(user, self.host);

		local usere = xml and getUserElement(xml);

		if usere then

			local user_jid = jid_join(usere.name, self.host);

			usere:remove_children("query", "jabber:iq:roster");

			usere:maptags(function (tag)

				if tag.attr.xmlns == "jabber:client" and tag.name == "presence" and tag.attr.type == "subscribe" then

					return nil;

				end

				return tag;

			end);

			if data and next(data) ~= nil then

				local roster = st.stanza("query", {xmlns='jabber:iq:roster'});

				usere:add_child(roster);

				for contact_jid, item in pairs(data) do

					if contact_jid ~= false then

						contact_jid = jid_bare(jid_prep(contact_jid));

						if contact_jid ~= user_jid then -- Skip self-contacts

							roster:tag("item", {

								jid = contact_jid,

								subscription = item.subscription,

								ask = item.ask,

								name = item.name,

							});

							for group in pairs(item.groups) do

								roster:tag("group"):text(group):up();

							end

							roster:up(); -- move out from item

						end

					else

						roster.attr.version = item.version;

						for pending_jid in pairs(item.pending) do

							usere:add_child(st.presence({ from = pending_jid, type = "subscribe" }));

						end

					end

				end

			end

			return self:_set_user_xml(user, self.host, xml);

		end

		return true;

	end;

};

-- PEP node configuration/etc. (not items)

local xmlns_pubsub_owner = "http://jabber.org/protocol/pubsub#owner";

local lib_pubsub = module:require "pubsub";

handlers.pep = {

	get = function (self, user)

		local xml = self:_get_user_xml(user, self.host);

		local user_el = xml and getUserElement(xml);

		if not user_el then

			return nil;

		end

		local nodes = {

			--[[

			[node_name] = {

				name = node_name;

				config = {};

				affiliations = {};

				subscribers = {};

			};

			]]

		};

		local owner_el = user_el:get_child("pubsub", xmlns_pubsub_owner);

		for node_el in owner_el:childtags() do

			local node_name = node_el.attr.node;

			local node = nodes[node_name];

			if not node then

				node = {

					name = node_name;

					config = {};

					affiliations = {};

					subscribers = {};

				};

				nodes[node_name] = node;

			end

			if node_el.name == "configure" then

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

				if form then

					node.config = lib_pubsub.node_config_form:data(form);

				end

			elseif node_el.name == "affiliations" then

				for affiliation_el in node_el:childtags("affiliation") do

					local aff_jid = jid_prep(affiliation_el.attr.jid);

					local aff_value = affiliation_el.attr.affiliation;

					if aff_jid and aff_value then

						node.affiliations[aff_jid] = aff_value;

					end

				end

			elseif node_el.name == "subscriptions" then

				for subscription_el in node_el:childtags("subscription") do

					local sub_jid = jid_prep(subscription_el.attr.jid);

					local sub_state = subscription_el.attr.subscription;

					if sub_jid and sub_state == "subscribed" then

						local options;

						local subscription_options_el = subscription_el:get_child("options");

						if subscription_options_el then

							local options_form = subscription_options_el:get_child("x", "jabber:x:data");

							if options_form then

								options = lib_pubsub.subscription_options_form:data(options_form);

							end

						end

						node.subscribers[sub_jid] = options or true;

					end

				end

			else

				module:log("warn", "Ignoring unknown pubsub element: %s", node_el.name);

			end

		end

		return nodes;

	end;

	set = function(self, user, data)

		local xml = self:_get_user_xml(user, self.host);

		local user_el = xml and getUserElement(xml);

		if not user_el then

			return true;

		end

		-- Remove existing data, if any

		user_el:remove_children("pubsub", xmlns_pubsub_owner);

		-- Generate new data

		local owner_el = st.stanza("pubsub", { xmlns = xmlns_pubsub_owner });

		for node_name, node_data in pairs(data) do

			if node_data == true then