matrix-roommembers.c

/*
 * matrix-roommember.c
 *
 *
 * Copyright (c) Openmarket UK Ltd 2015
 *
 * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
 */


#include "matrix-roommembers.h"

#include <stdlib.h>
#include <string.h>

#include "debug.h"

#include "matrix-json.h"

/******************************************************************************
 *
 * Individual members
 */

typedef struct _MatrixRoomMember {
    gchar *user_id;

    /* the current room membership */
    int membership;

    /* the displayname from the state table (this is a pointer to the actual
     * string in the state table, so should not be freed here) */
    const gchar *state_displayname;

    /* data attached to this member (matrix-room.c uses it to track the
     * name we told libpurple this member had)
     */
    gpointer opaque_data;

    /* callback to delete the opaque_data. Called with a pointer to the member.
     */
    DestroyMemberNotify on_delete;
} MatrixRoomMember;


static int _parse_membership(const gchar *membership)
{
    if(membership == NULL)
        return MATRIX_ROOM_MEMBERSHIP_NONE;

    if(strcmp(membership, "join") == 0)
        return MATRIX_ROOM_MEMBERSHIP_JOIN;
    if(strcmp(membership, "leave") == 0)
        return MATRIX_ROOM_MEMBERSHIP_LEAVE;
    if(strcmp(membership, "invite") == 0)
        return MATRIX_ROOM_MEMBERSHIP_INVITE;
    return MATRIX_ROOM_MEMBERSHIP_NONE;
}

static MatrixRoomMember *_new_member(const gchar *userid)
{
    MatrixRoomMember *mem = g_new0(MatrixRoomMember, 1);
    mem->user_id = g_strdup(userid);
    return mem;
}

static void _free_member(MatrixRoomMember *member)
{
    g_assert(member != NULL);
    if(member->on_delete)
        member->on_delete(member);
    g_free(member->user_id);
    member->user_id = NULL;
    g_free(member);
}


/**
 * Get the user_id for the given member
 *
 * @returns a string, which should *not* be freed
 */
const gchar *matrix_roommember_get_user_id(const MatrixRoomMember *member)
{
    return member->user_id;
}

/**
 * Get the displayname for the given member
 *
 * @returns a string, which should *not* be freed
 */
const gchar *matrix_roommember_get_displayname(const MatrixRoomMember *member)
{
    if(member->state_displayname != NULL) {
        /* TODO: if there is more than one member with this displayname, we
         * should return a deduplicated name
         */
        return member->state_displayname;
    } else {
        return member->user_id;
    }
}


/**
 * Get the opaque data associated with the given member
 */
gpointer matrix_roommember_get_opaque_data(const MatrixRoomMember *member)
{
    return member->opaque_data;
}


/**
 * Set the opaque data associated with the given member
 */
void matrix_roommember_set_opaque_data(MatrixRoomMember *member,
        gpointer data, DestroyMemberNotify on_delete)
{
    member->opaque_data = data;
    member->on_delete = on_delete;
}


/******************************************************************************
 *
 * member table
 */

struct _MatrixRoomMemberTable {
    GHashTable *hash_table;
    GSList *new_members;
    GSList *left_members;
    GSList *renamed_members;
};

MatrixRoomMemberTable *matrix_roommembers_new_table()
{
    MatrixRoomMemberTable *table;
    table = g_new0(MatrixRoomMemberTable, 1);
    table -> hash_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
                           (GDestroyNotify) _free_member);
    return table;
}


void matrix_roommembers_free_table(MatrixRoomMemberTable *table)
{
    g_hash_table_destroy(table->hash_table);
    table->hash_table = NULL;
    g_free(table);
}


MatrixRoomMember *matrix_roommembers_lookup_member(MatrixRoomMemberTable *table,
        const gchar *member_user_id)
{
    return g_hash_table_lookup(table->hash_table, member_user_id);
}


void matrix_roommembers_update_member(MatrixRoomMemberTable *table,
        const gchar *member_user_id, JsonObject *new_state)
{
    const gchar *old_displayname = NULL;
    MatrixRoomMember *member;
    int old_membership_val = MATRIX_ROOM_MEMBERSHIP_NONE,
            new_membership_val;
    const gchar *new_displayname, *new_membership;

    new_displayname = matrix_json_object_get_string_member(
             new_state, "displayname");
    new_membership = matrix_json_object_get_string_member(
                       new_state, "membership");

    new_membership_val = _parse_membership(new_membership);

    member = matrix_roommembers_lookup_member(table, member_user_id);

    if(member != NULL) {
        old_displayname = member -> state_displayname;
        old_membership_val = member -> membership;
    }

    if(!member) {
        member = _new_member(member_user_id);
        g_hash_table_insert(table->hash_table, g_strdup(member_user_id),
                member);
    }
    member->membership = new_membership_val;
    member->state_displayname = new_displayname;

    purple_debug_info("matrixprpl", "member %s change %i->%i, "
            "%s->%s\n", member_user_id,
            old_membership_val, new_membership_val,
            old_displayname, new_displayname);

    if(new_membership_val == MATRIX_ROOM_MEMBERSHIP_JOIN) {
        if(old_membership_val != MATRIX_ROOM_MEMBERSHIP_JOIN) {
            purple_debug_info("matrixprpl", "%s (%s) joins\n",
                    member_user_id, new_displayname);
            table->new_members = g_slist_append(
                    table->new_members, member);
        } else if(g_strcmp0(old_displayname, new_displayname) != 0) {
            purple_debug_info("matrixprpl", "%s (%s) changed name (was %s)\n",
                    member_user_id, new_displayname, old_displayname);
            table->renamed_members = g_slist_append(
                    table->renamed_members, member);
        }
    } else {
        if(old_membership_val == MATRIX_ROOM_MEMBERSHIP_JOIN) {
            purple_debug_info("matrixprpl", "%s (%s) leaves\n",
                    member_user_id, old_displayname);
            table->left_members = g_slist_append(
                    table->left_members, member);
        }
    }
}


/**
 * Returns a list of MatrixRoomMember *s. Free the list, but not the pointers.
 */
GList *matrix_roommembers_get_active_members(
        MatrixRoomMemberTable *member_table, gboolean include_invited)
{
    GHashTableIter iter;
    gpointer key, value;
    GList *members = NULL;

    g_hash_table_iter_init (&iter, member_table->hash_table);
    while (g_hash_table_iter_next (&iter, &key, &value)) {
        MatrixRoomMember *member = value;

        if(member->membership == MATRIX_ROOM_MEMBERSHIP_JOIN ||
                (include_invited &&
                        member->membership == MATRIX_ROOM_MEMBERSHIP_INVITE)) {
            members = g_list_prepend(members, value);
        }
    }
    return members;
}


GSList *matrix_roommembers_get_new_members(MatrixRoomMemberTable *table)
{
    GSList *members = table->new_members;
    table->new_members = NULL;
    return members;
}


GSList *matrix_roommembers_get_renamed_members(MatrixRoomMemberTable *table)
{
    GSList *members = table->renamed_members;
    table->renamed_members = NULL;
    return members;

}


GSList *matrix_roommembers_get_left_members(MatrixRoomMemberTable *table)
{
    GSList *members = table->left_members;
    table->left_members = NULL;
    return members;

}