/*

 * jabglue.c    -- Jabber protocol handling

 *

 * Copyright (C) 2005, 2006 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

 */

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

#include "jabglue.h"

#include "jab_priv.h"

#include "roster.h"

#include "screen.h"

#include "hooks.h"

#include "utils.h"

#include "settings.h"

#include "hbuf.h"

#include "histolog.h"

#include "commands.h"

#define JABBERPORT      5222

#define JABBERSSLPORT   5223

#define RECONNECTION_TIMEOUT    60L

jconn jc;

enum enum_jstate jstate;

char imstatus2char[imstatus_size+1] = {

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

};

static bool AutoConnection;

static time_t LastPingTime;

static unsigned int KeepaliveDelay;

static enum imstatus mystatus = offline;

static gchar *mystatusmsg;

static unsigned char online;

static void statehandler(jconn, int);

static void packethandler(jconn, jpacket);

void handle_state_events(char* from, xmlnode xmldata);

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

{

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

}

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

  alias = g_strdup(jid);

  if ((ptr = strchr(alias, JID_RESOURCE_SEPARATOR)) != 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, JID_DOMAIN_SEPARATOR)) {

    strcat(jid, JID_DOMAIN_SEPARATORSTR);

    strcat(jid, servername);

  }

  strcat(jid, JID_RESOURCE_SEPARATORSTR);

  strcat(jid, resource);

  return jid;

}

inline unsigned char jb_getonline(void)

{

  return online;

}

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();

  if (!jid) return jc;

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

  }

  if (jc)

    AutoConnection = true;

  return jc;

}

void jb_disconnect(void)

{

  if (!jc) return;

  if (online) {

    // Announce it to  everyone else

    jb_setstatus(offline, NULL, "");

    // End the XML flow

    jb_send_raw("</stream:stream>");

  }

  // Announce it to the user

  statehandler(jc, JCONN_STATE_OFF);

  jab_delete(jc);

  jc = NULL;

  AutoConnection = false;

}

inline void jb_reset_keepalive()

{

  time(&LastPingTime);

}

void jb_send_raw(const char *str)

{

  if (jc && online && str)

    jab_send_raw(jc, str);

}

void jb_keepalive()

{

  if (jc && online)

    jab_send_raw(jc, "  \t  ");

  jb_reset_keepalive();

}

void jb_set_keepalive_delay(unsigned int delay)

{

  KeepaliveDelay = delay;

}

//  check_connection()

// Check if we've been disconnected for a while (predefined timeout),

// and if so try to reconnect.

static void check_connection(void)

{

  static time_t disconnection_timestamp = 0L;

  time_t now;

  // Are we totally disconnected?

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

    disconnection_timestamp = 0L;

    return;

  }

  // Maybe we're voluntarily offline...

  if (!AutoConnection)

    return;

  time(&now);

  if (!disconnection_timestamp) {

    disconnection_timestamp = now;

    return;

  }

  // If the reconnection_timeout is reached, try to reconnect.

  if (now > disconnection_timestamp + RECONNECTION_TIMEOUT) {

    mcabber_connect();

    disconnection_timestamp = 0L;

  }

}

void jb_main()

{

  time_t now;

  fd_set fds;

  long timeout;

  struct timeval tv;

  static time_t last_eviqs_check = 0L;

  if (!online) {

    safe_usleep(10000);

    check_connection();

    return;

  }

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

    safe_usleep(75000);

    jab_start(jc);

    return;

  }

  FD_ZERO(&fds);

  FD_SET(0, &fds);

  FD_SET(jc->fd, &fds);

  tv.tv_sec = 60;

  tv.tv_usec = 0;

  time(&now);

  if (KeepaliveDelay) {

    if (now >= LastPingTime + (time_t)KeepaliveDelay) {

      tv.tv_sec = 0;

    } else {

      tv.tv_sec = LastPingTime + (time_t)KeepaliveDelay - now;

    }

  }

  // Check auto-away timeout

  timeout = scr_GetAutoAwayTimeout(now);

  if (tv.tv_sec > timeout) {

    tv.tv_sec = timeout;

  }

#if defined JEP0022 || defined JEP0085

  // Check composing timeout

  timeout = scr_GetChatStatesTimeout(now);

  if (tv.tv_sec > timeout) {

    tv.tv_sec = timeout;

  }

#endif

  if (!tv.tv_sec)

    tv.tv_usec = 350000;

  scr_DoUpdate();

  if (select(jc->fd + 1, &fds, NULL, NULL, &tv) > 0) {

    if (FD_ISSET(jc->fd, &fds))

      jab_poll(jc, 0);

  }

  if (jstate == STATE_CONNECTING) {

    if (jc) {

      eviqs *iqn;

      xmlnode z;

      iqn = iqs_new(JPACKET__GET, NS_AUTH, "auth", IQS_DEFAULT_TIMEOUT);

      iqn->callback = &iqscallback_auth;

      z = xmlnode_insert_tag(xmlnode_get_tag(iqn->xmldata, "query"),

                             "username");

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

      jab_send(jc, iqn->xmldata);

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

  }

  time(&now);

  // Check for EV & IQ requests timeouts

  if (now > last_eviqs_check + 20) {

    iqs_check_timeout(now);

    evs_check_timeout(now);

    last_eviqs_check = now;

  }

  // Keepalive

  if (KeepaliveDelay) {

    if (now > LastPingTime + (time_t)KeepaliveDelay)

      jb_keepalive();

  }

}

inline enum imstatus jb_getstatus()

{

  return mystatus;

}

inline const char *jb_getstatusmsg()

{

  return mystatusmsg;

}

static void roompresence(gpointer room, void *presencedata)

{

  const char *jid;

  const char *nickname;

  char *to;

  struct T_presence *pres = presencedata;

  if (!buddy_getinsideroom(room))

    return;

  jid = buddy_getjid(room);

  if (!jid) return;

  nickname = buddy_getnickname(room);

  if (!nickname) return;

  to = g_strdup_printf("%s/%s", jid, nickname);

  jb_setstatus(pres->st, to, pres->msg);

  g_free(to);

}

//  presnew(status, recipient, message)

// Create an xmlnode with default presence attributes

// Note: the caller must free the node after use

static xmlnode presnew(enum imstatus st, const char *recipient,

                       const char *msg)

{

  unsigned int prio;

  xmlnode x;

  x = jutil_presnew(JPACKET__UNKNOWN, 0, 0);

  if (recipient) {

    xmlnode_put_attrib(x, "to", recipient);

  }

  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;

  }

  prio = settings_opt_get_int("priority");

  if (prio) {

    char strprio[8];

    snprintf(strprio, 8, "%d", (int)prio);

    xmlnode_insert_cdata(xmlnode_insert_tag(x, "priority"),

                         strprio, (unsigned) -1);

  }

  if (msg)

    xmlnode_insert_cdata(xmlnode_insert_tag(x, "status"), msg, (unsigned) -1);

  return x;

}