/*

 * xmpp_iq.c    -- Jabber protocol IQ-related stuff

 *

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

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

 * Parts come from the centericq project:

 * Copyright (C) 2002-2005 by Konstantin Klyagin <konst@konst.org.ua>

 * Some small parts come from the Pidgin project <http://pidgin.im/>

 *

 * 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 <sys/utsname.h>

#include "xmpp_helper.h"

#include "commands.h"

#include "screen.h"

#include "utils.h"

#include "logprint.h"

#include "settings.h"

#include "caps.h"

#include "main.h"

extern struct xmpp_error xmpp_errors[];

static LmHandlerResult handle_iq_command_set_status(LmMessageHandler *h,

                                                    LmConnection *c,

                                                    LmMessage *m,

                                                    gpointer ud);

static LmHandlerResult handle_iq_command_leave_groupchats(LmMessageHandler *h,

                                                          LmConnection *c,

                                                          LmMessage *m,

                                                          gpointer ud);

inline double seconds_since_last_use(void);

struct adhoc_command {

  char *name;

  char *description;

  bool only_for_self;

  LmHandleMessageFunction callback;

};

const struct adhoc_command adhoc_command_list[] = {

  { "http://jabber.org/protocol/rc#set-status",

    "Change client status",

    1,

    &handle_iq_command_set_status },

  { "http://jabber.org/protocol/rc#leave-groupchats",

    "Leave groupchat(s)",

    1,

    &handle_iq_command_leave_groupchats },

  { NULL, NULL, 0, NULL },

};

struct adhoc_status {

  char *name;   // the name used by adhoc

  char *description;

  char *status; // the string, used by setstus

};

// It has to match imstatus of roster.h!

const struct adhoc_status adhoc_status_list[] = {

  {"offline", "Offline", "offline"},

  {"online", "Online", "avail"},

  {"chat", "Chat", "free"},

  {"dnd", "Do not disturb", "dnd"},

  {"xd", "Extended away", "notavail"},

  {"away", "Away", "away"},

#ifdef WITH_DEPRECATED_STATUS_INVISIBLE

  {"invisible", "Invisible", "invisible"},

#endif

  {NULL, NULL, NULL},

};

static char *generate_session_id(char *prefix)

{

  char *result;

  static int counter = 0;

  counter++;

  // TODO better use timestamp?

  result = g_strdup_printf("%s-%i", prefix, counter);

  return result;

}

static LmMessage *lm_message_new_iq_error(LmMessage *m, guint error)

{

  LmMessage *r;

  LmMessageNode *err;

  int i;

  for (i = 0; xmpp_errors[i].code; ++i)

    if (xmpp_errors[i].code == error)

      break;

  g_return_val_if_fail(xmpp_errors[i].code > 0, NULL);

  r = lm_message_new_iq_from_query(m, LM_MESSAGE_SUB_TYPE_ERROR);

  err = lm_message_node_add_child(r->node, "error", NULL);

  lm_message_node_set_attribute(err, "code", xmpp_errors[i].code_str);

  lm_message_node_set_attribute(err, "type", xmpp_errors[i].type);

  lm_message_node_set_attribute

          (lm_message_node_add_child(err,

                                     xmpp_errors[i].condition, NULL),

           "xmlns", NS_XMPP_STANZAS);

  return r;

}

void send_iq_error(LmConnection *c, LmMessage *m, guint error)

{

  LmMessage *r;

  r = lm_message_new_iq_error(m, error);

  lm_connection_send(c, r, NULL);

  lm_message_unref(r);

}

static void lm_message_node_add_dataform_result(LmMessageNode *node,

                                                const char *message)

{

  LmMessageNode *x, *field;

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

  lm_message_node_set_attributes(x,

                                 "type", "result",

                                 "xmlns", "jabber:x:data",

                                 NULL);

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

  lm_message_node_set_attributes(field,

                                 "type", "text-single",

                                 "var", "message",

                                 NULL);

  lm_message_node_add_child(field, "value", message);

}

// Dummy handler to ignore IQ response

LmHandlerResult handle_iq_dummy(LmMessageHandler *h, LmConnection *c,

                                 LmMessage *m, gpointer ud)

{

  LmMessageSubType mstype = lm_message_get_sub_type(m);

  if (mstype == LM_MESSAGE_SUB_TYPE_ERROR) {

    display_server_error(lm_message_node_get_child(m->node, "error"),

                         lm_message_get_from(m));

  }

  return LM_HANDLER_RESULT_REMOVE_MESSAGE;

}

static LmHandlerResult handle_iq_commands_list(LmMessageHandler *h,

                                               LmConnection *c,

                                               LmMessage *m, gpointer ud)

{

  LmMessage *iq;

  LmMessageNode *query;

  const char *requester_jid;

  const struct adhoc_command *command;

  const char *node;

  gboolean from_self;

  iq = lm_message_new_iq_from_query(m, LM_MESSAGE_SUB_TYPE_RESULT);

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

  lm_message_node_set_attribute(query, "xmlns", NS_COMMANDS);

  node = lm_message_node_get_attribute

          (lm_message_node_get_child(m->node, "query"),

           "node");

  if (node)

    lm_message_node_set_attribute(query, "node", node);

  requester_jid = lm_message_get_from(m);

  from_self = jid_equal(lm_connection_get_jid(c), requester_jid);

  for (command = adhoc_command_list ; command->name ; command++) {

    if (!command->only_for_self || from_self) {

      lm_message_node_set_attributes

              (lm_message_node_add_child(query, "item", NULL),

               "node", command->name,

               "name", command->description,

               "jid", lm_connection_get_jid(c),

               NULL);

    }

  }

  lm_connection_send(c, iq, NULL);

  lm_message_unref(iq);

  return LM_HANDLER_RESULT_REMOVE_MESSAGE;

}

static LmHandlerResult handle_iq_command_set_status(LmMessageHandler *h,

                                                    LmConnection *c,

                                                    LmMessage *m, gpointer ud)

{

  const char *action, *node;

  char *sessionid;

  LmMessage *iq;

  LmMessageNode *command, *x, *y;

  const struct adhoc_status *s;

  x = lm_message_node_get_child(m->node, "command");

  action = lm_message_node_get_attribute(x, "action");

  node = lm_message_node_get_attribute(x, "node");

  sessionid = (char *)lm_message_node_get_attribute(x, "sessionid");

  iq = lm_message_new_iq_from_query(m, LM_MESSAGE_SUB_TYPE_RESULT);

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

  lm_message_node_set_attribute(command, "node", node);

  lm_message_node_set_attribute(command, "xmlns", NS_COMMANDS);

  if (!sessionid) {

    sessionid = generate_session_id("set-status");

    lm_message_node_set_attribute(command, "sessionid", sessionid);

    g_free(sessionid);

    sessionid = NULL;

    lm_message_node_set_attribute(command, "status", "executing");

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

    lm_message_node_set_attribute(x, "type", "form");

    lm_message_node_set_attribute(x, "xmlns", "jabber:x:data");

    lm_message_node_add_child(x, "title", "Change Status");

    lm_message_node_add_child(x, "instructions",

                              "Choose the status and status message");

    // TODO see if factorisation is possible

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

    lm_message_node_set_attribute(y, "type", "hidden");

    lm_message_node_set_attribute(y, "var", "FORM_TYPE");

    lm_message_node_add_child(y, "value", "http://jabber.org/protocol/rc");

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

    lm_message_node_set_attributes(y,

                                   "type", "list-single",

                                   "var", "status",

                                   "label", "Status",

                                   NULL);

    lm_message_node_add_child(y, "required", NULL);

    // XXX: ugly

    lm_message_node_add_child(y, "value",

                              adhoc_status_list[xmpp_getstatus()].name);

    for (s = adhoc_status_list; s->name; s++) {

        LmMessageNode *option = lm_message_node_add_child(y, "option", NULL);

        lm_message_node_add_child(option, "value", s->name);

        lm_message_node_set_attribute(option, "label", s->description);

    }

    // TODO add priority ?

    // I do not think this is useful, user should not have to care of the

    // priority like gossip and gajim do (misc)

    lm_message_node_set_attributes

            (lm_message_node_add_child(x, "field", NULL),

             "type", "text-multi",

             "var", "status-message",

             "label", "Message",

             NULL);

  } else if (action && !strcmp(action, "cancel")) {

    lm_message_node_set_attribute(command, "status", "canceled");

  } else  { // (if sessionid and not canceled)

    y = lm_message_node_find_xmlns(x, "jabber:x:data"); //x?xmlns=jabber:x:data

    if (y) {

      const char *value=NULL, *message=NULL;

      LmMessageNode *fields, *field;

      field = fields = lm_message_node_get_child(y, "field"); //field?var=status

      while (field && strcmp("status",

                             lm_message_node_get_attribute(field, "var")))

        field = field->next;

      field = lm_message_node_get_child(field, "value");

      if (field)

        value = lm_message_node_get_value(field);

      field = fields; //field?var=status-message

      while (field && strcmp("status-message",

                             lm_message_node_get_attribute(field, "var")))

        field = field->next;

      field = lm_message_node_get_child(field, "value");

      if (field)

        message = lm_message_node_get_value(field);

      if (value) {

        for (s = adhoc_status_list; !s->name || strcmp(s->name, value); s++);

        if (s->name) {

          char *status = g_strdup_printf("%s %s", s->status,

                                         message ? message : "");

          cmd_setstatus(NULL, status);

          g_free(status);

          lm_message_node_set_attribute(command, "status", "completed");

          lm_message_node_add_dataform_result(command,

                                              "Status has been changed");

        }

      }

    }

  }

  if (sessionid)

    lm_message_node_set_attribute(command, "sessionid", sessionid);

  lm_connection_send(c, iq, NULL);

  lm_message_unref(iq);

  return LM_HANDLER_RESULT_REMOVE_MESSAGE;

}

static void _callback_foreach_buddy_groupchat(gpointer rosterdata, void *param)

{

  LmMessageNode *field, *option;

  const char *room_jid, *nickname;

  char *desc;

  room_jid = buddy_getjid(rosterdata);

  if (!room_jid) return;

  nickname = buddy_getnickname(rosterdata);

  if (!nickname) return;

  field = param;

  option = lm_message_node_add_child(field, "option", NULL);

  lm_message_node_add_child(option, "value", room_jid);

  desc = g_strdup_printf("%s on %s", nickname, room_jid);

  lm_message_node_set_attribute(option, "label", desc);

  g_free(desc);

}

static LmHandlerResult handle_iq_command_leave_groupchats(LmMessageHandler *h,

                                                          LmConnection *c,

                                                          LmMessage *m,

                                                          gpointer ud)

{

  const char *action, *node;

  char *sessionid;

  LmMessage *iq;

  LmMessageNode *command, *x;

  x = lm_message_node_get_child(m->node, "command");

  action = lm_message_node_get_attribute(x, "action");

  node = lm_message_node_get_attribute(x, "node");

  sessionid = (char*)lm_message_node_get_attribute(x, "sessionid");

  iq = lm_message_new_iq_from_query(m, LM_MESSAGE_SUB_TYPE_RESULT);

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

  lm_message_node_set_attributes(command,

                                 "node", node,

                                 "xmlns", NS_COMMANDS,

                                 NULL);

  if (!sessionid) {

    LmMessageNode *field;

    sessionid = generate_session_id("leave-groupchats");

    lm_message_node_set_attribute(command, "sessionid", sessionid);

    g_free(sessionid);

    sessionid = NULL;

    lm_message_node_set_attribute(command, "status", "executing");

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

    lm_message_node_set_attributes(x,

                                   "type", "form",

                                   "xmlns", "jabber:x:data",

                                   NULL);

    lm_message_node_add_child(x, "title", "Leave groupchat(s)");

    lm_message_node_add_child(x, "instructions",

                              "What groupchats do you want to leave?");

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

    lm_message_node_set_attributes(field,

                                   "type", "hidden",

                                   "var", "FORM_TYPE",

                                   NULL);

    lm_message_node_add_child(field, "value",

                              "http://jabber.org/protocol/rc");

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

    lm_message_node_set_attributes(field,

                                   "type", "list-multi",