-- Prosody IM

-- Copyright (C) 2008-2010 Matthew Wild

-- Copyright (C) 2008-2010 Waqas Hussain

-- Copyright (C) 2014 Daurnimator

--

-- This project is MIT/X11 licensed. Please see the

-- COPYING file in the source package for more information.

--

local select = select;

local pairs = pairs;

local next = next;

local setmetatable = setmetatable;

local dataform = require "util.dataforms";

local iterators = require "util.iterators";

local jid_split = require "util.jid".split;

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

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

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

local jid_resource = require "util.jid".resource;

local resourceprep = require "util.encodings".stringprep.resourceprep;

local st = require "util.stanza";

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

local md5 = require "util.hashes".md5;

local new_id = require "util.id".medium;

local log = module._log;

local occupant_lib = module:require "muc/occupant"

local muc_util = module:require "muc/util";

local is_kickable_error = muc_util.is_kickable_error;

local valid_roles, valid_affiliations = muc_util.valid_roles, muc_util.valid_affiliations;

local room_mt = {};

room_mt.__index = room_mt;

function room_mt:__tostring()

	return "MUC room ("..self.jid..")";

end

function room_mt.save()

	-- overridden by mod_muc.lua

end

function room_mt:get_occupant_jid(real_jid)

	return self._jid_nick[real_jid]

end

function room_mt:get_default_role(affiliation)

	local role = module:fire_event("muc-get-default-role", {

		room = self;

		affiliation = affiliation;

		affiliation_rank = valid_affiliations[affiliation or "none"];

	});

	role = role ~= "none" and role or nil; -- coerces `role == false` to `nil`

	return role, valid_roles[role or "none"];

end

module:hook("muc-get-default-role", function(event)

	if event.affiliation_rank >= valid_affiliations.admin then

		return "moderator";

	elseif event.affiliation_rank >= valid_affiliations.none then

		return "participant";

	end

end, -1);

--- Occupant functions

function room_mt:new_occupant(bare_real_jid, nick)

	local occupant = occupant_lib.new(bare_real_jid, nick);

	local affiliation = self:get_affiliation(bare_real_jid);

	occupant.role = self:get_default_role(affiliation);

	return occupant;

end

-- nick is in the form of an in-room JID

function room_mt:get_occupant_by_nick(nick)

	local occupant = self._occupants[nick];

	if occupant == nil then return nil end

	return occupant_lib.copy(occupant);

end

do

	local function next_copied_occupant(occupants, occupant_jid)

		local next_occupant_jid, raw_occupant = next(occupants, occupant_jid);

		if next_occupant_jid == nil then return nil end

		return next_occupant_jid, occupant_lib.copy(raw_occupant);

	end

	-- FIXME Explain what 'read_only' is supposed to be

	function room_mt:each_occupant(read_only) -- luacheck: ignore 212

		return next_copied_occupant, self._occupants, nil;

	end

end

function room_mt:has_occupant()

	return next(self._occupants, nil) ~= nil

end

function room_mt:get_occupant_by_real_jid(real_jid)

	local occupant_jid = self:get_occupant_jid(real_jid);

	if occupant_jid == nil then return nil end

	return self:get_occupant_by_nick(occupant_jid);

end

function room_mt:save_occupant(occupant)

	occupant = occupant_lib.copy(occupant); -- So that occupant can be modified more

	local id = occupant.nick

	-- Need to maintain _jid_nick secondary index

	local old_occupant = self._occupants[id];

	if old_occupant then

		for real_jid in old_occupant:each_session() do

			self._jid_nick[real_jid] = nil;

		end

	end

	local has_live_session = false

	if occupant.role ~= nil then

		for real_jid, presence in occupant:each_session() do

			if presence.attr.type == nil then

				has_live_session = true

				self._jid_nick[real_jid] = occupant.nick;

			end

		end

		if not has_live_session then

			-- Has no live sessions left; they have left the room.

			occupant.role = nil

		end

	end

	if not has_live_session then

		occupant = nil

	end

	self._occupants[id] = occupant

	return occupant

end

function room_mt:route_to_occupant(occupant, stanza)

	local to = stanza.attr.to;

	for jid in occupant:each_session() do

		stanza.attr.to = jid;

		self:route_stanza(stanza);

	end

	stanza.attr.to = to;

end

-- actor is the attribute table

local function add_item(x, affiliation, role, jid, nick, actor_nick, actor_jid, reason)

	x:tag("item", {affiliation = affiliation or "none"; role = role; jid = jid; nick = nick;})

	if actor_nick or actor_jid then

		x:tag("actor", {nick = actor_nick; jid = actor_jid;}):up()

	end

	if reason then

		x:tag("reason"):text(reason):up()

	end

	x:up();

	return x

end

-- actor is (real) jid

function room_mt:build_item_list(occupant, x, is_anonymous, nick, actor_nick, actor_jid, reason)

	local affiliation = self:get_affiliation(occupant.bare_jid) or "none";

	local role = occupant.role or "none";

	if is_anonymous then

		add_item(x, affiliation, role, nil, nick, actor_nick, actor_jid, reason);

	else

		for real_jid in occupant:each_session() do

			add_item(x, affiliation, role, real_jid, nick, actor_nick, actor_jid, reason);

		end

	end

	return x

end

function room_mt:broadcast_message(stanza)

	if module:fire_event("muc-broadcast-message", {room = self, stanza = stanza}) then

		return true;

	end

	self:broadcast(stanza);

	return true;

end

-- Strip delay tags claiming to be from us

module:hook("muc-occupant-groupchat", function (event)

	local stanza = event.stanza;

	local room = event.room;

	local room_jid = room.jid;

	stanza:maptags(function (child)

		if child.name == "delay" and child.attr["xmlns"] == "urn:xmpp:delay" then

			if child.attr["from"] == room_jid then

				return nil;

			end

		end

		if child.name == "x" and child.attr["xmlns"] == "jabber:x:delay" then

			if child.attr["from"] == room_jid then

				return nil;

			end

		end

		return child;

	end)

end);

-- Broadcast a stanza to all occupants in the room.

-- optionally checks conditional called with (nick, occupant)

function room_mt:broadcast(stanza, cond_func)

	for nick, occupant in self:each_occupant() do

		if cond_func == nil or cond_func(nick, occupant) then

			self:route_to_occupant(occupant, stanza)

		end

	end

end

local function can_see_real_jids(whois, occupant)

	if whois == "anyone" then

		return true;

	elseif whois == "moderators" then

		return valid_roles[occupant.role or "none"] >= valid_roles.moderator;

	end

end

-- Broadcasts an occupant's presence to the whole room

-- Takes the x element that goes into the stanzas

function room_mt:publicise_occupant_status(occupant, x, nick, actor, reason, prev_role, force_unavailable)

	local base_x = x.base or x;

	-- Build real jid and (optionally) occupant jid template presences

	local base_presence do

		-- Try to use main jid's presence

		local pr = occupant:get_presence();

		if pr and (occupant.role ~= nil or pr.attr.type == "unavailable") and not force_unavailable then

			base_presence = st.clone(pr);

		else -- user is leaving but didn't send a leave presence. make one for them

			base_presence = st.presence {from = occupant.nick; type = "unavailable";};

		end

	end

	-- Fire event (before full_p and anon_p are created)

	local event = {

		room = self; stanza = base_presence; x = base_x;

		occupant = occupant; nick = nick; actor = actor;

		reason = reason;

	}

	module:fire_event("muc-build-occupant-presence", event);

	module:fire_event("muc-broadcast-presence", event);

	-- Allow muc-broadcast-presence listeners to change things

	nick = event.nick;

	actor = event.actor;

	reason = event.reason;

	local whois = self:get_whois();

	local actor_nick;

	if actor then

		actor_nick = jid_resource(self:get_occupant_jid(actor));

	end

	local full_p, full_x;

	local function get_full_p()

		if full_p == nil then

			full_x = st.clone(x.full or base_x);

			self:build_item_list(occupant, full_x, false, nick, actor_nick, actor, reason);

			full_p = st.clone(base_presence):add_child(full_x);

		end

		return full_p, full_x;

	end

	local anon_p, anon_x;

	local function get_anon_p()

		if anon_p == nil then

			anon_x = st.clone(x.anon or base_x);

			self:build_item_list(occupant, anon_x, true, nick, actor_nick, nil, reason);

			anon_p = st.clone(base_presence):add_child(anon_x);

		end

		return anon_p, anon_x;

	end

	local self_p, self_x;

	do

		-- Can always see your own full jids

		-- But not allowed to see actor's

		self_x = st.clone(x.self or base_x);

		self:build_item_list(occupant, self_x, false, nick, actor_nick, nil, reason);

		self_p = st.clone(base_presence):add_child(self_x);

	end

	local broadcast_roles = self:get_presence_broadcast();

	-- General populace

	for occupant_nick, n_occupant in self:each_occupant() do

		if occupant_nick ~= occupant.nick then

			local pr;

			if can_see_real_jids(whois, n_occupant) then

				pr = get_full_p();

			elseif occupant.bare_jid == n_occupant.bare_jid then

				pr = self_p;

			else

				pr = get_anon_p();

			end

			if broadcast_roles[occupant.role or "none"] or force_unavailable then

				self:route_to_occupant(n_occupant, pr);

			elseif prev_role and broadcast_roles[prev_role] then

				pr.attr.type = 'unavailable';

				self:route_to_occupant(n_occupant, pr);

			end

		end

	end

	-- Presences for occupant itself

	self_x:tag("status", {code = "110";}):up();

	if occupant.role == nil then

		-- They get an unavailable

		self:route_to_occupant(occupant, self_p);

	else

		-- use their own presences as templates

		for full_jid, pr in occupant:each_session() do

			pr = st.clone(pr);

			pr.attr.to = full_jid;

			pr:add_child(self_x);

			self:route_stanza(pr);

		end

	end

end

function room_mt:send_occupant_list(to, filter)

	local to_bare = jid_bare(to);

	local is_anonymous = false;

	local whois = self:get_whois();

	local broadcast_roles = self:get_presence_broadcast();

	if whois ~= "anyone" then

		local affiliation = self:get_affiliation(to);

		if affiliation ~= "admin" and affiliation ~= "owner" then

			local occupant = self:get_occupant_by_real_jid(to);

			if not (occupant and can_see_real_jids(whois, occupant)) then

				is_anonymous = true;

			end

		end

	end

	local broadcast_bare_jids = {}; -- Track which bare JIDs we have sent presence for

	for occupant_jid, occupant in self:each_occupant() do

		broadcast_bare_jids[occupant.bare_jid] = true;

		if filter == nil or filter(occupant_jid, occupant) then

			local x = st.stanza("x", {xmlns='http://jabber.org/protocol/muc#user'});

			self:build_item_list(occupant, x, is_anonymous and to_bare ~= occupant.bare_jid); -- can always see your own jids

			local pres = st.clone(occupant:get_presence());

			pres.attr.to = to;

			pres:add_child(x);

			module:fire_event("muc-build-occupant-presence", { room = self, occupant = occupant, stanza = pres });

			if to_bare == occupant.bare_jid or broadcast_roles[occupant.role or "none"] then

				self:route_stanza(pres);

			end

		end

	end

	if broadcast_roles.none then

		-- Broadcast stanzas for affiliated users not currently in the MUC

		for affiliated_jid, affiliation, affiliation_data in self:each_affiliation() do

			local nick = affiliation_data and affiliation_data.reserved_nickname;

			if (nick or not is_anonymous) and not broadcast_bare_jids[affiliated_jid]

			and (filter == nil or filter(affiliated_jid, nil)) then

				local from = nick and (self.jid.."/"..nick) or self.jid;

				local pres = st.presence({ to = to, from = from, type = "unavailable" })

					:tag("x", { xmlns = 'http://jabber.org/protocol/muc#user' })

						:tag("item", {