-- 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 t_insert, t_remove = table.insert, table.remove;

local gettime = os.time;

local datetime = require "util.datetime";

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 default_history_length, max_history_length = 20, math.huge;

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

function room_mt:lock()

	module:fire_event("muc-room-locked", { room = self });

	self.locked = true

end

function room_mt:unlock()

	module:fire_event("muc-room-unlocked", { room = self });

	self.locked = nil

end

function room_mt:is_locked()

	return not not self.locked

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

	local role = occupant.role;

	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, historic)

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

	self:broadcast(stanza);

end

-- add to history

module:hook("muc-broadcast-message", function(event)

	if event.historic then

		local room = event.room

		local history = room._data['history'];

		if not history then history = {}; room._data['history'] = history; end

		local stanza = st.clone(event.stanza);

		stanza.attr.to = "";

		local ts = gettime();

		local stamp = datetime.datetime(ts);

		stanza:tag("delay", {xmlns = "urn:xmpp:delay", from = module.host, stamp = stamp}):up(); -- XEP-0203

		stanza:tag("x", {xmlns = "jabber:x:delay", from = module.host, stamp = datetime.legacy()}):up(); -- XEP-0091 (deprecated)

		local entry = { stanza = stanza, timestamp = ts };

		t_insert(history, entry);

		while #history > room:get_historylength() do t_remove(history, 1) end

	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

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

-- Takes (and modifies) the x element that goes into the stanzas

function room_mt:publicise_occupant_status(occupant, full_x, actor, reason)

	local anon_x;

	local has_anonymous = self:get_whois() ~= "anyone";

	if has_anonymous then

		anon_x = st.clone(full_x);

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

	end

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

	-- General populance

	local full_p

	if occupant.role ~= nil then

		-- Try to use main jid's presence

		local pr = occupant:get_presence();

		if pr ~= nil then

			full_p = st.clone(pr);

		end

	end

	if full_p == nil then

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

	end

	local anon_p;

	if has_anonymous then

		anon_p = st.clone(full_p);

		anon_p:add_child(anon_x);

	end

	full_p:add_child(full_x);

	for nick, n_occupant in self:each_occupant() do

		if nick ~= occupant.nick or n_occupant.role == nil then

			local pr = full_p;

			if has_anonymous and n_occupant.role ~= "moderator" and occupant.bare_jid ~= n_occupant.bare_jid then

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

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

				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

end

function room_mt:send_occupant_list(to, filter)

	local to_bare = jid_bare(to);

	local is_anonymous = true;

	if self:get_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 occupant.role ~= "moderator" 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

local function parse_history(stanza)

	local x_tag = stanza:get_child("x", "http://jabber.org/protocol/muc");

	local history_tag = x_tag and x_tag:get_child("history", "http://jabber.org/protocol/muc");

	if not history_tag then

		return nil, 20, nil

	end

	local maxchars = tonumber(history_tag.attr.maxchars);

	local maxstanzas = tonumber(history_tag.attr.maxstanzas);

	-- messages received since the UTC datetime specified

	local since = history_tag.attr.since;

	if since then

		since = datetime.parse(since);

	end

	-- messages received in the last "X" seconds.

	local seconds = tonumber(history_tag.attr.seconds);

	if seconds then

		seconds = gettime() - seconds

		if since then

			since = math.max(since, seconds);

		else

			since = seconds;

		end

	end

	return maxchars, maxstanzas, since

end

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

	local room = event.room

	local history = room._data['history']; -- send discussion history

	if not history then return nil end

	local history_len = #history

	local to = event.to

	local maxchars = event.maxchars

	local maxstanzas = event.maxstanzas or history_len

	local since = event.since

	local n = 0;

	local charcount = 0;

	for i=history_len,1,-1 do

		local entry = history[i];

		if maxchars then

			if not entry.chars then

				entry.stanza.attr.to = "";

				entry.chars = #tostring(entry.stanza);

			end

			charcount = charcount + entry.chars + #to;

			if charcount > maxchars then break; end

		end

		if since and since > entry.timestamp then break; end

		if n + 1 > maxstanzas then break; end