-- 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, ipairs = pairs, ipairs;

local next = next;

local setmetatable = setmetatable;

local dataform = require "util.dataforms";

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

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

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

local st = require "util.stanza";

local log = require "util.logger".init("mod_muc");

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

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

local occupant_lib = module:require "muc/occupant"

local is_kickable_error do

	local kickable_error_conditions = {

		["gone"] = true;

		["internal-server-error"] = true;

		["item-not-found"] = true;

		["jid-malformed"] = true;

		["recipient-unavailable"] = true;

		["redirect"] = true;

		["remote-server-not-found"] = true;

		["remote-server-timeout"] = true;

		["service-unavailable"] = true;

		["malformed error"] = true;

	};

	function is_kickable_error(stanza)

		local cond = select(2, stanza:get_error()) or "malformed error";

		return kickable_error_conditions[cond];

	end

end

local room_mt = {};

room_mt.__index = room_mt;

function room_mt:__tostring()

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

end

function room_mt:get_occupant_jid(real_jid)

	return self._jid_nick[real_jid]

end

local valid_affiliations = {

	outcast = 0;

	none = 1;

	member = 2;

	admin = 3;

	owner = 4;

};

local valid_roles = {

	none = 0;

	visitor = 1;

	participant = 2;

	moderator = 3;

};

function room_mt:get_default_role(affiliation)

	if affiliation == "owner" or affiliation == "admin" then

		return "moderator";

	elseif affiliation == "member" then

		return "participant";

	elseif not affiliation then

		if not self:get_members_only() then

			return self:get_moderated() and "visitor" or "participant";

		end

	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

	function room_mt:each_occupant(read_only)

		return next_copied_occupant, self._occupants, nil;

	end

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 pairs(old_occupant.sessions) do

			self._jid_nick[real_jid] = nil;

		end

	end

	if occupant.role ~= nil and next(occupant.sessions) then

		for real_jid, presence in occupant:each_session() do

			self._jid_nick[real_jid] = occupant.nick;

		end

	else

		occupant = nil

	end

	self._occupants[id] = occupant

end

function room_mt:route_to_occupant(occupant, stanza)

	local to = stanza.attr.to;

	for jid, pr in occupant:each_session() do

		if pr.attr.type ~= "unavailable" then

			stanza.attr.to = jid;

			self:route_stanza(stanza);

		end

	end

	stanza.attr.to = to;

end

-- Adds an item to an "x" element.

-- actor is the attribute table

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

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

	if actor then

		x:tag("actor", actor):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, reason)

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

	local role = occupant.role or "none";

	local actor_attr;

	if actor then

		actor_attr = {nick = select(3,jid_split(self:get_occupant_jid(actor)))};

	end

	if is_anonymous then

		add_item(x, affiliation, role, nil, nick, actor_attr, reason);

	else

		if actor_attr then

			actor_attr.jid = actor;

		end

		for real_jid, session in occupant:each_session() do

			add_item(x, affiliation, role, real_jid, nick, actor_attr, reason);

		end

	end

	return x

end

function room_mt:broadcast_message(stanza)

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

	self:broadcast(stanza);

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

local function get_base_presence(occupant)

	if occupant.role ~= nil then

		-- Try to use main jid's presence

		local pr = occupant:get_presence();

		if pr ~= nil then

			return st.clone(pr);

		end

	end

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

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 function get_presence(is_anonymous)

		local x = st.clone(base_x);

		self:build_item_list(occupant, x, is_anonymous, nick, actor, reason);

		return get_base_presence(occupant):add_child(x), x;

	end

	local full_p, full_x = get_presence(false);

	local anon_p, anon_x;

	local function get_anon_p()

		if anon_p == nil then

			anon_p, anon_x = get_presence(true);

		end

		return anon_p, anon_x;

	end

	local whois = self:get_whois();

	-- General populance

	for nick, n_occupant in self:each_occupant() do

		if nick ~= occupant.nick then

			local pr;

			if can_see_real_jids(whois, occupant) or occupant.bare_jid == n_occupant.bare_jid then

				pr = full_p;

			else

				pr = get_anon_p();

			end

			self:route_to_occupant(n_occupant, pr);

		end

	end

	-- Presences for occupant itself

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

	if occupant.role == nil then

		-- They get an unavailable

		self:route_to_occupant(occupant, full_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;

			-- You can always see your own full jids

			pr:add_child(full_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 = true;

	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 or can_see_real_jids(whois, occupant) then

				is_anonymous = false;

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

	};

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

	reply:add_child(form:form(nil, "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)

	event.reply:tag("feature", {var = event.room:get_moderated() and "muc_moderated" or "muc_unmoderated"}):up();

end);

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

	event.reply:tag("feature", {var = event.room:get_members_only() and "muc_membersonly" or "muc_open"}):up();

end);

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

	event.reply:tag("feature", {var = event.room:get_persistent() and "muc_persistent" or "muc_temporary"}):up();

end);

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

	event.reply:tag("feature", {var = event.room:get_hidden() and "muc_hidden" or "muc_public"}):up();

end);

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

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

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

	return self._data['subject'], self._data['subject_from']

end

local function create_subject_message(from, subject)

	return st.message({from = from; type = "groupchat"})

		:tag('subject'):text(subject):up();

end

function room_mt:send_subject(to)

	local msg = create_subject_message(self:get_subject());

	msg.attr.to = to;

	self:route_stanza(msg);

end

function room_mt:set_subject(current_nick, subject)

	if subject == "" then subject = nil; end

	self._data['subject'] = subject;

	self._data['subject_from'] = current_nick;

	if self.save then self:save(); end

	local msg = create_subject_message(current_nick, subject);

	self:broadcast_message(msg);

	return true;

end

function room_mt:handle_kickable(origin, stanza)

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