/*
 * ga-entry-group.c - Source for GaEntryGroup
 * Copyright (C) 2006-2007 Collabora Ltd.
 *
 * This library 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 2.1 of the License, or (at your option) any later version.
 *
 * This library 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 this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "avahi-common/avahi-malloc.h"

#include "ga-error.h"
#include "ga-entry-group.h"
#include "ga-entry-group-enumtypes.h"

G_DEFINE_TYPE(GaEntryGroup, ga_entry_group, G_TYPE_OBJECT)

static void _free_service(gpointer data);

/* signal enum */
enum {
    STATE_CHANGED,
    LAST_SIGNAL
};

static guint signals[LAST_SIGNAL] = { 0 };

/* properties */
enum {
    PROP_STATE = 1
};

/* private structures */
typedef struct _GaEntryGroupPrivate GaEntryGroupPrivate;

struct _GaEntryGroupPrivate {
    GaEntryGroupState state;
    GaClient *client;
    AvahiEntryGroup *group;
    GHashTable *services;
    gboolean dispose_has_run;
};

typedef struct _GaEntryGroupServicePrivate GaEntryGroupServicePrivate;

struct _GaEntryGroupServicePrivate {
    GaEntryGroupService public;
    GaEntryGroup *group;
    gboolean frozen;
    GHashTable *entries;
};

typedef struct _GaEntryGroupServiceEntry GaEntryGroupServiceEntry;

struct _GaEntryGroupServiceEntry {
    guint8 *value;
    gsize size;
};


#define GA_ENTRY_GROUP_GET_PRIVATE(o)     (G_TYPE_INSTANCE_GET_PRIVATE ((o), GA_TYPE_ENTRY_GROUP, GaEntryGroupPrivate))

static void ga_entry_group_init(GaEntryGroup * obj) {
    GaEntryGroupPrivate *priv = GA_ENTRY_GROUP_GET_PRIVATE(obj);
    /* allocate any data required by the object here */
    priv->state = GA_ENTRY_GROUP_STATE_UNCOMMITED;
    priv->client = NULL;
    priv->group = NULL;
    priv->services = g_hash_table_new_full(g_direct_hash,
                                           g_direct_equal,
                                           NULL, _free_service);
}

static void ga_entry_group_dispose(GObject * object);
static void ga_entry_group_finalize(GObject * object);

static void ga_entry_group_get_property(GObject * object,
                            guint property_id,
                            GValue * value, GParamSpec * pspec) {
    GaEntryGroup *group = GA_ENTRY_GROUP(object);
    GaEntryGroupPrivate *priv = GA_ENTRY_GROUP_GET_PRIVATE(group);

    switch (property_id) {
        case PROP_STATE:
            g_value_set_enum(value, priv->state);
            break;
        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
            break;
    }
}

static void ga_entry_group_class_init(GaEntryGroupClass * ga_entry_group_class) {
    GObjectClass *object_class = G_OBJECT_CLASS(ga_entry_group_class);
    GParamSpec *param_spec;

    g_type_class_add_private(ga_entry_group_class,
                             sizeof (GaEntryGroupPrivate));

    object_class->dispose = ga_entry_group_dispose;
    object_class->finalize = ga_entry_group_finalize;
    object_class->get_property = ga_entry_group_get_property;

    param_spec = g_param_spec_enum("state", "Entry Group state",
                                   "The state of the avahi entry group",
                                   GA_TYPE_ENTRY_GROUP_STATE,
                                   GA_ENTRY_GROUP_STATE_UNCOMMITED,
                                   G_PARAM_READABLE |
                                   G_PARAM_STATIC_NAME |
                                   G_PARAM_STATIC_BLURB);
    g_object_class_install_property(object_class, PROP_STATE, param_spec);

    signals[STATE_CHANGED] =
            g_signal_new("state-changed",
                         G_OBJECT_CLASS_TYPE(ga_entry_group_class),
                         G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
                         0,
                         NULL, NULL,
                         g_cclosure_marshal_VOID__ENUM,
                         G_TYPE_NONE, 1, GA_TYPE_ENTRY_GROUP_STATE);
}

void ga_entry_group_dispose(GObject * object) {
    GaEntryGroup *self = GA_ENTRY_GROUP(object);
    GaEntryGroupPrivate *priv = GA_ENTRY_GROUP_GET_PRIVATE(self);

    if (priv->dispose_has_run)
        return;
    priv->dispose_has_run = TRUE;

    /* release any references held by the object here */
    if (priv->group) {
        avahi_entry_group_free(priv->group);
        priv->group = NULL;
    }

    if (priv->client) {
        g_object_unref(priv->client);
        priv->client = NULL;
    }

    if (G_OBJECT_CLASS(ga_entry_group_parent_class)->dispose)
        G_OBJECT_CLASS(ga_entry_group_parent_class)->dispose(object);
}

void ga_entry_group_finalize(GObject * object) {
    GaEntryGroup *self = GA_ENTRY_GROUP(object);
    GaEntryGroupPrivate *priv = GA_ENTRY_GROUP_GET_PRIVATE(self);

    /* free any data held directly by the object here */
    g_hash_table_destroy(priv->services);
    priv->services = NULL;

    G_OBJECT_CLASS(ga_entry_group_parent_class)->finalize(object);
}

static void _free_service(gpointer data) {
    GaEntryGroupService *s = (GaEntryGroupService *) data;
    GaEntryGroupServicePrivate *p = (GaEntryGroupServicePrivate *) s;
    g_free(s->name);
    g_free(s->type);
    g_free(s->domain);
    g_free(s->host);
    g_hash_table_destroy(p->entries);
    g_free(s);
}

static GQuark detail_for_state(AvahiEntryGroupState state) {
    static struct {
        AvahiEntryGroupState state;
        const gchar *name;
        GQuark quark;
    } states[] = {
        { AVAHI_ENTRY_GROUP_UNCOMMITED, "uncommited", 0},
        { AVAHI_ENTRY_GROUP_REGISTERING, "registering", 0},
        { AVAHI_ENTRY_GROUP_ESTABLISHED, "established", 0},
        { AVAHI_ENTRY_GROUP_COLLISION, "collistion", 0},
        { AVAHI_ENTRY_GROUP_FAILURE, "failure", 0},
        { 0, NULL, 0}
    };
    int i;

    for (i = 0; states[i].name != NULL; i++) {
        if (state != states[i].state)
            continue;

        if (!states[i].quark)
            states[i].quark = g_quark_from_static_string(states[i].name);
        return states[i].quark;
    }
    g_assert_not_reached();
}

static void _avahi_entry_group_cb(AvahiEntryGroup * g,
                      AvahiEntryGroupState state, void *data) {
    GaEntryGroup *self = GA_ENTRY_GROUP(data);
    GaEntryGroupPrivate *priv = GA_ENTRY_GROUP_GET_PRIVATE(self);

    /* Avahi can call the callback before return from _client_new */
    if (priv->group == NULL)
        priv->group = g;

    g_assert(g == priv->group);
    priv->state = state;
    g_signal_emit(self, signals[STATE_CHANGED],
                  detail_for_state(state), state);
}

GaEntryGroup *ga_entry_group_new(void) {
    return g_object_new(GA_TYPE_ENTRY_GROUP, NULL);
}

static guint _entry_hash(gconstpointer v) {
    const GaEntryGroupServiceEntry *entry =
            (const GaEntryGroupServiceEntry *) v;
    guint32 h = 0;
    guint i;

    for (i = 0; i < entry->size; i++) {
        h = (h << 5) - h + entry->value[i];
    }

    return h;
}

static gboolean _entry_equal(gconstpointer a, gconstpointer b) {
    const GaEntryGroupServiceEntry *aentry =
            (const GaEntryGroupServiceEntry *) a;
    const GaEntryGroupServiceEntry *bentry =
            (const GaEntryGroupServiceEntry *) b;

    if (aentry->size != bentry->size) {
        return FALSE;
    }

    return memcmp(aentry->value, bentry->value, aentry->size) == 0;
}

static GaEntryGroupServiceEntry *_new_entry(const guint8 * value, gsize size) {
    GaEntryGroupServiceEntry *entry;

    if (value == NULL) {
        return NULL;
    }

    entry = g_slice_new(GaEntryGroupServiceEntry);
    entry->value = g_malloc(size + 1);
    memcpy(entry->value, value, size);
    /* for string keys, make sure it's NUL-terminated too */
    entry->value[size] = 0;
    entry->size = size;

    return entry;
}

static void _set_entry(GHashTable * table, const guint8 * key, gsize ksize,
           const guint8 * value, gsize vsize) {

    g_hash_table_insert(table, _new_entry(key, ksize),
                        _new_entry(value, vsize));
}

static void _free_entry(gpointer data) {
    GaEntryGroupServiceEntry *entry = (GaEntryGroupServiceEntry *) data;

    if (entry == NULL) {
        return;
    }

    g_free(entry->value);
    g_slice_free(GaEntryGroupServiceEntry, entry);
}

static GHashTable *_string_list_to_hash(AvahiStringList * list) {
    GHashTable *ret;
    AvahiStringList *t;

    ret = g_hash_table_new_full(_entry_hash,
                                _entry_equal, _free_entry, _free_entry);

    for (t = list; t != NULL; t = avahi_string_list_get_next(t)) {
        gchar *key;
        gchar *value;
        gsize size;
        int r;

        /* list_get_pair only fails if if memory allocation fails. Normal glib
         * behaviour is to assert/abort when that happens */
        r = avahi_string_list_get_pair(t, &key, &value, &size);
        g_assert(r == 0);

        if (value == NULL) {
            _set_entry(ret, t->text, t->size, NULL, 0);
        } else {
            _set_entry(ret, (const guint8 *) key, strlen(key),
                       (const guint8 *) value, size);
        }
        avahi_free(key);
        avahi_free(value);
    }
    return ret;
}

static void _hash_to_string_list_foreach(gpointer key, gpointer value, gpointer data) {
    AvahiStringList **list = (AvahiStringList **) data;
    GaEntryGroupServiceEntry *kentry = (GaEntryGroupServiceEntry *) key;
    GaEntryGroupServiceEntry *ventry = (GaEntryGroupServiceEntry *) value;

    if (value != NULL) {
        *list = avahi_string_list_add_pair_arbitrary(*list,
                                                     (gchar *) kentry->value,
                                                     ventry->value,
                                                     ventry->size);
    } else {
        *list = avahi_string_list_add_arbitrary(*list,
                                                kentry->value, kentry->size);
    }
}

static AvahiStringList *_hash_to_string_list(GHashTable * table) {
    AvahiStringList *list = NULL;
    g_hash_table_foreach(table, _hash_to_string_list_foreach,
                         (gpointer) & list);
    return list;
}

GaEntryGroupService *ga_entry_group_add_service_strlist(GaEntryGroup * group,
                                                        const gchar * name,
                                                        const gchar * type,
                                                        guint16 port,
                                                        GError ** error,
                                                        AvahiStringList *
                                                        txt) {
    return ga_entry_group_add_service_full_strlist(group, AVAHI_IF_UNSPEC,
                                                   AVAHI_PROTO_UNSPEC, 0,
                                                   name, type, NULL, NULL,
                                                   port, error, txt);
}

GaEntryGroupService *ga_entry_group_add_service_full_strlist(GaEntryGroup *
                                                             group,
                                                             AvahiIfIndex
                                                             interface,
                                                             AvahiProtocol
                                                             protocol,
                                                             AvahiPublishFlags
                                                             flags,
                                                             const gchar *
                                                             name,
                                                             const gchar *
                                                             type,
                                                             const gchar *
                                                             domain,
                                                             const gchar *
                                                             host,
                                                             guint16 port,
                                                             GError ** error,
                                                             AvahiStringList *
                                                             txt) {
    GaEntryGroupPrivate *priv = GA_ENTRY_GROUP_GET_PRIVATE(group);
    GaEntryGroupServicePrivate *service = NULL;
    int ret;

    ret = avahi_entry_group_add_service_strlst(priv->group,
                                               interface, protocol,
                                               flags,
                                               name, type,
                                               domain, host, port, txt);
    if (ret) {
        if (error != NULL) {
            *error = g_error_new(GA_ERROR, ret,
                                 "Adding service to group failed: %s",
                                 avahi_strerror(ret));
        }
        goto out;
    }

    service = g_new0(GaEntryGroupServicePrivate, 1);
    service->public.interface = interface;
    service->public.protocol = protocol;
    service->public.flags = flags;
    service->public.name = g_strdup(name);
    service->public.type = g_strdup(type);
    service->public.domain = g_strdup(domain);
    service->public.host = g_strdup(host);
    service->public.port = port;
    service->group = group;
    service->frozen = FALSE;
    service->entries = _string_list_to_hash(txt);
    g_hash_table_insert(priv->services, group, service);
  out:
    return (GaEntryGroupService *) service;
}

GaEntryGroupService *ga_entry_group_add_service(GaEntryGroup * group,
                                                const gchar * name,
                                                const gchar * type,
                                                guint16 port,
                                                GError ** error, ...) {
    GaEntryGroupService *ret;
    AvahiStringList *txt = NULL;
    va_list va;
    va_start(va, error);
    txt = avahi_string_list_new_va(va);

    ret = ga_entry_group_add_service_full_strlist(group,
                                                  AVAHI_IF_UNSPEC,
                                                  AVAHI_PROTO_UNSPEC,
                                                  0,
                                                  name, type,
                                                  NULL, NULL,
                                                  port, error, txt);
    avahi_string_list_free(txt);
    va_end(va);
    return ret;
}

GaEntryGroupService *ga_entry_group_add_service_full(GaEntryGroup * group,
                                                     AvahiIfIndex interface,
                                                     AvahiProtocol protocol,
                                                     AvahiPublishFlags flags,
                                                     const gchar * name,
                                                     const gchar * type,
                                                     const gchar * domain,
                                                     const gchar * host,
                                                     guint16 port,
                                                     GError ** error, ...) {
    GaEntryGroupService *ret;
    AvahiStringList *txt = NULL;
    va_list va;

    va_start(va, error);
    txt = avahi_string_list_new_va(va);

    ret = ga_entry_group_add_service_full_strlist(group,
                                                  interface, protocol,
                                                  flags,
                                                  name, type,
                                                  domain, host,
                                                  port, error, txt);
    avahi_string_list_free(txt);
    va_end(va);
    return ret;
}

gboolean ga_entry_group_add_record(GaEntryGroup * group,
                          AvahiPublishFlags flags,
                          const gchar * name,
                          guint16 type,
                          guint32 ttl,
                          const void *rdata, gsize size, GError ** error) {
    return ga_entry_group_add_record_full(group,
                                          AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC,
                                          flags, name, AVAHI_DNS_CLASS_IN,
                                          type, ttl, rdata, size, error);
}

gboolean ga_entry_group_add_record_full(GaEntryGroup * group,
                               AvahiIfIndex interface,
                               AvahiProtocol protocol,
                               AvahiPublishFlags flags,
                               const gchar * name,
                               guint16 clazz,
                               guint16 type,
                               guint32 ttl,
                               const void *rdata,
                               gsize size, GError ** error) {
    int ret;
    GaEntryGroupPrivate *priv = GA_ENTRY_GROUP_GET_PRIVATE(group);
    g_assert(group != NULL && priv->group != NULL);

    ret = avahi_entry_group_add_record(priv->group, interface, protocol,
                                       flags, name, clazz, type, ttl, rdata,
                                       size);
    if (ret) {
        if (error != NULL) {
            *error = g_error_new(GA_ERROR, ret,
                                 "Setting raw record failed: %s",
                                 avahi_strerror(ret));
        }
        return FALSE;
    }
    return TRUE;
}


void ga_entry_group_service_freeze(GaEntryGroupService * service) {
    GaEntryGroupServicePrivate *p = (GaEntryGroupServicePrivate *) service;
    p->frozen = TRUE;
}

gboolean ga_entry_group_service_thaw(GaEntryGroupService * service, GError ** error) {
    GaEntryGroupServicePrivate *priv = (GaEntryGroupServicePrivate *) service;
    int ret;
    gboolean result = TRUE;

    AvahiStringList *txt = _hash_to_string_list(priv->entries);
    ret = avahi_entry_group_update_service_txt_strlst
            (GA_ENTRY_GROUP_GET_PRIVATE(priv->group)->group,
             service->interface, service->protocol, service->flags,
             service->name, service->type, service->domain, txt);
    if (ret) {
        if (error != NULL) {
            *error = g_error_new(GA_ERROR, ret,
                                 "Updating txt record failed: %s",
                                 avahi_strerror(ret));
        }
        result = FALSE;
    }

    avahi_string_list_free(txt);
    priv->frozen = FALSE;
    return result;
}

gboolean ga_entry_group_service_set(GaEntryGroupService * service,
                           const gchar * key, const gchar * value,
                           GError ** error) {
    return ga_entry_group_service_set_arbitrary(service, key,
                                                (const guint8 *) value,
                                                strlen(value), error);

}

gboolean ga_entry_group_service_set_arbitrary(GaEntryGroupService * service,
                                     const gchar * key, const guint8 * value,
                                     gsize size, GError ** error) {
    GaEntryGroupServicePrivate *priv = (GaEntryGroupServicePrivate *) service;

    _set_entry(priv->entries, (const guint8 *) key, strlen(key), value, size);

    if (!priv->frozen)
        return ga_entry_group_service_thaw(service, error);
    else
        return TRUE;
}

gboolean ga_entry_group_service_remove_key(GaEntryGroupService * service,
                                  const gchar * key, GError ** error) {
    GaEntryGroupServicePrivate *priv = (GaEntryGroupServicePrivate *) service;
    GaEntryGroupServiceEntry entry;

    entry.value = (void*) key;
    entry.size = strlen(key);

    g_hash_table_remove(priv->entries, &entry);

    if (!priv->frozen)
        return ga_entry_group_service_thaw(service, error);
    else
        return TRUE;
}


gboolean ga_entry_group_attach(GaEntryGroup * group,
                      GaClient * client, GError ** error) {
    GaEntryGroupPrivate *priv = GA_ENTRY_GROUP_GET_PRIVATE(group);

    g_return_val_if_fail(client->avahi_client, FALSE);
    g_assert(priv->client == NULL || priv->client == client);
    g_assert(priv->group == NULL);

    priv->client = client;
    g_object_ref(client);

    priv->group = avahi_entry_group_new(client->avahi_client,
                                        _avahi_entry_group_cb, group);
    if (priv->group == NULL) {
        if (error != NULL) {
            int aerrno = avahi_client_errno(client->avahi_client);
            *error = g_error_new(GA_ERROR, aerrno,
                                 "Attaching group failed: %s",
                                 avahi_strerror(aerrno));
        }
        return FALSE;
    }
    return TRUE;
}

gboolean ga_entry_group_commit(GaEntryGroup * group, GError ** error) {
    GaEntryGroupPrivate *priv = GA_ENTRY_GROUP_GET_PRIVATE(group);
    int ret;
    ret = avahi_entry_group_commit(priv->group);
    if (ret) {
        if (error != NULL) {
            *error = g_error_new(GA_ERROR, ret,
                                 "Committing group failed: %s",
                                 avahi_strerror(ret));
        }
        return FALSE;
    }
    return TRUE;
}

gboolean ga_entry_group_reset(GaEntryGroup * group, GError ** error) {
    GaEntryGroupPrivate *priv = GA_ENTRY_GROUP_GET_PRIVATE(group);
    int ret;
    ret = avahi_entry_group_reset(priv->group);
    if (ret) {
        if (error != NULL) {
            *error = g_error_new(GA_ERROR, ret,
                                 "Resetting group failed: %s",
                                 avahi_strerror(ret));
        }
        return FALSE;
    }
    return TRUE;
}