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

local setmetatable = setmetatable;

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

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

local muc_domain = nil; --module:get_host();

local default_history_length, max_history_length = 20, math.huge;

------------

local presence_filters = {["http://jabber.org/protocol/muc"]=true;["http://jabber.org/protocol/muc#user"]=true};

local function presence_filter(tag)

	if presence_filters[tag.attr.xmlns] then

		return nil;

	end

	return tag;

end

local function get_filtered_presence(stanza)

	return st.clone(stanza):maptags(presence_filter);

end

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;

};

local function get_error_condition(stanza)

	local _, condition = stanza:get_error();

	return condition or "malformed error";

end

local function is_kickable_error(stanza)

	local cond = get_error_condition(stanza);

	return kickable_error_conditions[cond] and cond;

end

-----------

local room_mt = {};

room_mt.__index = room_mt;

function room_mt:__tostring()

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

end

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:broadcast_presence(stanza, sid, code, nick)

	stanza = get_filtered_presence(stanza);

	local occupant = self._occupants[stanza.attr.from];

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

		:tag("item", {affiliation=occupant.affiliation or "none", role=occupant.role or "none", nick=nick}):up();

	if code then

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

	end

	self:broadcast_except_nick(stanza, stanza.attr.from);

	local me = self._occupants[stanza.attr.from];

	if me then

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

		stanza.attr.to = sid;

		self:_route_stanza(stanza);

	end

end

function room_mt:broadcast_message(stanza, historic)

	local to = stanza.attr.to;

	for occupant, o_data in pairs(self._occupants) do

		for jid in pairs(o_data.sessions) do

			stanza.attr.to = jid;

			self:_route_stanza(stanza);

		end

	end

	stanza.attr.to = to;

	if historic then -- add to history

		return self:save_to_history(stanza)

	end

end

function room_mt:save_to_history(stanza)

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

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

	stanza = st.clone(stanza);

	stanza.attr.to = "";

	local stamp = datetime.datetime();

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

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

	local entry = { stanza = stanza, stamp = stamp };

	t_insert(history, entry);

	while #history > (self._data.history_length or default_history_length) do t_remove(history, 1) end

end

function room_mt:broadcast_except_nick(stanza, nick)

	for rnick, occupant in pairs(self._occupants) do

		if rnick ~= nick then

			for jid in pairs(occupant.sessions) do

				stanza.attr.to = jid;

				self:_route_stanza(stanza);

			end

		end

	end

end

function room_mt:send_occupant_list(to)

	local current_nick = self._jid_nick[to];

	for occupant, o_data in pairs(self._occupants) do

		if occupant ~= current_nick then

			local pres = get_filtered_presence(o_data.sessions[o_data.jid]);

			pres.attr.to, pres.attr.from = to, occupant;

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

				:tag("item", {affiliation=o_data.affiliation or "none", role=o_data.role or "none"}):up();

			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

-- Get history for 'to'

function room_mt:get_history(to, maxchars, maxstanzas, since)

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

	if not history then return end

	local history_len = #history

	maxstanzas = maxstanzas or history_len

	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.stamp then break; end

		if n + 1 > maxstanzas then break; end

		n = n + 1;

	end

	local i = history_len-n+1

	return function()

		if i > history_len then return nil end

		local entry = history[i]

		local msg = entry.stanza

		msg.attr.to = to;

		i = i + 1

		return msg

	end

end

function room_mt:send_history(to, stanza)

	local maxchars, maxstanzas, since = parse_history(stanza)

	for msg in self:get_history(to, maxchars, maxstanzas, since) do

		self:_route_stanza(msg);

	end

end

function room_mt:send_subject(to)

	if self._data['subject'] then

		self:_route_stanza(st.message({type='groupchat', from=self._data['subject_from'] or self.jid, to=to}):tag("subject"):text(self._data['subject']));

	end

end

function room_mt:get_disco_info(stanza)

	local count = 0; for _ in pairs(self._occupants) do count = count + 1; end

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

		:tag("identity", {category="conference", type="text", name=self:get_name()}):up()

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

		:tag("feature", {var=self:get_password() and "muc_passwordprotected" or "muc_unsecured"}):up()

		:tag("feature", {var=self:get_moderated() and "muc_moderated" or "muc_unmoderated"}):up()

		:tag("feature", {var=self:get_members_only() and "muc_membersonly" or "muc_open"}):up()

		:tag("feature", {var=self:get_persistent() and "muc_persistent" or "muc_temporary"}):up()

		:tag("feature", {var=self:get_hidden() and "muc_hidden" or "muc_public"}):up()

		:tag("feature", {var=self._data.whois ~= "anyone" and "muc_semianonymous" or "muc_nonanonymous"}):up()

		:add_child(dataform.new({

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

			{ name = "muc#roominfo_description", label = "Description", value = "" },

			{ name = "muc#roominfo_occupants", label = "Number of occupants", value = tostring(count) }

		}):form({["muc#roominfo_description"] = self:get_description()}, 'result'))

	;

end

function room_mt:get_disco_items(stanza)

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

	for room_jid in pairs(self._occupants) do

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

	end

	return reply;

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 = st.message({type='groupchat', from=current_nick})

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

	self:broadcast_message(msg, false);

	return true;

end

function room_mt:handle_kickable(origin, stanza)

	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

	local kick_stanza = st.presence({type='unavailable', from=stanza.attr.from, to=stanza.attr.to})

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

	self:handle_unavailable_to_occupant(origin, kick_stanza); -- send unavailable

	return true;

end

function room_mt:set_name(name)

	if name == "" or type(name) ~= "string" or name == (jid_split(self.jid)) then name = nil; end

	if self._data.name ~= name then

		self._data.name = name;

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

	end

end

function room_mt:get_name()

	return self._data.name or jid_split(self.jid);

end

function room_mt:set_description(description)

	if description == "" or type(description) ~= "string" then description = nil; end

	if self._data.description ~= description then

		self._data.description = description;

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

	end

end

function room_mt:get_description()

	return self._data.description;

end

function room_mt:set_password(password)

	if password == "" or type(password) ~= "string" then password = nil; end

	if self._data.password ~= password then

		self._data.password = password;

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

	end

end

function room_mt:get_password()

	return self._data.password;

end

function room_mt:set_moderated(moderated)

	moderated = moderated and true or nil;

	if self._data.moderated ~= moderated then

		self._data.moderated = moderated;

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

	end

end

function room_mt:get_moderated()

	return self._data.moderated;

end

function room_mt:set_members_only(members_only)

	members_only = members_only and true or nil;

	if self._data.members_only ~= members_only then

		self._data.members_only = members_only;

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

	end

end

function room_mt:get_members_only()

	return self._data.members_only;

end

function room_mt:set_persistent(persistent)

	persistent = persistent and true or nil;

	if self._data.persistent ~= persistent then

		self._data.persistent = persistent;

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

	end

end

function room_mt:get_persistent()

	return self._data.persistent;

end

function room_mt:set_hidden(hidden)

	hidden = hidden and true or nil;

	if self._data.hidden ~= hidden then

		self._data.hidden = hidden;

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

	end

end

function room_mt:get_hidden()

	return self._data.hidden;

end

function room_mt:get_public()

	return not self:get_hidden();

end