/*

 * xmpp_muc.c   -- Jabber MUC protocol handling

 *

 * Copyright (C) 2008-2010 Frank Zschockelt <mcabber@freakysoft.de>

 * Copyright (C) 2005-2010 Mikael Berthe <mikael@lilotux.net>

 * Copyrigth (C) 2010      Myhailo Danylenko <isbear@ukrposte.net>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or (at

 * your option) any later version.

 *

 * This program is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307

 * USA

 */

#include <string.h>

#include <stdlib.h>

#include "xmpp_helper.h"

#include "xmpp_muc.h"

#include "events.h"

#include "hooks.h"

#include "screen.h"

#include "hbuf.h"

#include "roster.h"

#include "commands.h"

#include "settings.h"

#include "utils.h"

#include "histolog.h"

extern enum imstatus mystatus;

extern gchar *mystatusmsg;

static GSList *invitations = NULL;

static void decline_invitation(event_muc_invitation *invitation, const char *reason)

{

  // cut and paste from xmpp_room_invite

  LmMessage *m;

  LmMessageNode *x, *y;

  if (!invitation) return;

  if (!invitation->to || !invitation->from) return;

  m = lm_message_new(invitation->to, LM_MESSAGE_TYPE_MESSAGE);

  x = lm_message_node_add_child(m->node, "x", NULL);

  lm_message_node_set_attribute(x, "xmlns", NS_MUC_USER);

  y = lm_message_node_add_child(x, "decline", NULL);

  lm_message_node_set_attribute(y, "to", invitation->from);

  if (reason)

    lm_message_node_add_child(y, "reason", reason);

  lm_connection_send(lconnection, m, NULL);

  lm_message_unref(m);

}

void destroy_event_muc_invitation(event_muc_invitation *invitation)

{

  invitations = g_slist_remove(invitations, invitation);

  g_free(invitation->to);

  g_free(invitation->from);

  g_free(invitation->passwd);

  g_free(invitation->reason);

  g_free(invitation->evid);

  g_free(invitation);

}

// invitation event handler

// TODO: if event is accepted, check if other events to the same room exist and

// destroy them? (need invitation registry list for that)

static gboolean evscallback_invitation(guint evcontext, const char *arg, gpointer userdata)

{

  event_muc_invitation *invitation = userdata;

  // Sanity check

  if (G_UNLIKELY(!invitation)) {

    // Shouldn't happen.

    scr_LogPrint(LPRINT_LOGNORM, "Error in evs callback.");

    return FALSE;

  }

  if (evcontext == EVS_CONTEXT_TIMEOUT) {

    scr_LogPrint(LPRINT_LOGNORM, "Invitation event %s timed out, cancelled.", invitation->to);

    return FALSE;

  }

  if (evcontext == EVS_CONTEXT_CANCEL) {

    scr_LogPrint(LPRINT_LOGNORM, "Invitation event %s cancelled.", invitation->to);

    return FALSE;

  }

  if (!(evcontext == EVS_CONTEXT_ACCEPT || evcontext == EVS_CONTEXT_REJECT))

    return FALSE;

  // Ok, let's work now

  if (evcontext == EVS_CONTEXT_ACCEPT) {

    char *nickname = default_muc_nickname(invitation->to);

    xmpp_room_join(invitation->to, nickname, invitation->passwd);

    g_free(nickname);

  } else {

    scr_LogPrint(LPRINT_LOGNORM, "Invitation to %s refused.", invitation->to);

    if (invitation->reply)

      decline_invitation(invitation, arg);

  }

  return FALSE;

}

// Join a MUC room

void xmpp_room_join(const char *room, const char *nickname, const char *passwd)

{

  LmMessage *x;

  LmMessageNode *y;

  gchar *roomid;

  GSList *room_elt;

  if (!xmpp_is_online() || !room)

    return;

  if (!nickname)        return;

  roomid = g_strdup_printf("%s/%s", room, nickname);

  if (check_jid_syntax(roomid)) {

    scr_LogPrint(LPRINT_NORMAL, "<%s/%s> is not a valid Jabber room", room,

                 nickname);

    g_free(roomid);

    return;

  }

  room_elt = roster_find(room, jidsearch, ROSTER_TYPE_USER|ROSTER_TYPE_ROOM);

  // Add room if it doesn't already exist

  if (!room_elt) {

    room_elt = roster_add_user(room, NULL, NULL, ROSTER_TYPE_ROOM,

                               sub_none, -1);

  } else {

    // Make sure this is a room (it can be a conversion user->room)

    buddy_settype(room_elt->data, ROSTER_TYPE_ROOM);

  }

  // If insideroom is TRUE, this is a nickname change and we don't care here

  if (!buddy_getinsideroom(room_elt->data)) {

    // We're trying to enter a room

    buddy_setnickname(room_elt->data, nickname);

  }

  // Send the XML request

  x = lm_message_new_presence(mystatus, roomid, mystatusmsg);

  xmpp_insert_entity_capabilities(x->node, mystatus); // Entity Caps (XEP-0115)

  y = lm_message_node_add_child(x->node, "x", NULL);

  lm_message_node_set_attribute(y, "xmlns", NS_MUC);

  if (passwd)

    lm_message_node_add_child(y, "password", passwd);

  lm_connection_send(lconnection, x, NULL);

  lm_message_unref(x);

  g_free(roomid);

}

// Invite a user to a MUC room

// room syntax: "room@server"

// reason can be null.

void xmpp_room_invite(const char *room, const char *fjid, const char *reason)

{

  LmMessage *msg;

  LmMessageNode *x, *y;

  if (!xmpp_is_online() || !room || !fjid)

    return;

  msg = lm_message_new(room, LM_MESSAGE_TYPE_MESSAGE);

  x = lm_message_node_add_child(msg->node, "x", NULL);

  lm_message_node_set_attribute(x, "xmlns", NS_MUC_USER);

  y = lm_message_node_add_child(x, "invite", NULL);

  lm_message_node_set_attribute(y, "to", fjid);

  if (reason)

    lm_message_node_add_child(y, "reason", reason);

  lm_connection_send(lconnection, msg, NULL);

  lm_message_unref(msg);

}

int xmpp_room_setattrib(const char *roomid, const char *fjid,

                        const char *nick, struct role_affil ra,

                        const char *reason)

{

  LmMessage *iq;

  LmMessageNode *query, *x;

  if (!xmpp_is_online() || !roomid)

    return 1;

  if (!fjid && !nick) return 1;

  if (check_jid_syntax((char*)roomid)) {

    scr_LogPrint(LPRINT_NORMAL, "<%s> is not a valid Jabber id", roomid);

    return 1;

  }

  if (fjid && check_jid_syntax((char*)fjid)) {

    scr_LogPrint(LPRINT_NORMAL, "<%s> is not a valid Jabber id", fjid);

    return 1;

  }

  if (ra.type == type_affil && ra.val.affil == affil_outcast && !fjid)

    return 1; // Shouldn't happen (jid mandatory when banning)

  iq = lm_message_new_with_sub_type(roomid, LM_MESSAGE_TYPE_IQ,

                                    LM_MESSAGE_SUB_TYPE_SET);

  query = lm_message_node_add_child(iq->node, "query", NULL);

  lm_message_node_set_attribute(query, "xmlns", NS_MUC_ADMIN);

  x = lm_message_node_add_child(query, "item", NULL);

  if (fjid) {

    lm_message_node_set_attribute(x, "jid", fjid);

  } else { // nickname

    lm_message_node_set_attribute(x, "nick", nick);

  }

  if (ra.type == type_affil)

    lm_message_node_set_attribute(x, "affiliation", straffil[ra.val.affil]);

  else if (ra.type == type_role)

    lm_message_node_set_attribute(x, "role", strrole[ra.val.role]);

  if (reason)

    lm_message_node_add_child(x, "reason", reason);

  lm_message_unref(iq);

  return 0;

}

// Unlock a MUC room

// room syntax: "room@server"

void xmpp_room_unlock(const char *room)

{

  LmMessageNode *node;

  LmMessage *iq;

  if (!xmpp_is_online() || !room)

    return;

  iq = lm_message_new_with_sub_type(room, LM_MESSAGE_TYPE_IQ,

                                    LM_MESSAGE_SUB_TYPE_SET);

  node = lm_message_node_add_child(iq->node, "query", NULL);

  lm_message_node_set_attribute(node, "xmlns", NS_MUC_OWNER);

  node = lm_message_node_add_child(node, "x", NULL);

  lm_message_node_set_attributes(node, "xmlns", "jabber:x:data",

                                 "type", "submit", NULL);

  lm_message_unref(iq);

}

// Destroy a MUC room

// room syntax: "room@server"

void xmpp_room_destroy(const char *room, const char *venue, const char *reason)

{

  LmMessage *iq;

  LmMessageNode *query, *x;

  if (!xmpp_is_online() || !room)

    return;

  iq = lm_message_new_with_sub_type(room, LM_MESSAGE_TYPE_IQ,

                                    LM_MESSAGE_SUB_TYPE_SET);

  query = lm_message_node_add_child(iq->node, "query", NULL);

  lm_message_node_set_attribute(query, "xmlns", NS_MUC_OWNER);

  x = lm_message_node_add_child(query, "destroy", NULL);

  if (venue && *venue)

    lm_message_node_set_attribute(x, "jid", venue);

  if (reason)

    lm_message_node_add_child(x, "reason", reason);

  lm_message_unref(iq);

}

//  muc_get_item_info(...)

// Get room member's information from xmlndata.

// The variables must be initialized before calling this function,

// because they are not touched if the relevant information is missing.

static void muc_get_item_info(const char *from, LmMessageNode *xmldata,

                              enum imrole *mbrole, enum imaffiliation *mbaffil,

                              const char **mbjid, const char **mbnick,

                              const char **actorjid, const char **reason)

{

  LmMessageNode *y, *z;

  const char *p;

  y = lm_message_node_find_child(xmldata, "item");

  if (!y)

    return;

  p = lm_message_node_get_attribute(y, "affiliation");

  if (p) {

    if (!strcmp(p, "owner"))        *mbaffil = affil_owner;

    else if (!strcmp(p, "admin"))   *mbaffil = affil_admin;

    else if (!strcmp(p, "member"))  *mbaffil = affil_member;

    else if (!strcmp(p, "outcast")) *mbaffil = affil_outcast;

    else if (!strcmp(p, "none"))    *mbaffil = affil_none;

    else scr_LogPrint(LPRINT_LOGNORM, "<%s>: Unknown affiliation \"%s\"",

                      from, p);

  }

  p = lm_message_node_get_attribute(y, "role");

  if (p) {

    if (!strcmp(p, "moderator"))        *mbrole = role_moderator;

    else if (!strcmp(p, "participant")) *mbrole = role_participant;

    else if (!strcmp(p, "visitor"))     *mbrole = role_visitor;

    else if (!strcmp(p, "none"))        *mbrole = role_none;

    else scr_LogPrint(LPRINT_LOGNORM, "<%s>: Unknown role \"%s\"",

                      from, p);

  }

  *mbjid = lm_message_node_get_attribute(y, "jid");

  *mbnick = lm_message_node_get_attribute(y, "nick");

  // For kick/ban, there can be actor and reason tags

  *reason = lm_message_node_get_child_value(y, "reason");

  if (*reason && !**reason)

    *reason = NULL;

  z = lm_message_node_find_child(y, "actor");

  if (z)

    *actorjid = lm_message_node_get_attribute(z, "jid");

}

//  muc_handle_join(...)

// Handle a join event in a MUC room.

// This function will return the new_member value TRUE if somebody else joins

// the room (and FALSE if _we_ are joining the room).

static bool muc_handle_join(const GSList *room_elt, const char *rname,

                            const char *roomjid, const char *ournick,

                            enum room_printstatus printstatus,

                            time_t usttime, int log_muc_conf)

{

  bool new_member = FALSE; // True if somebody else joins the room (not us)

  gchar *mbuf;

  enum room_flagjoins flagjoins;

  if (!buddy_getinsideroom(room_elt->data)) {

    // We weren't inside the room yet.  Now we are.

    // However, this could be a presence packet from another room member

    buddy_setinsideroom(room_elt->data, TRUE);

    // Set the message flag unless we're already in the room buffer window

    scr_setmsgflag_if_needed(roomjid, FALSE);

    // Add a message to the tracelog file

    mbuf = g_strdup_printf("You have joined %s as \"%s\"", roomjid, ournick);

    scr_LogPrint(LPRINT_LOGNORM, "%s", mbuf);

    g_free(mbuf);

    mbuf = g_strdup_printf("You have joined as \"%s\"", ournick);

    // The 1st presence message could be for another room member

    if (strcmp(ournick, rname)) {