/*

 * 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

 */

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

#include "jabglue.h"

#include "screen.h"

#include "utils.h"

#define JABBERPORT      5222

#define JABBERSSLPORT   5223

jconn jc;

static int s_id = 1;  // FIXME which use??

static int regmode, regdone;

static enum {

  STATE_CONNECTING,

  STATE_GETAUTH,

  STATE_SENDAUTH,

  STATE_LOGGED

} jstate;

void statehandler(jconn, int);

void packethandler(jconn, jpacket);

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

{

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

}

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

{

  ut_WriteLog("%03s: %s\n", ((io == 0) ? "OUT" : "IN"), buf);

}

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

{

  screen_logger(j, io, buf);

  file_logger(j, io, 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);

}

char *jidtodisp(const char *jid)

{

  char *ptr;

  char *alias = strdup(jid);

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

    *ptr = 0;

  }

  return alias;

}

jconn jb_connect(const char *jid, unsigned int port, int ssl, const char *pass)

{

  if (!port) {

    if (ssl)

      port = JABBERSSLPORT;

    else

      port = JABBERPORT;

  }

  if (jc)

    free(jc);

  jc = jab_new(jid, pass, port, ssl);

  jab_logger(jc, file_logger);

  jab_packet_handler(jc, &packethandler);

  jab_state_handler(jc, &statehandler);

  if (jc->user) {

    //fonline = TRUE;

    jstate = STATE_CONNECTING;

    statehandler(0, -1);

    jab_start(jc);

  }

  return jc;

}

void jb_disconnect(void)

{

  statehandler(jc, JCONN_STATE_OFF);

}

void jb_keepalive()

{

  if (jc) {

    // XXX Only if connected...

    jab_send_raw(jc, " ");

  }

}

void jb_main()

{

  xmlnode x, z;

  char *cid;

  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("Unable to connect to the server");

      // fonline = FALSE;

    }

  }

  if (!jc) {

    statehandler(jc, JCONN_STATE_OFF);

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

    statehandler(jc, JCONN_STATE_OFF);

  }

}

void setjabberstatus(enum imstatus st, char *msg)

{

  xmlnode x = jutil_presnew(JPACKET__UNKNOWN, 0, 0);

  switch(st) {

    case away:

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

                (unsigned) -1);

        break;

    case occupied:

    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;

  }

  /* TODO

  if (!add["prio"].empty())

    xmlnode_insert_cdata(xmlnode_insert_tag(x, "priority"),

            add["prio"].c_str(), (unsigned) -1);

  */

  if (!msg || !*msg) {

    msg  = "unknownStatus"; // FIXME

    //msg = imstatus2str(st);

  }

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

          (unsigned) -1);

  jab_send(jc, x);

  xmlnode_free(x);

  //sendvisibility();

  // XXX logger.putourstatus(proto, getstatus(), ourstatus = st);

}

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

{

  xmlnode x = jutil_msgnew(TMSG_CHAT, jid, 0, text);

  jab_send(jc, x);

  xmlnode_free(x);

}

void postlogin()

{

  //int i;

  //flogged = TRUE;

  //ourstatus = available;

  //setautostatus(jhook.manualstatus);

  setjabberstatus(1, "I'm here!");

  /*

  for (i = 0; i < clist.count; i++) {

    c = (icqcontact *) clist.at(i);

    if (c->getdesc().pname == proto)

      if (ischannel(c))

        if (c->getbasicinfo().requiresauth)

          c->setstatus(available);

  }

  */

  /*

  agents.insert(agents.begin(), agent("vcard", "Jabber VCard", "", agent::atStandard));

  agents.begin()->params[agent::ptRegister].enabled = TRUE;

  string buf;

  ifstream f(conf.getconfigfname("jabber-infoset").c_str());

  if (f.is_open()) {

    icqcontact *c = clist.get(contactroot);

    c->clear();

    icqcontact::basicinfo bi = c->getbasicinfo();

    icqcontact::reginfo ri = c->getreginfo();

    ri.service = agents.begin()->name;

    getstring(f, buf); c->setnick(buf);

    getstring(f, buf); bi.email = buf;

    getstring(f, buf); bi.fname = buf;

    getstring(f, buf); bi.lname = buf;

    f.close();

    c->setbasicinfo(bi);

    c->setreginfo(ri);

    sendupdateuserinfo(*c);

    unlink(conf.getconfigfname("jabber-infoset").c_str());

  }

  */

}

void gotloggedin(void)

{

  xmlnode x;

  x = jutil_iqnew(JPACKET__GET, NS_AGENTS);

  xmlnode_put_attrib(x, "id", "Agent List");

  jab_send(jc, x);

  xmlnode_free(x);

  x = jutil_iqnew(JPACKET__GET, NS_ROSTER);

  xmlnode_put_attrib(x, "id", "Roster");

  jab_send(jc, x);

  xmlnode_free(x);

}

void gotroster(xmlnode x)

{

  xmlnode y, z;

  for (y = xmlnode_get_tag(x, "item"); y; y = xmlnode_get_nextsibling(y)) {

    const char *alias = xmlnode_get_attrib(y, "jid");

    const char *sub = xmlnode_get_attrib(y, "subscription");

    const char *name = xmlnode_get_attrib(y, "name");

    const char *group = 0;

    z = xmlnode_get_tag(y, "group");

    if (z) group = xmlnode_get_data(z);

    if (alias) {

      char *buddyname;

      if (name)

        buddyname = name;

      else

        buddyname = jidtodisp(alias);

      bud_AddBuddy(alias, buddyname);

      if (!name)

        free(buddyname);

    }

  }

  bud_SortRoster();

  postlogin();

}

void gotmessage(char *type, const char *from, const char *body,

        const char *enc)

{

  char *u, *h, *r;

  jidsplit(from, &u, &h, &r);

  /*

  // Maybe we should remember the resource?

  if (r)

    scr_LogPrint("There is an extra part in message (resource?): %s", r);

  */

  scr_WriteIncomingMessage(jidtodisp(from), body);

}

void statehandler(jconn conn, int state)

{

  static int previous_state = -1;

  ut_WriteLog("StateHandler called (state=%d).\n", state);

  switch(state) {

    case JCONN_STATE_OFF:

        /* jhook.flogged = jhook.fonline = FALSE; */

        if (previous_state != JCONN_STATE_OFF) {

          scr_LogPrint("+ JCONN_STATE_OFF");

          /*

           jhook.roster.clear();

           jhook.agents.clear();

          */

        }

        break;

    case JCONN_STATE_CONNECTED:

        scr_LogPrint("+ JCONN_STATE_CONNECTED");

        break;

    case JCONN_STATE_AUTH:

        scr_LogPrint("+ JCONN_STATE_AUTH");

        break;

    case JCONN_STATE_ON:

        scr_LogPrint("+ JCONN_STATE_ON");

        // if (regmode) jhook.fonline = TRUE;

        break;

    case JCONN_STATE_CONNECTING:

        scr_LogPrint("+ JCONN_STATE_CONNECTING");

        break;

    default:

        break;

  }

  previous_state = state;

}

void packethandler(jconn conn, jpacket packet)

{

  char *p;

  xmlnode x, y;

  // string from, type, body, enc, ns, id, u, h, s;

  char *from=NULL, *type=NULL, *body=NULL, *enc=NULL;

  char *ns=NULL;

  char *id=NULL;

  enum imstatus ust;

  // int npos;

  // bool isagent;

  jpacket_reset(packet);

  p = xmlnode_get_attrib(packet->x, "from"); if (p) from = p;

  p = xmlnode_get_attrib(packet->x, "type"); if (p) type = p;

  switch (packet->type) {

    case JPACKET_MESSAGE:

        x = xmlnode_get_tag(packet->x, "body");

        p = xmlnode_get_data(x); if (p) body = p;

        if ((x = xmlnode_get_tag(packet->x, "subject")) != NULL)

          if ((p = xmlnode_get_data(x)) != NULL) {

            char *tmp = malloc(strlen(body)+strlen(p)+3);