/*

 * jabglue.c    -- Jabber protocol handling

 *

 * Copyright (C) 2005 Mikael Berthe <bmikael@lists.lilotux.net>

 * Parts come from the centericq project:

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

 *

 * 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

 */

#define _GNU_SOURCE  /* We need glibc for strptime */

#include "../libjabber/jabber.h"

#include "jabglue.h"

#include "roster.h"

#include "screen.h"

#include "hooks.h"

#include "utils.h"

#include "settings.h"

#define JABBERPORT      5222

#define JABBERSSLPORT   5223

#define JABBER_AGENT_GROUP "Jabber Agents"

#define to_utf8(s)   ((s) ? g_locale_to_utf8((s),   -1, NULL,NULL,NULL) : NULL)

#define from_utf8(s) ((s) ? g_locale_from_utf8((s), -1, NULL,NULL,NULL) : NULL)

jconn jc;

static time_t LastPingTime;

static unsigned int KeepaliveDelay;

static unsigned int prio;

static int s_id;

static int regmode, regdone;

static enum imstatus mystatus = offline;

unsigned char online;

char imstatus2char[imstatus_size+1] = {

    '_', 'o', 'i', 'f', 'd', 'n', 'a', '\0'

};

static enum {

  STATE_CONNECTING,

  STATE_GETAUTH,

  STATE_SENDAUTH,

  STATE_LOGGED

} jstate;

void statehandler(jconn, int);

void packethandler(jconn, jpacket);

static void logger(jconn j, int io, const char *buf)

{

  scr_LogPrint(LPRINT_DEBUG, "%03s: %s", ((io == 0) ? "OUT" : "IN"), buf);

}

/*

static void jidsplit(const char *jid, char **user, char **host,

        char **res)

{

  char *tmp, *ptr;

  tmp = strdup(jid);

  if ((ptr = strchr(tmp, '/')) != NULL) {

    *res = strdup(ptr+1);

    *ptr = 0;

  } else

    *res = NULL;

  if ((ptr = strchr(tmp, '@')) != NULL) {

    *host = strdup(ptr+1);

    *ptr = 0;

  } else

    *host = NULL;

  *user = strdup(tmp);

  free(tmp);

}

*/

//  jidtodisp(jid)

// Strips the resource part from the jid

// The caller should g_free the result after use.

char *jidtodisp(const char *jid)

{

  char *ptr;

  char *alias;

  while ((alias = g_strdup(jid)) == NULL)

  if ((ptr = strchr(alias, '/')) != NULL) {

    *ptr = 0;

  }

  return alias;

}

char *compose_jid(const char *username, const char *servername,

        const char *resource)

{

  char *jid = g_new(char, 3 +

                    strlen(username) + strlen(servername) + strlen(resource));

  strcpy(jid, username);

  if (!strchr(jid, '@')) {

    strcat(jid, "@");

    strcat(jid, servername);

  }

  strcat(jid, "/");

  strcat(jid, resource);

  return jid;

}

jconn jb_connect(const char *jid, const char *server, unsigned int port,

                 int ssl, const char *pass)

{

  if (!port) {

    if (ssl)

      port = JABBERSSLPORT;

    else

      port = JABBERPORT;

  }

  jb_disconnect();

  s_id = 1;

  jc = jab_new((char*)jid, (char*)pass, (char*)server, port, ssl);

  /* These 3 functions can deal with a NULL jc, no worry... */

  jab_logger(jc, logger);

  jab_packet_handler(jc, &packethandler);

  jab_state_handler(jc, &statehandler);

  if (jc && jc->user) {

    online = TRUE;

    jstate = STATE_CONNECTING;

    statehandler(0, -1);

    jab_start(jc);

  }

  return jc;

}

void jb_disconnect(void)

{

  if (!jc) return;

  // announce it to  everyone else

  jb_setstatus(offline, "");

  // announce it to the user

  statehandler(jc, JCONN_STATE_OFF);

  jab_delete(jc);

  //free(jc); XXX

  jc = NULL;

}

inline void jb_reset_keepalive()

{

  time(&LastPingTime);

}

void jb_keepalive()

{

  if (jc && online)

    jab_send_raw(jc, "  \t  ");

  jb_reset_keepalive();

}

void jb_set_keepalive_delay(unsigned int delay)

{

  KeepaliveDelay = delay;

}

inline void jb_set_priority(unsigned int priority)

{

  prio = priority;

}

void jb_main()

{

  xmlnode x, z;

  char *cid;

  if (!online) {

    return;

  }

  if (jc && jc->state == JCONN_STATE_CONNECTING) {

    jab_start(jc);

    return;

  }

  jab_poll(jc, 50);

  if (jstate == STATE_CONNECTING) {

    if (jc) {

      x = jutil_iqnew(JPACKET__GET, NS_AUTH);

      cid = jab_getid(jc);

      xmlnode_put_attrib(x, "id", cid);

      // id = atoi(cid);

      z = xmlnode_insert_tag(xmlnode_get_tag(x, "query"), "username");

      xmlnode_insert_cdata(z, jc->user->user, (unsigned) -1);

      jab_send(jc, x);

      xmlnode_free(x);

      jstate = STATE_GETAUTH;

    }

    if (!jc || jc->state == JCONN_STATE_OFF) {

      scr_LogPrint(LPRINT_LOGNORM, "Unable to connect to the server");

      online = FALSE;

    }

  }

  if (!jc) {

    statehandler(jc, JCONN_STATE_OFF);

  } else if (jc->state == JCONN_STATE_OFF || jc->fd == -1) {

    statehandler(jc, JCONN_STATE_OFF);

  }

  // Keepalive

  if (KeepaliveDelay) {

    time_t now;

    time(&now);

    if (now > LastPingTime + KeepaliveDelay)

      jb_keepalive();

  }

}

inline enum imstatus jb_getstatus()

{

  return mystatus;

}

void jb_setstatus(enum imstatus st, const char *msg)

{

  xmlnode x;

  gchar *utf8_msg;

  if (!online) return;

  x = jutil_presnew(JPACKET__UNKNOWN, 0, 0);

  switch(st) {

    case away:

        xmlnode_insert_cdata(xmlnode_insert_tag(x, "show"), "away",

                (unsigned) -1);

        break;

    case dontdisturb:

        xmlnode_insert_cdata(xmlnode_insert_tag(x, "show"), "dnd",

                (unsigned) -1);

        break;

    case freeforchat:

        xmlnode_insert_cdata(xmlnode_insert_tag(x, "show"), "chat",

                (unsigned) -1);

        break;

    case notavail:

        xmlnode_insert_cdata(xmlnode_insert_tag(x, "show"), "xa",

                (unsigned) -1);

        break;

    case invisible:

        xmlnode_put_attrib(x, "type", "invisible");

        break;

    case offline:

        xmlnode_put_attrib(x, "type", "unavailable");

        break;

    default:

        break;

  }

  if (prio) {

    char strprio[8];

    snprintf(strprio, 8, "%u", prio);

    xmlnode_insert_cdata(xmlnode_insert_tag(x, "priority"),

            strprio, (unsigned) -1);

  }

  if (!msg)

      msg = settings_get_status_msg(st);

  utf8_msg = to_utf8(msg);

  xmlnode_insert_cdata(xmlnode_insert_tag(x, "status"), utf8_msg,

          (unsigned) -1);

  jab_send(jc, x);

  xmlnode_free(x);

  g_free(utf8_msg);

  //sendvisibility();   ???

  // We'll need to update the roster if we switch to/from offline because

  // we don't know the presences of buddies when offline...

  if (mystatus == offline || st == offline)

    update_roster = TRUE;

  hk_mystatuschange(0, mystatus, st, msg);

  mystatus = st;

}

void jb_send_msg(const char *jid, const char *text)

{

  gchar *buffer = to_utf8(text);

  xmlnode x = jutil_msgnew(TMSG_CHAT, (char*)jid, 0, (char*)buffer);

  jab_send(jc, x);

  xmlnode_free(x);

  g_free(buffer);

  jb_reset_keepalive();

}

// Note: the caller should check the jid is correct

void jb_addbuddy(const char *jid, const char *name, const char *group)

{

  xmlnode x, y, z;

  char *cleanjid;

  if (!online) return;

  // We don't check if the jabber user already exists in the roster,

  // because it allows to re-ask for notification.

  //x = jutil_presnew(JPACKET__SUBSCRIBE, jid, NULL);

  x = jutil_presnew(JPACKET__SUBSCRIBE, (char*)jid, "online");

  jab_send(jc, x);

  xmlnode_free(x);

  x = jutil_iqnew(JPACKET__SET, NS_ROSTER);

  y = xmlnode_get_tag(x, "query");

  z = xmlnode_insert_tag(y, "item");

  xmlnode_put_attrib(z, "jid", jid);

  if (name) {

    gchar *name_utf8 = to_utf8(name);

    z = xmlnode_insert_tag(z, "name");

    xmlnode_insert_cdata(z, name_utf8, (unsigned) -1);

    g_free(name_utf8);

  }

  if (group) {

    char *group_utf8 = to_utf8(group);

    z = xmlnode_insert_tag(z, "group");

    xmlnode_insert_cdata(z, group_utf8, (unsigned) -1);

    g_free(group_utf8);

  }

  jab_send(jc, x);

  xmlnode_free(x);

  cleanjid = jidtodisp(jid);

  roster_add_user(cleanjid, name, group, ROSTER_TYPE_USER);

  g_free(cleanjid);

  buddylist_build();

  update_roster = TRUE;

}

void jb_delbuddy(const char *jid)

{

  xmlnode x, y, z;

  char *cleanjid;

  if (!online) return;

  cleanjid = jidtodisp(jid);

  // If the current buddy is an agent, unsubscribe from it

  if (roster_gettype(cleanjid) == ROSTER_TYPE_AGENT) {

    scr_LogPrint(LPRINT_LOGNORM, "Unregistering from the %s agent", cleanjid);

    x = jutil_iqnew(JPACKET__SET, NS_REGISTER);

    xmlnode_put_attrib(x, "to", cleanjid);

    y = xmlnode_get_tag(x, "query");

    xmlnode_insert_tag(y, "remove");

    jab_send(jc, x);

    xmlnode_free(x);

  }

  // Unsubscribe this buddy from our presence notification

  x = jutil_presnew(JPACKET__UNSUBSCRIBE, cleanjid, 0);

  jab_send(jc, x);

  xmlnode_free(x);

  // Ask for removal from roster

  x = jutil_iqnew(JPACKET__SET, NS_ROSTER);