/*
 * This file is part of matrix-glib-sdk
 *
 * matrix-glib-sdk is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation, either
 * version 3 of the License, or (at your option) any later version.
 *
 * matrix-glib-sdk 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with matrix-glib-sdk. If not, see
 * <http://www.gnu.org/licenses/>.
 */

#include "matrix-room.h"
#include "matrix-enumtypes.h"

/**
 * SECTION:matrix-room
 * @short_description: class to hold room data
 *
 */

#define MATRIX_ROOM_TYPE_MEMBER_DATA (matrix_room_member_data_get_type ())

enum  {
    PROP_0,
    PROP_ROOM_ID,
    PROP_ALIASES,
    PROP_AVATAR_URL,
    PROP_AVATAR_THUMBNAIL_URL,
    PROP_CANONICAL_ALIAS,
    PROP_CREATOR,
    PROP_FEDERATE,
    PROP_GUEST_ACCESS,
    PROP_HISTORY_VISIBILITY,
    PROP_JOIN_RULES,
    PROP_NAME,
    PROP_DEFAULT_POWER_LEVEL,
    PROP_DEFAULT_EVENT_LEVEL,
    PROP_DEFAULT_STATE_LEVEL,
    PROP_BAN_LEVEL,
    PROP_KICK_LEVEL,
    PROP_REDACT_LEVEL,
    PROP_INVITE_LEVEL,
    PROP_TOPIC,
    PROP_TYPING_USERS,
    PROP_AVATAR_INFO,
    PROP_AVATAR_THUMBNAIL_INFO,
    NUM_PROPERTIES
};

static GParamSpec *matrix_room_properties[NUM_PROPERTIES];

typedef struct {
    MatrixProfile* profile;
    gboolean thirdparty;
} MatrixRoomMemberData;

MatrixRoomMemberData *
matrix_room_member_data_new(void)
{
    return g_new0(MatrixRoomMemberData, 1);
}

void
matrix_room_member_data_free(MatrixRoomMemberData *member_data)
{
    g_return_if_fail(member_data != NULL);

    g_object_unref(member_data->profile);
    g_free(member_data);
}

typedef struct {
    gchar *room_id;
    gchar **aliases;
    gint aliases_len;
    gchar *avatar_url;
    MatrixImageInfo *avatar_info;
    gchar *avatar_thumbnail_url;
    MatrixImageInfo *avatar_thumbnail_info;
    gchar *canonical_alias;
    gchar *creator;
    gboolean federate;
    MatrixGuestAccess guest_access;
    MatrixHistoryVisibility history_visibility;
    MatrixJoinRules join_rules;
    gchar *name;
    gint default_power_level;
    gint default_event_level;
    gint default_state_level;
    gint ban_level;
    gint kick_level;
    gint redact_level;
    gint invite_level;
    gchar *topic;
    gchar **typing_users;
    gint typing_users_len;
    GHashTable* event_levels;
    GHashTable* user_levels;
    GHashTable* members;
} MatrixRoomPrivate;

/**
 * MatrixRoom:
 *
 * The #MatrixRoom class is there to hold different parameters of a room like its known aliases,
 * its members, etc.
 */
G_DEFINE_TYPE_WITH_PRIVATE(MatrixRoom, matrix_room, G_TYPE_OBJECT);

/**
 * matrix_room_new:
 * @room_id: a room ID
 *
 * Create a new #MatrixRoom object.
 *
 * Returns: (transfer full): a new #MatrixRoom object
 */
MatrixRoom *
matrix_room_new(const gchar *room_id)
{
    g_return_val_if_fail(room_id != NULL, NULL);

    return (MatrixRoom *)g_object_new(MATRIX_TYPE_ROOM,
                                      "room-id", room_id,
                                      NULL);
}

/**
 * matrix_room_add_member:
 * @room: a #MatrixRoom
 * @user_id: the Matrix ID of the user to add
 * @profile: a #MatrixProfile
 * @third_party: if true, the member is marked as a pending 3rd party invitation
 * @error: a #GError, or %NULL to ignore errors
 *
 * Add a member to the room member list.  If a member with the same @user_id exists, @error is
 * set to #MATRIX_ERROR_ALREADY_EXISTS.
 */
void
matrix_room_add_member(MatrixRoom *matrix_room, const gchar *user_id, MatrixProfile *profile, gboolean third_party, GError **error)
{
    MatrixRoomPrivate *priv;
    MatrixRoomMemberData *data = NULL;

    g_return_if_fail(matrix_room != NULL);
    g_return_if_fail(user_id != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if ((data = g_hash_table_lookup(priv->members, user_id)) != NULL) {
        g_set_error(error, MATRIX_ERROR, MATRIX_ERROR_ALREADY_EXISTS,
                    "User already exists in that room");

        return;
    }

    data = matrix_room_member_data_new();

    if (profile == NULL) {
        data->profile = matrix_profile_new();
    } else {
        data->profile = profile;
    }

    data->thirdparty = third_party;

    g_hash_table_insert(priv->members, g_strdup(user_id), data);
}

/**
 * matrix_room_get_or_add_member:
 * @room: a #MatrixRoom
 * @user_id: the Matrix ID of the user to add
 * @third_party: if %TRUE, the member is marked as a pending 3rd party invitation
 * @error: a #GError, or %NULL to ignore errors
 *
 * Gets the profile of the room member specified in @user_id.  If that user is not added to the
 * room yet, it gets added with an empty profile and that profile is returned.
 *
 * Returns: (transfer none): the #MatrixProfile of the user
 */
MatrixProfile *
matrix_room_get_or_add_member(MatrixRoom *matrix_room, const gchar *user_id, gboolean third_party, GError **error)
{
    MatrixProfile *profile;
    GError *inner_error = NULL;

    g_return_val_if_fail(matrix_room != NULL, NULL);
    g_return_val_if_fail(user_id != NULL, NULL);

    profile = matrix_room_get_member(matrix_room, user_id, NULL, &inner_error);

    if (inner_error == NULL) {
        return profile;
    }

    if ((inner_error->domain != MATRIX_ERROR) || (inner_error->code == MATRIX_ERROR_NOT_FOUND)) {
        g_propagate_error(error, inner_error);

        return NULL;
    }

    g_clear_error(&inner_error);

    matrix_room_add_member(matrix_room, user_id, NULL, third_party, &inner_error);

    if (inner_error != NULL) {
        g_propagate_error(error, inner_error);

        return NULL;
    }

    profile = matrix_room_get_member(matrix_room, user_id, &third_party, &inner_error);

    if (inner_error != NULL) {
        g_propagate_error(error, inner_error);

        return NULL;
    }

    return profile;
}

/**
 * matrix_room_get_member:
 * @room: a #MatrixRoom
 * @user_id: the Matrix ID of the user to find
 * @third_party: gets a true value if the member is actually a pending 3rd party invitation
 * @error: (nullable): a #GError, or %NULL to ignore errors
 *
 * Gets the profile of the room member specified in @user_id.  If that user is not added to
 * the room yet, @error is set to #MATRIX_ERROR_NOT_FOUND.
 *
 * Returns: (transfer none): the profile of the user
 */
MatrixProfile *
matrix_room_get_member(MatrixRoom *matrix_room, const gchar *user_id, gboolean *third_party, GError **error)
{
    MatrixRoomMemberData *data;
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, NULL);
    g_return_val_if_fail(user_id != NULL, NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if ((data = g_hash_table_lookup(priv->members, user_id)) == NULL) {
        g_set_error(error, MATRIX_ERROR, MATRIX_ERROR_NOT_FOUND,
                    "No such room member");

        return NULL;
    }

    if (third_party != NULL) {
        *third_party = data->thirdparty;
    }

    return data->profile;
}

/**
 * matrix_room_remove_member:
 * @room: a #MatrixRoom
 * @user_id: a Matrix ID
 * @error: (nullable): a #GError, or %NULL to ignore errors
 *
 * Removes @user_id from the member list.
 */
void
matrix_room_remove_member(MatrixRoom *matrix_room, const gchar *user_id, GError **error)
{
    MatrixRoomMemberData *data;
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);
    g_return_if_fail(user_id != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if ((data = g_hash_table_lookup(priv->members, user_id)) == NULL) {
        g_set_error(error, MATRIX_ERROR, MATRIX_ERROR_NOT_FOUND,
                    "No such room member");

        return;
    }

    g_hash_table_remove(priv->members, user_id);
}

/**
 * matrix_room_clear_user_levels:
 * @room: a #MatrixRoom
 *
 * Clear the stored individual user levels.  This should be called eg. when receiving a new
 * `m.room.power_levels` event.
 */
void
matrix_room_clear_user_levels(MatrixRoom *matrix_room)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    g_hash_table_remove_all(priv->user_levels);
}

/**
 * matrix_room_set_user_level:
 * @room: a #MatrixRoom
 * @user_id: a fully qualified Matrix ID
 * @level: the new power level
 *
 * Set an individual power level for a user.
 */
void
matrix_room_set_user_level(MatrixRoom *matrix_room, const gchar *user_id, gint level)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);
    g_return_if_fail(user_id != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    g_hash_table_insert (priv->user_levels, g_strdup(user_id), GINT_TO_POINTER(level));
}

/**
 * matrix_room_get_user_level:
 * @room: a #MatrixRoom
 * @user_id: a fully qualified Matrix ID
 *
 * Get the power level of a user.  If the user doesn’t have an individually set power level,
 * the default value is returned.
 *
 * Returns: the level of the user.
 */
gint
matrix_room_get_user_level(MatrixRoom *matrix_room, const gchar *user_id)
{
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, 0);
    g_return_val_if_fail(user_id != NULL, 0);

    priv = matrix_room_get_instance_private(matrix_room);

    gpointer level = NULL;

    if (!g_hash_table_lookup_extended(priv->user_levels, user_id, NULL, &level)) {
        return priv->default_power_level;
    }

    return GPOINTER_TO_INT(level);
}

/**
 * matrix_room_clear_event_levels:
 * @room: a #MatrixRoom
 *
 * Clear the stored event level requirements.  This should be called eg. when receiving a new
 * `m.room.power_levels` event.
 */
void
matrix_room_clear_event_levels(MatrixRoom *matrix_room)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    g_hash_table_remove_all(priv->event_levels);
}

/**
 * matrix_room_set_event_level:
 * @room: a #MatrixRoom
 * @event_type: the event type to restrict
 * @level: the desired level for the event type
 *
 * Set the required level to send an event of type @event_type.
 */
void
matrix_room_set_event_level(MatrixRoom *matrix_room, const gchar *event_type, gint level)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);
    g_return_if_fail (event_type != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    g_hash_table_insert(priv->event_levels, g_strdup(event_type), GINT_TO_POINTER(level));
}

/**
 * matrix_room_get_event_level:
 * @room: a #MatrixRoom
 * @event_type: the event type to query
 * @error: (nullable): a #GError, or %NULL to ignore errors
 *
 * Get the required level to send an event of type @event_type.  If there is no level
 * requirement set for this event type, this function returns %NULL as there is no way to
 * decide if #MatrixRoom:default-state-level or #MatrixRoom:default-event-level should be used.
 *
 * Returns: the level required to send a specific event
 */
gint
matrix_room_get_event_level(MatrixRoom *matrix_room, const gchar *event_type, GError **error)
{
    MatrixRoomPrivate *priv;
    gpointer level;

    g_return_val_if_fail(matrix_room != NULL, 0);
    g_return_val_if_fail(event_type != NULL, 0);

    priv = matrix_room_get_instance_private(matrix_room);

    if (!g_hash_table_lookup_extended(priv->event_levels, event_type, NULL, &level)) {
        g_set_error(error, MATRIX_ERROR, MATRIX_ERROR_NOT_FOUND, "No level set for this event type");

        return 0;
    }

    return GPOINTER_TO_INT(level);
}

const gchar *
matrix_room_get_room_id(MatrixRoom *matrix_room)
{
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    return priv->room_id;
}

static void
matrix_room_set_room_id(MatrixRoom *matrix_room, const gchar *room_id)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if (g_strcmp0(room_id, priv->room_id) != 0) {
        g_free(priv->room_id);
        priv->room_id = g_strdup(room_id);

        g_object_notify_by_pspec((GObject *)matrix_room, matrix_room_properties[PROP_ROOM_ID]);
    }
}

/**
 * matrix_room_get_aliases:
 * @room: a #MatrixRoom
 * @n_aliases: (nullable): a placeholder for the length of the list
 *
 * Returns: (transfer none): the list of room aliases
 */
gchar **
matrix_room_get_aliases(MatrixRoom *matrix_room, int *n_aliases)
{
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if (n_aliases != NULL) {
        *n_aliases = priv->aliases_len;
    }

    return priv->aliases;
}

/**
 * matrix_room_set_aliases:
 * @room: a #MatrixRoom
 * @aliases: a list of aliases to assign to @room
 * @n_aliases: the length of @aliases
 */
void
matrix_room_set_aliases(MatrixRoom *matrix_room, const gchar **aliases, int n_aliases)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    for (gint i = 0; i < priv->aliases_len; i++) {
        g_free(priv->aliases[i]);
    }

    g_free(priv->aliases);

    priv->aliases = g_new(gchar *, n_aliases);

    for (gint i = 0; i < n_aliases; i++) {
        priv->aliases[i] = g_strdup(aliases[i]);
    }

    g_object_notify_by_pspec((GObject *)matrix_room, matrix_room_properties[PROP_ALIASES]);
}

const gchar *
matrix_room_get_avatar_url(MatrixRoom *matrix_room)
{
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    return priv->avatar_url;
}

void
matrix_room_set_avatar_url(MatrixRoom *matrix_room, const gchar *avatar_url)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if (g_strcmp0(avatar_url, priv->avatar_url) != 0) {
        g_free(priv->avatar_url);
        priv->avatar_url = g_strdup(avatar_url);

        g_object_notify_by_pspec((GObject *)matrix_room, matrix_room_properties[PROP_AVATAR_URL]);
    }
}

MatrixImageInfo *
matrix_room_get_avatar_info(MatrixRoom *matrix_room)
{
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    return priv->avatar_info;
}

void
matrix_room_set_avatar_info(MatrixRoom *matrix_room, MatrixImageInfo *avatar_info)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if (priv->avatar_info != avatar_info) {
        matrix_image_info_unref(priv->avatar_info);
        priv->avatar_info = matrix_image_info_ref(avatar_info);

        g_object_notify_by_pspec((GObject *)matrix_room, matrix_room_properties[PROP_AVATAR_INFO]);
    }
}

const gchar *
matrix_room_get_avatar_thumbnail_url(MatrixRoom *matrix_room)
{
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    return priv->avatar_thumbnail_url;
}

void
matrix_room_set_avatar_thumbnail_url(MatrixRoom *matrix_room, const gchar *avatar_thumbnail_url)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if (g_strcmp0(avatar_thumbnail_url, priv->avatar_thumbnail_url) != 0) {
        g_free(priv->avatar_thumbnail_url);
        priv->avatar_thumbnail_url = g_strdup(avatar_thumbnail_url);

        g_object_notify_by_pspec((GObject *)matrix_room, matrix_room_properties[PROP_AVATAR_THUMBNAIL_URL]);
    }
}

MatrixImageInfo *
matrix_room_get_avatar_thumbnail_info(MatrixRoom *matrix_room)
{
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    return priv->avatar_thumbnail_info;
}

void
matrix_room_set_avatar_thumbnail_info(MatrixRoom *matrix_room, MatrixImageInfo *avatar_thumbnail_info)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if (priv->avatar_thumbnail_info != avatar_thumbnail_info) {
        matrix_image_info_unref(priv->avatar_thumbnail_info);
        priv->avatar_thumbnail_info = matrix_image_info_ref(avatar_thumbnail_info);

        g_object_notify_by_pspec((GObject *)matrix_room, matrix_room_properties[PROP_AVATAR_THUMBNAIL_INFO]);
    }
}

const gchar *
matrix_room_get_canonical_alias(MatrixRoom *matrix_room)
{
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    return priv->canonical_alias;
}

void
matrix_room_set_canonical_alias(MatrixRoom *matrix_room, const gchar *canonical_alias)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if (g_strcmp0(canonical_alias, priv->canonical_alias) != 0) {
        g_free(priv->canonical_alias);
        priv->canonical_alias = g_strdup(canonical_alias);

        g_object_notify_by_pspec((GObject *)matrix_room, matrix_room_properties[PROP_CANONICAL_ALIAS]);
    }
}

const gchar *
matrix_room_get_creator(MatrixRoom *matrix_room)
{
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    return priv->creator;
}

void
matrix_room_set_creator(MatrixRoom *matrix_room, const gchar *creator)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if (g_strcmp0(creator, priv->creator) != 0) {
        g_free(priv->creator);
        priv->creator = g_strdup(creator);

        g_object_notify_by_pspec((GObject *)matrix_room, matrix_room_properties[PROP_CREATOR]);
    }
}

gboolean
matrix_room_get_federate(MatrixRoom *matrix_room)
{
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, FALSE);

    priv = matrix_room_get_instance_private(matrix_room);

    return priv->federate;
}

void
matrix_room_set_federate(MatrixRoom *matrix_room, gboolean federate)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if (priv->federate != federate) {
        priv->federate = federate;

        g_object_notify_by_pspec((GObject *)matrix_room, matrix_room_properties[PROP_FEDERATE]);
    }
}

MatrixGuestAccess
matrix_room_get_guest_access(MatrixRoom *matrix_room)
{
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, 0);

    priv = matrix_room_get_instance_private(matrix_room);

    return priv->guest_access;
}

void
matrix_room_set_guest_access(MatrixRoom *matrix_room, MatrixGuestAccess guest_access)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if (priv->guest_access != guest_access) {
        priv->guest_access = guest_access;

        g_object_notify_by_pspec((GObject *)matrix_room, matrix_room_properties[PROP_GUEST_ACCESS]);
    }
}

MatrixHistoryVisibility
matrix_room_get_history_visibility(MatrixRoom *matrix_room)
{
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, 0);

    priv = matrix_room_get_instance_private(matrix_room);

    return priv->history_visibility;
}

void
matrix_room_set_history_visibility(MatrixRoom *matrix_room, MatrixHistoryVisibility history_visibility)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if (priv->history_visibility != history_visibility) {
        priv->history_visibility = history_visibility;

        g_object_notify_by_pspec((GObject *)matrix_room, matrix_room_properties[PROP_HISTORY_VISIBILITY]);
    }
}

MatrixJoinRules
matrix_room_get_join_rules(MatrixRoom *matrix_room)
{
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, 0);

    priv = matrix_room_get_instance_private(matrix_room);

    return priv->join_rules;
}

void
matrix_room_set_join_rules(MatrixRoom *matrix_room, MatrixJoinRules join_rules)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if (priv->join_rules != join_rules) {
        priv->join_rules = join_rules;

        g_object_notify_by_pspec((GObject *)matrix_room, matrix_room_properties[PROP_JOIN_RULES]);
    }
}

const gchar *
matrix_room_get_name(MatrixRoom *matrix_room)
{
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    return priv->name;
}

void
matrix_room_set_name(MatrixRoom *matrix_room, const gchar *name)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if (g_strcmp0(name, priv->name) != 0) {
        g_free(priv->name);
        priv->name = g_strdup(name);

        g_object_notify_by_pspec((GObject *)matrix_room, matrix_room_properties[PROP_NAME]);
    }
}

gint
matrix_room_get_default_power_level(MatrixRoom *matrix_room)
{
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, 0);

    priv = matrix_room_get_instance_private(matrix_room);

    return priv->default_power_level;
}

void
matrix_room_set_default_power_level(MatrixRoom *matrix_room, gint default_power_level)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if (priv->default_power_level != default_power_level) {
        priv->default_power_level = default_power_level;

        g_object_notify_by_pspec((GObject *)matrix_room, matrix_room_properties[PROP_DEFAULT_POWER_LEVEL]);
    }
}

gint
matrix_room_get_default_event_level(MatrixRoom *matrix_room)
{
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, 0);

    priv = matrix_room_get_instance_private(matrix_room);

    return priv->default_event_level;
}

void
matrix_room_set_default_event_level(MatrixRoom *matrix_room, gint default_event_level)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if (priv->default_event_level != default_event_level) {
        priv->default_event_level = default_event_level;

        g_object_notify_by_pspec((GObject *)matrix_room, matrix_room_properties[PROP_DEFAULT_EVENT_LEVEL]);
    }
}

gint
matrix_room_get_default_state_level(MatrixRoom *matrix_room)
{
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, 0);

    priv = matrix_room_get_instance_private(matrix_room);

    return priv->default_state_level;
}

void
matrix_room_set_default_state_level(MatrixRoom *matrix_room, gint defaul_state_level)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if (priv->default_state_level != defaul_state_level) {
        priv->default_state_level = defaul_state_level;

        g_object_notify_by_pspec((GObject *)matrix_room, matrix_room_properties[PROP_DEFAULT_STATE_LEVEL]);
    }
}

gint
matrix_room_get_ban_level(MatrixRoom *matrix_room)
{
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, 0);

    priv = matrix_room_get_instance_private(matrix_room);

    return priv->ban_level;
}

void
matrix_room_set_ban_level(MatrixRoom *matrix_room, gint ban_level)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if (priv->ban_level != ban_level) {
        priv->ban_level = ban_level;

        g_object_notify_by_pspec((GObject *)matrix_room, matrix_room_properties[PROP_BAN_LEVEL]);
    }
}

gint
matrix_room_get_kick_level(MatrixRoom *matrix_room)
{
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, 0);

    priv = matrix_room_get_instance_private(matrix_room);

    return priv->kick_level;
}

void
matrix_room_set_kick_level(MatrixRoom *matrix_room, gint kick_level)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if (priv->kick_level != kick_level) {
        priv->kick_level = kick_level;

        g_object_notify_by_pspec((GObject *)matrix_room, matrix_room_properties[PROP_KICK_LEVEL]);
    }
}

gint
matrix_room_get_redact_level(MatrixRoom *matrix_room)
{
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, 0);

    priv = matrix_room_get_instance_private(matrix_room);

    return priv->redact_level;
}

void
matrix_room_set_redact_level(MatrixRoom *matrix_room, gint redact_level)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if (priv->redact_level != redact_level) {
        priv->redact_level = redact_level;

        g_object_notify_by_pspec((GObject *)matrix_room, matrix_room_properties[PROP_REDACT_LEVEL]);
    }
}

gint
matrix_room_get_invite_level(MatrixRoom *matrix_room)
{
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, 0);

    priv = matrix_room_get_instance_private(matrix_room);

    return priv->invite_level;
}

void
matrix_room_set_invite_level(MatrixRoom *matrix_room, gint invite_level)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if (priv->invite_level != invite_level) {
        priv->invite_level = invite_level;

        g_object_notify_by_pspec((GObject *)matrix_room, matrix_room_properties[PROP_INVITE_LEVEL]);
    }
}

const gchar *
matrix_room_get_topic(MatrixRoom *matrix_room)
{
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    return priv->topic;
}

void
matrix_room_set_topic(MatrixRoom *matrix_room, const gchar *topic)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if (g_strcmp0(topic, priv->topic) != 0) {
        g_free(priv->topic);
        priv->topic = g_strdup(topic);

        g_object_notify_by_pspec((GObject *)matrix_room, matrix_room_properties[PROP_TOPIC]);
    }
}

/**
 * matrix_room_get_typing_users:
 * @room: a #MatrixRoom
 * @n_typing_users: (nullable): placeholder for the length of the returned list
 *
 * Returns: (transfer none): the list of typing users in @room
 */
gchar **
matrix_room_get_typing_users(MatrixRoom *matrix_room, int *n_typing_users)
{
    MatrixRoomPrivate *priv;

    g_return_val_if_fail(matrix_room != NULL, NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    if (n_typing_users != NULL) {
        *n_typing_users = priv->typing_users_len;
    }

    return priv->typing_users;
}

void
matrix_room_set_typing_users(MatrixRoom *matrix_room, gchar **typing_users, int n_typing_users)
{
    MatrixRoomPrivate *priv;

    g_return_if_fail(matrix_room != NULL);

    priv = matrix_room_get_instance_private(matrix_room);

    for (gint i = 0; i < priv->typing_users_len; i++) {
        g_free(priv->typing_users[i]);
    }

    g_free(priv->typing_users);

    priv->typing_users = g_new(gchar *, n_typing_users);

    for (gint i = 0; i < n_typing_users; i++) {
        priv->typing_users[i] = g_strdup(typing_users[i]);
    }

    g_object_notify_by_pspec((GObject *)matrix_room, matrix_room_properties[PROP_TYPING_USERS]);
}

static void
matrix_room_finalize(GObject *gobject)
{
    MatrixRoomPrivate *priv = matrix_room_get_instance_private(MATRIX_ROOM(gobject));

    g_free(priv->room_id);

    for (gint i = 0; i < priv->aliases_len; i++) {
        g_free(priv->aliases[i]);
    }

    g_free(priv->aliases);
    g_free(priv->avatar_url);
    matrix_image_info_unref(priv->avatar_info);
    g_free(priv->avatar_thumbnail_url);
    matrix_image_info_unref(priv->avatar_thumbnail_info);
    g_free(priv->canonical_alias);
    g_free(priv->creator);
    g_free(priv->name);
    g_free(priv->topic);

    for (gint i = 0; i < priv->typing_users_len; i++) {
        g_free(priv->typing_users[i]);
    }

    g_free(priv->typing_users);
    g_hash_table_unref(priv->event_levels);
    g_hash_table_unref(priv->user_levels);
    g_hash_table_unref(priv->members);

    G_OBJECT_CLASS(matrix_room_parent_class)->finalize(gobject);
}

static void
matrix_room_get_property(GObject *gobject, guint property_id, GValue *value, GParamSpec *pspec)
{
    MatrixRoom *matrix_room = MATRIX_ROOM(gobject);

    switch (property_id) {
        case PROP_ROOM_ID:
            g_value_set_string(value, matrix_room_get_room_id(matrix_room));

            break;
        case PROP_ALIASES:
            g_value_set_boxed(value, matrix_room_get_aliases(matrix_room, NULL));

            break;
        case PROP_AVATAR_URL:
            g_value_set_string(value, matrix_room_get_avatar_url(matrix_room));

            break;
        case PROP_AVATAR_THUMBNAIL_URL:
            g_value_set_string(value, matrix_room_get_avatar_thumbnail_url(matrix_room));

            break;
        case PROP_CANONICAL_ALIAS:
            g_value_set_string(value, matrix_room_get_canonical_alias(matrix_room));

            break;
        case PROP_CREATOR:
            g_value_set_string(value, matrix_room_get_creator(matrix_room));

            break;
        case PROP_FEDERATE:
            g_value_set_boolean(value, matrix_room_get_federate(matrix_room));

            break;
        case PROP_GUEST_ACCESS:
            g_value_set_enum(value, matrix_room_get_guest_access(matrix_room));

            break;
        case PROP_HISTORY_VISIBILITY:
            g_value_set_enum(value, matrix_room_get_history_visibility(matrix_room));

            break;
        case PROP_JOIN_RULES:
            g_value_set_enum(value, matrix_room_get_join_rules(matrix_room));

            break;
        case PROP_NAME:
            g_value_set_string(value, matrix_room_get_name(matrix_room));

            break;
        case PROP_DEFAULT_POWER_LEVEL:
            g_value_set_int(value, matrix_room_get_default_power_level(matrix_room));

            break;
        case PROP_DEFAULT_EVENT_LEVEL:
            g_value_set_int(value, matrix_room_get_default_event_level(matrix_room));

            break;
        case PROP_DEFAULT_STATE_LEVEL:
            g_value_set_int(value, matrix_room_get_default_state_level(matrix_room));

            break;
        case PROP_BAN_LEVEL:
            g_value_set_int(value, matrix_room_get_ban_level(matrix_room));

            break;
        case PROP_KICK_LEVEL:
            g_value_set_int(value, matrix_room_get_kick_level(matrix_room));

            break;
        case PROP_REDACT_LEVEL:
            g_value_set_int(value, matrix_room_get_redact_level(matrix_room));

            break;
        case PROP_INVITE_LEVEL:
            g_value_set_int(value, matrix_room_get_invite_level(matrix_room));

            break;
        case PROP_TOPIC:
            g_value_set_string(value, matrix_room_get_topic(matrix_room));

            break;
        case PROP_TYPING_USERS:
            g_value_set_boxed(value, matrix_room_get_typing_users(matrix_room, NULL));

            break;
        case PROP_AVATAR_INFO:
            g_value_set_boxed(value, matrix_room_get_avatar_info(matrix_room));

            break;
        case PROP_AVATAR_THUMBNAIL_INFO:
            g_value_set_boxed(value, matrix_room_get_avatar_thumbnail_info(matrix_room));

            break;
        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, property_id, pspec);

            break;
    }
}

static void
matrix_room_set_property(GObject *gobject, guint property_id, const GValue *value, GParamSpec *pspec)
{
    MatrixRoom * matrix_room = MATRIX_ROOM(gobject);

    switch (property_id) {
        case PROP_ROOM_ID:
            matrix_room_set_room_id(matrix_room, g_value_get_string(value));

            break;
        case PROP_ALIASES:
        {
            gpointer boxed = g_value_get_boxed(value);

            matrix_room_set_aliases(matrix_room, boxed, (boxed == NULL) ? 0 : g_strv_length(boxed));

            break;
        }
        case PROP_AVATAR_URL:
            matrix_room_set_avatar_url(matrix_room, g_value_get_string(value));

            break;
        case PROP_AVATAR_THUMBNAIL_URL:
            matrix_room_set_avatar_thumbnail_url(matrix_room, g_value_get_string(value));

            break;
        case PROP_CANONICAL_ALIAS:
            matrix_room_set_canonical_alias(matrix_room, g_value_get_string(value));

            break;
        case PROP_CREATOR:
            matrix_room_set_creator(matrix_room, g_value_get_string(value));

            break;
        case PROP_FEDERATE:
            matrix_room_set_federate(matrix_room, g_value_get_boolean(value));

            break;
        case PROP_GUEST_ACCESS:
            matrix_room_set_guest_access(matrix_room, g_value_get_enum(value));

            break;
        case PROP_HISTORY_VISIBILITY:
            matrix_room_set_history_visibility(matrix_room, g_value_get_enum(value));

            break;
        case PROP_JOIN_RULES:
            matrix_room_set_join_rules(matrix_room, g_value_get_enum (value));

            break;
        case PROP_NAME:
            matrix_room_set_name(matrix_room, g_value_get_string(value));

            break;
        case PROP_DEFAULT_POWER_LEVEL:
            matrix_room_set_default_power_level(matrix_room, g_value_get_int(value));

            break;
        case PROP_DEFAULT_EVENT_LEVEL:
            matrix_room_set_default_event_level(matrix_room, g_value_get_int(value));

            break;
        case PROP_DEFAULT_STATE_LEVEL:
            matrix_room_set_default_state_level(matrix_room, g_value_get_int(value));

            break;
        case PROP_BAN_LEVEL:
            matrix_room_set_ban_level(matrix_room, g_value_get_int(value));

            break;
        case PROP_KICK_LEVEL:
            matrix_room_set_kick_level(matrix_room, g_value_get_int(value));

            break;
        case PROP_REDACT_LEVEL:
            matrix_room_set_redact_level(matrix_room, g_value_get_int(value));

            break;
        case PROP_INVITE_LEVEL:
            matrix_room_set_invite_level(matrix_room, g_value_get_int(value));

            break;
        case PROP_TOPIC:
            matrix_room_set_topic(matrix_room, g_value_get_string(value));

            break;
        case PROP_TYPING_USERS:
        {
            gpointer boxed = g_value_get_boxed(value);

            matrix_room_set_typing_users(matrix_room, boxed, (boxed == NULL) ? 0 : g_strv_length(boxed));

            break;
        }
        case PROP_AVATAR_INFO:
            matrix_room_set_avatar_info(matrix_room, g_value_get_boxed(value));

            break;
        case PROP_AVATAR_THUMBNAIL_INFO:
            matrix_room_set_avatar_thumbnail_info(matrix_room, g_value_get_boxed(value));

            break;
        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, property_id, pspec);

            break;
    }
}

static void
matrix_room_class_init(MatrixRoomClass *klass)
{
    G_OBJECT_CLASS(klass)->get_property = matrix_room_get_property;
    G_OBJECT_CLASS(klass)->set_property = matrix_room_set_property;
    G_OBJECT_CLASS(klass)->finalize = matrix_room_finalize;

    /**
     * MatrixRoom:room-id:
     *
     * The ID of the room this object belongs to.
     */
    matrix_room_properties[PROP_ROOM_ID] = g_param_spec_string(
            "room-id", "room-id", "room-id",
            NULL,
            G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
    g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_ROOM_ID, matrix_room_properties[PROP_ROOM_ID]);

    /**
     * MatrixRoom:aliases:
     *
     * All the known room aliases.
     */
    matrix_room_properties[PROP_ALIASES] = g_param_spec_boxed(
            "aliases", "aliases", "aliases",
            G_TYPE_STRV,
            G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
    g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_ALIASES, matrix_room_properties[PROP_ALIASES]);

    /**
     * MatrixRoom:avatar-url:
     *
     * The URL of the room’s avatar.
     */
    matrix_room_properties[PROP_AVATAR_URL] = g_param_spec_string(
            "avatar-url", "avatar-url", "avatar-url",
            NULL,
            G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
    g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_AVATAR_URL, matrix_room_properties[PROP_AVATAR_URL]);

    /**
     * MatrixRoom:avatar-thumbnail-url:
     *
     * The URL of the room avatar’s thumbnail.
     */
    matrix_room_properties[PROP_AVATAR_THUMBNAIL_URL] = g_param_spec_string(
            "avatar-thumbnail-url", "avatar-thumbnail-url", "avatar-thumbnail-url",
            NULL,
            G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
    g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_AVATAR_THUMBNAIL_URL, matrix_room_properties[PROP_AVATAR_THUMBNAIL_URL]);

    /**
     * MatrixRoom:canonical-alias:
     *
     * The canonical alias of the room.
     */
    matrix_room_properties[PROP_CANONICAL_ALIAS] = g_param_spec_string(
            "canonical-alias", "canonical-alias", "canonical-alias",
            NULL,
            G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
    g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_CANONICAL_ALIAS, matrix_room_properties[PROP_CANONICAL_ALIAS]);

    /**
     * MatrixRoom:creator:
     *
     * The Matrix ID of the room’s creator.
     */
    matrix_room_properties[PROP_CREATOR] = g_param_spec_string(
            "creator", "creator", "creator",
            NULL,
            G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
    g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_CREATOR, matrix_room_properties[PROP_CREATOR]);

    /**
     * MatrixRoom:federate:
     *
     * If %FALSE, the room is not federated.
     */
    matrix_room_properties[PROP_FEDERATE] = g_param_spec_boolean(
            "federate", "federate", "federate",
            FALSE,
            G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
    g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_FEDERATE, matrix_room_properties[PROP_FEDERATE]);

    /**
     * MatrixRoom:guest-access:
     *
     * Wether guests are allowed to join the room.
     */
    matrix_room_properties[PROP_GUEST_ACCESS] = g_param_spec_enum(
            "guest-access", "guest-access", "guest-access",
            MATRIX_TYPE_GUEST_ACCESS, MATRIX_GUEST_ACCESS_UNKNOWN,
            G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
    g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_GUEST_ACCESS, matrix_room_properties[PROP_GUEST_ACCESS]);

    /**
     * MatrixRoom:history-visibility:
     * This value controls the visibility of the room’s history.
     */
    matrix_room_properties[PROP_HISTORY_VISIBILITY] = g_param_spec_enum(
            "history-visibility", "history-visibility", "history-visibility",
            MATRIX_TYPE_HISTORY_VISIBILITY, MATRIX_HISTORY_VISIBILITY_UNKNOWN,
            G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
    g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_HISTORY_VISIBILITY, matrix_room_properties[PROP_HISTORY_VISIBILITY]);
    /**
     * MatrixRoom:join-rules:
     *
     * Controls who can join the room.
     */
    matrix_room_properties[PROP_JOIN_RULES] = g_param_spec_enum(
            "join-rules", "join-rules", "join-rules",
            MATRIX_TYPE_JOIN_RULES, MATRIX_JOIN_RULES_UNKNOWN,
            G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
    g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_JOIN_RULES, matrix_room_properties[PROP_JOIN_RULES]);

    /**
     * MatrixRoom:name:
     *
     * The room’s name.
     */
    matrix_room_properties[PROP_NAME] = g_param_spec_string(
            "name", "name", "name",
            NULL,
            G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
    g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_NAME, matrix_room_properties[PROP_NAME]);

    /**
     * MatrixRoom:default-power-level:
     *
     * The default power level users get upon joining the room.
     */
    matrix_room_properties[PROP_DEFAULT_POWER_LEVEL] = g_param_spec_int(
            "default-power-level", "default-power-level", "default-power-level",
            G_MININT, G_MAXINT, 0,
            G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
    g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_DEFAULT_POWER_LEVEL, matrix_room_properties[PROP_DEFAULT_POWER_LEVEL]);

    /**
     * MatrixRoom:default-event-level:
     *
     * The power level required to send non-state events to the room.  This gets applied if
     * the event type doesn’t have an explicit level requirement (see
     * matrix_room_set_event_level() and matrix_room_get_event_level() for more information).
     */
    matrix_room_properties[PROP_DEFAULT_EVENT_LEVEL] = g_param_spec_int(
            "default-event-level", "default-event-level", "default-event-level",
            G_MININT, G_MAXINT, 0,
            G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
    g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_DEFAULT_EVENT_LEVEL, matrix_room_properties[PROP_DEFAULT_EVENT_LEVEL]);

    /**
     * MatrixRoom:default-state-level:
     *
     * The power level required to send state events to the room.  This get applied if the
     * event type doesn’t have an explicit level requirement (see matrix_room_set_event_level()
     * and matrix_room_get_event_level() for more information).
     */
    matrix_room_properties[PROP_DEFAULT_STATE_LEVEL] = g_param_spec_int(
            "default-state-level", "default-state-level", "default-state-level",
            G_MININT, G_MAXINT, 10,
            G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
    g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_DEFAULT_STATE_LEVEL, matrix_room_properties[PROP_DEFAULT_STATE_LEVEL]);

    /**
     * MatrixRoom:ban-level:
     *
     * The power level required to ban other users from the room.
     */
    matrix_room_properties[PROP_BAN_LEVEL] = g_param_spec_int(
            "ban-level", "ban-level", "ban-level",
            G_MININT, G_MAXINT, 5,
            G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
    g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_BAN_LEVEL, matrix_room_properties[PROP_BAN_LEVEL]);

    /**
     * MatrixRoom:kick-level:
     *
     * The power level required to kick other users from the room.
     */
    matrix_room_properties[PROP_KICK_LEVEL] = g_param_spec_int(
            "kick-level", "kick-level", "kick-level",
            G_MININT, G_MAXINT, 5,
            G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
    g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_KICK_LEVEL, matrix_room_properties[PROP_KICK_LEVEL]);

    /**
     * MatrixRoom:redact-level:
     *
     * The power level required to redact events in the room.
     */
    matrix_room_properties[PROP_REDACT_LEVEL] = g_param_spec_int(
            "redact-level", "redact-level", "redact-level",
            G_MININT, G_MAXINT, 20,
            G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
    g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_REDACT_LEVEL, matrix_room_properties[PROP_REDACT_LEVEL]);

    /**
     * MatrixRoom:invite-level:
     *
     * The power level required to invite users to the room.
     */
    matrix_room_properties[PROP_INVITE_LEVEL] = g_param_spec_int(
            "invite-level", "invite-level", "invite-level",
            G_MININT, G_MAXINT, 0,
            G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
    g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_INVITE_LEVEL, matrix_room_properties[PROP_INVITE_LEVEL]);

    /**
     * MatrixRoom:topic:
     *
     * The room’s topic.
     */
    matrix_room_properties[PROP_TOPIC] = g_param_spec_string(
            "topic", "topic", "topic",
            NULL,
            G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
    g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_TOPIC, matrix_room_properties[PROP_TOPIC]);

    /**
     * MatrixRoom:typing-users:
     *
     * The users currently typing in the room.
     */
    matrix_room_properties[PROP_TYPING_USERS] = g_param_spec_boxed(
            "typing-users", "typing-users", "typing-users",
            G_TYPE_STRV,
            G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
    g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_TYPING_USERS, matrix_room_properties[PROP_TYPING_USERS]);

    /**
     * MatrixRoom:avatar-info:
     *
     * A #MatrixImageInfo describing #MatrixRoom:avatar-url.
     */
    matrix_room_properties[PROP_AVATAR_INFO] = g_param_spec_boxed(
            "avatar-info", "avatar-info", "avatar-info",
            MATRIX_TYPE_IMAGE_INFO,
            G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
    g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_AVATAR_INFO, matrix_room_properties[PROP_AVATAR_INFO]);

    /**
     * MatrixRoom:avatar-thumbnail-info:
     *
     * A #MatrixImageInfo describing #MatrixRoom:avatar-thumbnail-url:
     */
    matrix_room_properties[PROP_AVATAR_THUMBNAIL_INFO] = g_param_spec_boxed(
            "avatar-thumbnail-info", "avatar-thumbnail-info", "avatar-thumbnail-info",
            MATRIX_TYPE_IMAGE_INFO,
            G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
    g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_AVATAR_THUMBNAIL_INFO, matrix_room_properties[PROP_AVATAR_THUMBNAIL_INFO]);
}

static void
matrix_room_init(MatrixRoom *matrix_room)
{
    MatrixRoomPrivate *priv = matrix_room_get_instance_private(matrix_room);

    priv->avatar_url = NULL;
    priv->avatar_info = NULL;
    priv->avatar_thumbnail_url = NULL;
    priv->avatar_thumbnail_info = NULL;
    priv->canonical_alias = NULL;
    priv->creator = NULL;
    priv->federate = FALSE;
    priv->guest_access = MATRIX_GUEST_ACCESS_UNKNOWN;
    priv->history_visibility = MATRIX_HISTORY_VISIBILITY_UNKNOWN;
    priv->join_rules = MATRIX_JOIN_RULES_UNKNOWN;
    priv->name = NULL;
    priv->default_power_level = 0;
    priv->default_event_level = 0;
    priv->default_state_level = 10;
    priv->ban_level = 5;
    priv->kick_level = 5;
    priv->redact_level = 20;
    priv->invite_level = 0;
    priv->topic = NULL;
    priv->event_levels = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
    priv->user_levels = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
    priv->members = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify)matrix_room_member_data_free);
}