/*

 * roster.c     -- Local roster implementation

 *

 * Copyright (C) 2005, 2006 Mikael Berthe <bmikael@lists.lilotux.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 "roster.h"

#include "utils.h"

char *strrole[] = { /* Should match enum in roster.h */

  "none",

  "moderator",

  "participant",

  "visitor"

};

char *straffil[] = { /* Should match enum roster.h */

  "none",

  "owner",

  "admin",

  "memeber",

  "outcast"

};

/* Resource structure */

typedef struct {

  gchar *name;

  gchar prio;

  enum imstatus status;

  gchar *status_msg;

  time_t status_timestamp;

  enum imrole role;

  enum imaffiliation affil;

  gchar *realjid;       /* for chatrooms, if buddy's real jid is known */

  guint events;

} res;

/* This is a private structure type for the roster */

typedef struct {

  gchar *name;

  gchar *jid;

  guint type;

  enum subscr subscription;

  GSList *resource;

  /* For groupchats */

  gchar *nickname;

  gchar *topic;

  guint inside_room;

  /* To keep track of last status message */

  gchar *offline_status_message;

  /* Flag used for the UI */

  guint flags;

  // list: user -> points to his group; group -> points to its users list

  GSList *list;

} roster;

/* ### Variables ### */

static int hide_offline_buddies;

static GSList *groups;

static GSList *unread_list;

static GHashTable *unread_jids;

GList *buddylist;

GList *current_buddy;

GList *alternate_buddy;

static roster roster_special;

void unread_jid_add(const char *jid);

int  unread_jid_del(const char *jid);

/* ### Initialization ### */

void roster_init(void)

{

  roster_special.name = SPECIAL_BUFFER_STATUS_ID;

  roster_special.type = ROSTER_TYPE_SPECIAL;

}

/* ### Resources functions ### */

static void free_all_resources(GSList **reslist)

{

  GSList *lip;

  res *p_res;

  for ( lip = *reslist; lip ; lip = g_slist_next(lip)) {

    p_res = (res*)lip->data;

    g_free((gchar*)p_res->status_msg);

    g_free((gchar*)p_res->name);

    g_free((gchar*)p_res->realjid);

  }

  // Free all nodes but the first (which is static)

  g_slist_free(*reslist);

  *reslist = NULL;

}

// Resources are sorted in ascending order

static gint resource_compare_prio(res *a, res *b) {

  //return (a->prio - b->prio);

  if (a->prio < b->prio) return -1;

  else                   return 1;

}

//  get_resource(rost, resname)

// Return a pointer to the resource with name resname, in rost's resources list

// - if rost has no resources, return NULL

// - if resname is defined, return the match or NULL

// - if resname is NULL, the last resource is returned, currently

//   This could change in the future, because we should return the best one

//   (priority? last used? and fall back to the first resource)

//

static res *get_resource(roster *rost, const char *resname)

{

  GSList *p;

  res *r = NULL;

  for (p = rost->resource; p; p = g_slist_next(p)) {

    r = p->data;

    if (resname && !strcmp(r->name, resname))

      return r;

  }

  // The last resource is one of the resources with the highest priority,

  // however, we don't know if it is the more-recently-used.

  if (!resname) return r;

  return NULL;

}

//  get_or_add_resource(rost, resname, priority)

// - if there is a "resname" resource in rost's resources, return a pointer

//   on this resource

// - if not, add the resource, set the name, and return a pointer on this

//   new resource

static res *get_or_add_resource(roster *rost, const char *resname, gchar prio)

{

  GSList *p;

  res *nres;

  if (!resname) return NULL;

  for (p = rost->resource; p; p = g_slist_next(p)) {

    res *r = p->data;

    if (!strcmp(r->name, resname))

      return r;

  }

  // Resource not found

  nres = g_new0(res, 1);

  nres->name = g_strdup(resname);

  nres->prio = prio;

  rost->resource = g_slist_insert_sorted(rost->resource, nres,

                                         (GCompareFunc)&resource_compare_prio);

  return nres;

}

static void del_resource(roster *rost, const char *resname)

{

  GSList *p;

  GSList *p_res_elt = NULL;

  res *p_res;

  if (!resname) return;

  for (p = rost->resource; p; p = g_slist_next(p)) {

    res *r = p->data;

    if (!strcmp(r->name, resname))

      p_res_elt = p;

  }

  if (!p_res_elt) return;   // Resource not found

  p_res = p_res_elt->data;

  // Keep a copy of the status message when a buddy goes offline

  if (g_slist_length(rost->resource) == 1) {

    g_free(rost->offline_status_message);

    rost->offline_status_message = p_res->status_msg;

    p_res->status_msg = NULL;

  }

  // Free allocations and delete resource node

  g_free(p_res->name);

  g_free(p_res->status_msg);

  g_free(p_res->realjid);

  rost->resource = g_slist_delete_link(rost->resource, p_res_elt);

  return;

}

/* ### Roster functions ### */

// Comparison function used to search in the roster (compares jids and types)

static gint roster_compare_jid_type(roster *a, roster *b) {

  if (! (a->type & b->type))

    return -1; // arbitrary (but should be != 0, of course)

  return strcasecmp(a->jid, b->jid);

}

// Comparison function used to search in the roster (compares names and types)

static gint roster_compare_name_type(roster *a, roster *b) {

  if (! (a->type & b->type))

    return -1; // arbitrary (but should be != 0, of course)

  return strcmp(a->name, b->name);

}

// Comparison function used to sort the roster (by name)

static gint roster_compare_name(roster *a, roster *b) {

  return strcmp(a->name, b->name);

}

// Finds a roster element (user, group, agent...), by jid or name

// If roster_type is 0, returns match of any type.

// Returns the roster GSList element, or NULL if jid/name not found

GSList *roster_find(const char *jidname, enum findwhat type, guint roster_type)

{

  GSList *sl_roster_elt = groups;

  GSList *res;

  roster sample;

  GCompareFunc comp;

  if (!jidname) return NULL;

  if (!roster_type)

    roster_type = ROSTER_TYPE_USER  | ROSTER_TYPE_ROOM |

                  ROSTER_TYPE_AGENT | ROSTER_TYPE_GROUP;

  sample.type = roster_type;

  if (type == jidsearch) {

    sample.jid = (gchar*)jidname;

    comp = (GCompareFunc)&roster_compare_jid_type;

  } else if (type == namesearch) {

    sample.name = (gchar*)jidname;

    comp = (GCompareFunc)&roster_compare_name_type;

  } else

    return NULL;    // Should not happen...

  while (sl_roster_elt) {

    roster *roster_elt = (roster*)sl_roster_elt->data;

    if (roster_type & ROSTER_TYPE_GROUP) {

      if ((type == namesearch) && !strcmp(jidname, roster_elt->name))

        return sl_roster_elt;

    }

    res = g_slist_find_custom(roster_elt->list, &sample, comp);

    if (res) return res;

    sl_roster_elt = g_slist_next(sl_roster_elt);

  }

  return NULL;

}

// Returns pointer to new group, or existing group with that name

GSList *roster_add_group(const char *name)

{

  roster *roster_grp;

  GSList *p_group;

  // #1 Check name doesn't already exist

  p_group = roster_find(name, namesearch, ROSTER_TYPE_GROUP);

  if (!p_group) {

    // #2 Create the group node

    roster_grp = g_new0(roster, 1);

    roster_grp->name = g_strdup(name);

    roster_grp->type = ROSTER_TYPE_GROUP;

    // #3 Insert (sorted)

    groups = g_slist_insert_sorted(groups, roster_grp,

            (GCompareFunc)&roster_compare_name);

    p_group = roster_find(name, namesearch, ROSTER_TYPE_GROUP);

  }

  return p_group;

}

// Returns a pointer to the new user, or existing user with that name

GSList *roster_add_user(const char *jid, const char *name, const char *group,

                        guint type, enum subscr esub)

{

  roster *roster_usr;

  roster *my_group;

  GSList *slist;

  if ((type != ROSTER_TYPE_USER) &&

      (type != ROSTER_TYPE_ROOM) &&

      (type != ROSTER_TYPE_AGENT)) {

    // XXX Error message?

    return NULL;

  }

  // Let's be arbitrary: default group has an empty name ("").

  if (!group)  group = "";

  // #1 Check this user doesn't already exist

  slist = roster_find(jid, jidsearch, 0);

  if (slist) {

    char *oldgroupname;

    // That's an update

    roster_usr = slist->data;

    roster_usr->subscription = esub;

    if (name)

      buddy_setname(slist->data, (char*)name);

    // Let's check if the group name has changed

    oldgroupname = ((roster*)((GSList*)roster_usr->list)->data)->name;

    if (group && strcmp(oldgroupname, group))

      buddy_setgroup(slist->data, (char*)group);

    return slist;

  }

  // #2 add group if necessary

  slist = roster_add_group(group);

  if (!slist) return NULL;

  my_group = (roster*)slist->data;

  // #3 Create user node

  roster_usr = g_new0(roster, 1);

  roster_usr->jid   = g_strdup(jid);

  if (name) {

    roster_usr->name  = g_strdup(name);

  } else {

    gchar *p, *str = g_strdup(jid);

    p = strchr(str, JID_RESOURCE_SEPARATOR);

    if (p)  *p = '\0';

    roster_usr->name = g_strdup(str);

    g_free(str);

  }

  if (unread_jid_del(jid)) {

    roster_usr->flags |= ROSTER_FLAG_MSG;

    // Append the roster_usr to unread_list

    unread_list = g_slist_append(unread_list, roster_usr);

  }

  roster_usr->type = type;

  roster_usr->subscription = esub;

  roster_usr->list = slist;    // (my_group SList element)

  // #4 Insert node (sorted)

  my_group->list = g_slist_insert_sorted(my_group->list, roster_usr,

                                         (GCompareFunc)&roster_compare_name);

  return roster_find(jid, jidsearch, type);

}

// Removes user (jid) from roster, frees allocated memory

void roster_del_user(const char *jid)

{

  GSList *sl_user, *sl_group;

  GSList **sl_group_listptr;

  roster *roster_usr;

  GSList *node;

  sl_user = roster_find(jid, jidsearch,

                        ROSTER_TYPE_USER|ROSTER_TYPE_AGENT|ROSTER_TYPE_ROOM);

  if (sl_user == NULL)

    return;

  roster_usr = (roster*)sl_user->data;

  // Remove (if present) from unread messages list

  node = g_slist_find(unread_list, roster_usr);

  if (node) unread_list = g_slist_delete_link(unread_list, node);

  // If there is a pending unread message, keep track of it

  if (roster_usr->flags & ROSTER_FLAG_MSG)

    unread_jid_add(roster_usr->jid);

  // Let's free memory (jid, name, status message)