local events = require "util.events";

local cache = require "util.cache";

local errors = require "util.error";

local service_mt = {};

local default_config = {

	itemstore = function (config, _) return cache.new(config["max_items"]) end;

	broadcaster = function () end;

	subscriber_filter = function (subs) return subs end;

	itemcheck = function () return true; end;

	get_affiliation = function () end;

	normalize_jid = function (jid) return jid; end;

	capabilities = {

		outcast = {

			create = false;

			publish = false;

			retract = false;

			get_nodes = false;

			subscribe = false;

			unsubscribe = false;

			get_subscription = true;

			get_subscriptions = true;

			get_items = false;

			subscribe_other = false;

			unsubscribe_other = false;

			get_subscription_other = false;

			get_subscriptions_other = false;

			be_subscribed = false;

			be_unsubscribed = true;

			set_affiliation = false;

		};

		none = {

			create = false;

			publish = false;

			retract = false;

			get_nodes = true;

			subscribe = true;

			unsubscribe = true;

			get_subscription = true;

			get_subscriptions = true;

			get_items = false;

			subscribe_other = false;

			unsubscribe_other = false;

			get_subscription_other = false;

			get_subscriptions_other = false;

			be_subscribed = true;

			be_unsubscribed = true;

			set_affiliation = false;

		};

		member = {

			create = false;

			publish = false;

			retract = false;

			get_nodes = true;

			subscribe = true;

			unsubscribe = true;

			get_subscription = true;

			get_subscriptions = true;

			get_items = true;

			subscribe_other = false;

			unsubscribe_other = false;

			get_subscription_other = false;

			get_subscriptions_other = false;

			be_subscribed = true;

			be_unsubscribed = true;

			set_affiliation = false;

		};

		publisher = {

			create = false;

			publish = true;

			retract = true;

			get_nodes = true;

			get_configuration = true;

			subscribe = true;

			unsubscribe = true;

			get_subscription = true;

			get_subscriptions = true;

			get_items = true;

			subscribe_other = false;

			unsubscribe_other = false;

			get_subscription_other = false;

			get_subscriptions_other = false;

			be_subscribed = true;

			be_unsubscribed = true;

			set_affiliation = false;

		};

		owner = {

			create = true;

			publish = true;

			retract = true;

			delete = true;

			get_nodes = true;

			configure = true;

			get_configuration = true;

			subscribe = true;

			unsubscribe = true;

			get_subscription = true;

			get_subscriptions = true;

			get_items = true;

			subscribe_other = true;

			unsubscribe_other = true;

			get_subscription_other = true;

			get_subscriptions_other = true;

			be_subscribed = true;

			be_unsubscribed = true;

			set_affiliation = true;

		};

	};

};

local default_config_mt = { __index = default_config };

local default_node_config = {

	["persist_items"] = true;

	["max_items"] = 20;

	["access_model"] = "open";

	["publish_model"] = "publishers";

	["send_last_published_item"] = "never";

};

local default_node_config_mt = { __index = default_node_config };

-- Storage helper functions

local function load_node_from_store(service, node_name)

	local node = service.config.nodestore:get(node_name);

	node.config = setmetatable(node.config or {}, {__index=service.node_defaults});

	return node;

end

local function save_node_to_store(service, node)

	return service.config.nodestore:set(node.name, {

		name = node.name;

		config = node.config;

		subscribers = node.subscribers;

		affiliations = node.affiliations;

	});

end

local function delete_node_in_store(service, node_name)

	return service.config.nodestore:set(node_name, nil);

end

-- Create and return a new service object

local function new(config)

	config = config or {};

	local service = setmetatable({

		config = setmetatable(config, default_config_mt);

		node_defaults = setmetatable(config.node_defaults or {}, default_node_config_mt);

		affiliations = {};

		subscriptions = {};

		nodes = {};

		data = {};

		events = events.new();

	}, service_mt);

	-- Load nodes from storage, if we have a store and it supports iterating over stored items

	if config.nodestore and config.nodestore.users then

		for node_name in config.nodestore:users() do

			local node = load_node_from_store(service, node_name);

			service.nodes[node_name] = node;

			if node.config.persist_items then

				service.data[node_name] = config.itemstore(service.nodes[node_name].config, node_name);

			end

			for jid in pairs(service.nodes[node_name].subscribers) do

				local normal_jid = service.config.normalize_jid(jid);

				local subs = service.subscriptions[normal_jid];

				if subs then

					if not subs[jid] then

						subs[jid] = { [node_name] = true };

					else

						subs[jid][node_name] = true;

					end

				else

					service.subscriptions[normal_jid] = { [jid] = { [node_name] = true } };

				end

			end

		end

	end

	return service;

end

--- Service methods

local service = {};

service_mt.__index = service;

function service:jids_equal(jid1, jid2) --> boolean

	local normalize = self.config.normalize_jid;

	return normalize(jid1) == normalize(jid2);

end

function service:may(node, actor, action) --> boolean

	if actor == true then return true; end

	local node_obj = self.nodes[node];

	local node_aff = node_obj and (node_obj.affiliations[actor]

	              or node_obj.affiliations[self.config.normalize_jid(actor)]);

	local service_aff = self.affiliations[actor]

	                 or self.config.get_affiliation(actor, node, action);

	local default_aff = self:get_default_affiliation(node, actor) or "none";

	-- Check if node allows/forbids it

	local node_capabilities = node_obj and node_obj.capabilities;

	if node_capabilities then

		local caps = node_capabilities[node_aff or service_aff or default_aff];

		if caps then

			local can = caps[action];

			if can ~= nil then

				return can;

			end

		end

	end

	-- Check service-wide capabilities instead

	local service_capabilities = self.config.capabilities;

	local caps = service_capabilities[node_aff or service_aff or default_aff];

	if caps then

		local can = caps[action];

		if can ~= nil then

			return can;

		end

	end

	return false;

end

function service:get_default_affiliation(node, actor) --> affiliation

	local node_obj = self.nodes[node];

	local access_model = node_obj and node_obj.config.access_model

		or self.node_defaults.access_model;

	if access_model == "open" then

		return "member";

	elseif access_model == "whitelist" then

		return "outcast";

	end

	if self.config.access_models then

		local check = self.config.access_models[access_model];

		if check then

			local aff = check(actor);

			if aff then

				return aff;

			end

		end

	end

end

function service:set_affiliation(node, actor, jid, affiliation) --> ok, err

	-- Access checking

	if not self:may(node, actor, "set_affiliation") then

		return false, "forbidden";

	end

	--

	local node_obj = self.nodes[node];

	if not node_obj then

		return false, "item-not-found";

	end

	jid = self.config.normalize_jid(jid);

	local old_affiliation = node_obj.affiliations[jid];

	node_obj.affiliations[jid] = affiliation;

	if self.config.nodestore then

		-- TODO pass the error from storage to caller eg wrapped in an util.error

		local ok, err = save_node_to_store(self, node_obj); -- luacheck: ignore 211/err

		if not ok then

			node_obj.affiliations[jid] = old_affiliation;

			return ok, "internal-server-error";

		end

	end

	local _, jid_sub = self:get_subscription(node, true, jid);

	if not jid_sub and not self:may(node, jid, "be_unsubscribed") then

		local ok, err = self:add_subscription(node, true, jid);

		if not ok then

			return ok, err;

		end

	elseif jid_sub and not self:may(node, jid, "be_subscribed") then

		local ok, err = self:add_subscription(node, true, jid);

		if not ok then

			return ok, err;

		end

	end

	return true;

end

function service:add_subscription(node, actor, jid, options) --> ok, err

	-- Access checking

	local cap;

	if actor == true or jid == actor or self:jids_equal(actor, jid) then

		cap = "subscribe";

	else

		cap = "subscribe_other";

	end

	if not self:may(node, actor, cap) then

		return false, "forbidden";

	end

	if not self:may(node, jid, "be_subscribed") then

		return false, "forbidden";

	end

	--

	local node_obj = self.nodes[node];

	if not node_obj then

		if not self.config.autocreate_on_subscribe then

			return false, "item-not-found";

		else

			local ok, err = self:create(node, true);

			if not ok then

				return ok, err;

			end

			node_obj = self.nodes[node];

		end

	end

	local old_subscription = node_obj.subscribers[jid];

	node_obj.subscribers[jid] = options or true;

	local normal_jid = self.config.normalize_jid(jid);

	local subs = self.subscriptions[normal_jid];

	if subs then

		if not subs[jid] then

			subs[jid] = { [node] = true };

		else

			subs[jid][node] = true;

		end

	else

		self.subscriptions[normal_jid] = { [jid] = { [node] = true } };

	end

	if self.config.nodestore then

		-- TODO pass the error from storage to caller eg wrapped in an util.error

		local ok, err = save_node_to_store(self, node_obj); -- luacheck: ignore 211/err

		if not ok then

			node_obj.subscribers[jid] = old_subscription;

			self.subscriptions[normal_jid][jid][node] = old_subscription and true or nil;

			return ok, "internal-server-error";

		end

	end

	self.events.fire_event("subscription-added", { service = self, node = node, jid = jid, normalized_jid = normal_jid, options = options });

	return true;

end

function service:remove_subscription(node, actor, jid) --> ok, err

	-- Access checking

	local cap;

	if actor == true or jid == actor or self:jids_equal(actor, jid) then

		cap = "unsubscribe";

	else

		cap = "unsubscribe_other";

	end

	if not self:may(node, actor, cap) then

		return false, "forbidden";

	end

	if not self:may(node, jid, "be_unsubscribed") then