-- 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 st = require "util.stanza";

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

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

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()

	-- overriden 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"];

	});

	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);

--- 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

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

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; 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

-- 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, base_x, nick, actor, reason)

	-- 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 (pr.attr.type ~= "unavailable" and occupant.role ~= nil) 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-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 = select(3, jid_split(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(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(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;

	if can_see_real_jids(whois, occupant) then

		self_p, self_x = get_full_p();

	else

		-- Can always see your own full jids

		-- But not allowed to see actor's

		self_x = st.clone(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

	-- General populance

	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

			self:route_to_occupant(n_occupant, pr);

		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();

	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

	for occupant_jid, occupant in self:each_occupant() do

		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);

			self:route_stanza(pres);

		end

	end

end

function room_mt:get_disco_info(stanza)

	local reply = st.reply(stanza):query("http://jabber.org/protocol/disco#info");

	local form = dataform.new {

		{ name = "FORM_TYPE", type = "hidden", value = "http://jabber.org/protocol/muc#roominfo" };

	};

	local formdata = {};

	module:fire_event("muc-disco#info", {room = self; reply = reply; form = form, formdata = formdata ;});

	reply:add_child(form:form(formdata, "result"));

	return reply;

end

module:hook("muc-disco#info", function(event)

	event.reply:tag("feature", {var = "http://jabber.org/protocol/muc"}):up();

end);

module:hook("muc-disco#info", function(event)

	table.insert(event.form, { name = "muc#roominfo_occupants", label = "Number of occupants" });

	event.formdata["muc#roominfo_occupants"] = tostring(iterators.count(event.room:each_occupant()));

end);

function room_mt:get_disco_items(stanza)

	local reply = st.reply(stanza):query("http://jabber.org/protocol/disco#items");

	for room_jid in self:each_occupant() do

		reply:tag("item", {jid = room_jid, name = room_jid:match("/(.*)")}):up();

	end

	return reply;

end

function room_mt:handle_kickable(origin, stanza) -- luacheck: ignore 212

	local real_jid = stanza.attr.from;

	local occupant = self:get_occupant_by_real_jid(real_jid);

	if occupant == nil then return nil; end

	local type, condition, text = stanza:get_error();

	local error_message = "Kicked: "..(condition and condition:gsub("%-", " ") or "presence error");

	if text then

		error_message = error_message..": "..text;

	end

	occupant:set_session(real_jid, st.presence({type="unavailable"})

		:tag('status'):text(error_message));

	self:save_occupant(occupant);

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

		:tag("status", {code = "307"})

	self:publicise_occupant_status(occupant, x);

	if occupant.jid == real_jid then -- Was last session

		module:fire_event("muc-occupant-left", {room = self; nick = occupant.nick; occupant = occupant;});

	end

	return true;

end

if not module:get_option_boolean("muc_compat_create", true) then

	module:hook("muc-room-pre-create", function(event)

		local origin, stanza = event.origin, event.stanza;