-- Prosody IM

-- Copyright (C) 2008-2010 Matthew Wild

-- Copyright (C) 2008-2010 Waqas Hussain

--

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

		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

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

function room_mt:send_history(to, stanza)

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

	if history then

		local x_tag = stanza and 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");

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

		if maxchars then maxchars = math.floor(maxchars); end

		local maxstanzas = math.floor(history_tag and tonumber(history_tag.attr.maxstanzas) or #history);

		if not history_tag then maxstanzas = 20; end

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

		if seconds then seconds = datetime.datetime(os.time() - math.floor(seconds)); end

		local since = history_tag and history_tag.attr.since;

		if since then since = datetime.parse(since); since = since and datetime.datetime(since); end

		if seconds and (not since or since < seconds) then since = seconds; end

		local n = 0;

		local charcount = 0;

		for i=#history,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

		for i=#history-n+1,#history do

			local msg = history[i].stanza;

			msg.attr.to = to;

			self:_route_stanza(msg);

		end

	end

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

			{ 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

local function build_unavailable_presence_from_error(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

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

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

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

function room_mt:set_public(public)

	return self:set_hidden(not public);

end

function room_mt:set_changesubject(changesubject)

	changesubject = changesubject and true or nil;

	if self._data.changesubject ~= changesubject then

		self._data.changesubject = changesubject;

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

	end

end

function room_mt:get_changesubject()

	return self._data.changesubject;

end

function room_mt:get_historylength()

	return self._data.history_length or default_history_length;

end

function room_mt:set_historylength(length)

	length = math.min(tonumber(length) or default_history_length, max_history_length or math.huge);

	if length == default_history_length then

		length = nil;

	end

	self._data.history_length = length;

end

local valid_whois = { moderators = true, anyone = true };

function room_mt:set_whois(whois)

	if valid_whois[whois] and self._data.whois ~= whois then

		self._data.whois = whois;

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

	end