/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */

/* vim:set et sts=4: */

/* bus - The Input Bus

 * Copyright (C) 2008-2010 Peng Huang <shawn.p.huang@gmail.com>

 * Copyright (C) 2008-2010 Red Hat, Inc.

 *

 * 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 Street, Fifth Floor, Boston, MA  02110-1301

 * USA

 */

#include <unistd.h>

#include "connection.h"

#include "matchrule.h"

struct _BusConnection {

    IBusObject parent;

    /* instance members */

    /* underlying GDBus connetion */

    GDBusConnection *connection;

    /* a unique name of the connection like ":1.0" */

    gchar *unique_name;

    /* list for well known names */

    GList  *names;

    guint  filter_id;

};

struct _BusConnectionClass {

  IBusObjectClass parent;

  /* class members */

};

/* static guint            _signals[LAST_SIGNAL] = { 0 }; */

/* functions prototype */

static void     bus_connection_destroy      (BusConnection      *connection);

static void     bus_connection_set_dbus_connection

                                            (BusConnection      *connection,

                                             GDBusConnection    *dbus_connection);

static void     bus_connection_dbus_connection_closed_cb

                                            (GDBusConnection    *dbus_connection,

                                             gboolean            remote_peer_vanished,

                                             GError             *error,

                                             BusConnection      *connection);

static GQuark   bus_connection_quark        (void);

#define BUS_CONNECTION_QUARK (bus_connection_quark ())

G_DEFINE_TYPE (BusConnection, bus_connection, IBUS_TYPE_OBJECT)

static void

bus_connection_class_init (BusConnectionClass *class)

{

    IBusObjectClass *ibus_object_class = IBUS_OBJECT_CLASS (class);

    ibus_object_class->destroy = (IBusObjectDestroyFunc) bus_connection_destroy;

}

static void

bus_connection_init (BusConnection *connection)

{

}

static void

bus_connection_destroy (BusConnection *connection)

{

    if (connection->connection) {

        /* disconnect from closed signal */

        g_signal_handlers_disconnect_by_func (connection->connection,

                G_CALLBACK (bus_connection_dbus_connection_closed_cb), connection);

        /* remove filter */

        bus_connection_set_filter (connection, NULL, NULL, NULL);

        /* disconnect busconnection with dbus connection */

        g_object_set_qdata ((GObject *)connection->connection, BUS_CONNECTION_QUARK, NULL);

        if (!g_dbus_connection_is_closed (connection->connection)) {

            g_dbus_connection_close (connection->connection, NULL, NULL, NULL);

        }

        g_object_unref (connection->connection);

        connection->connection = NULL;

    }

    if (connection->unique_name) {

        g_free (connection->unique_name);

        connection->unique_name = NULL;

    }

    g_list_free_full (connection->names, g_free);

    connection->names = NULL;

    IBUS_OBJECT_CLASS(bus_connection_parent_class)->destroy (IBUS_OBJECT (connection));

}

static void

bus_connection_dbus_connection_closed_cb (GDBusConnection *dbus_connection,

                                          gboolean         remote_peer_vanished,

                                          GError          *error,

                                          BusConnection   *connection)

{

    ibus_object_destroy ((IBusObject *) connection);

}

static void

bus_connection_set_dbus_connection (BusConnection   *connection,

                                    GDBusConnection *dbus_connection)

{

    connection->connection = dbus_connection;

    g_object_ref (connection->connection);

    g_object_set_qdata_full ((GObject *) dbus_connection,

                             BUS_CONNECTION_QUARK,

                             g_object_ref (connection),

                             (GDestroyNotify) g_object_unref);

    g_signal_connect (connection->connection, "closed",

                G_CALLBACK (bus_connection_dbus_connection_closed_cb), connection);

}

static GQuark

bus_connection_quark (void)

{

    static GQuark quark = 0;

    if (quark == 0) {

        quark = g_quark_from_static_string ("BUS_CONNECTION");

    }

    return quark;

}

BusConnection *

bus_connection_new (GDBusConnection *dbus_connection)

{

    g_return_val_if_fail (bus_connection_lookup (dbus_connection) == NULL, NULL);

    BusConnection *connection = BUS_CONNECTION (g_object_new (BUS_TYPE_CONNECTION, NULL));

    bus_connection_set_dbus_connection (connection, dbus_connection);

    return connection;

}

BusConnection *

bus_connection_lookup (GDBusConnection *dbus_connection)

{

    g_return_val_if_fail (G_IS_DBUS_CONNECTION (dbus_connection), NULL);

    return (BusConnection *) g_object_get_qdata ((GObject *) dbus_connection,

                    BUS_CONNECTION_QUARK);

}

const gchar *

bus_connection_get_unique_name (BusConnection   *connection)

{

    return connection->unique_name;

}

void

bus_connection_set_unique_name (BusConnection   *connection,

                                const gchar     *name)

{

    g_assert (connection->unique_name == NULL); /* we don't allow rewriting the unique_name. */

    connection->unique_name = g_strdup (name);

}

const GList *

bus_connection_get_names (BusConnection   *connection)

{

    return connection->names;

}

const gchar *

bus_connection_add_name (BusConnection     *connection,

                         const gchar       *name)

{

    gchar *new_name;

    new_name = g_strdup (name);

    connection->names = g_list_append (connection->names, new_name);

    return new_name;

}

gboolean

bus_connection_remove_name (BusConnection     *connection,

                            const gchar       *name)

{

    GList *list = g_list_find_custom (connection->names, name, (GCompareFunc) g_strcmp0);

    if (list) {

        g_free (list->data);

        connection->names = g_list_delete_link (connection->names, list);

        return TRUE;

    }

    return FALSE;

}

gboolean

bus_connection_has_name (BusConnection     *connection,

                         const gchar       *name)

{

    GList *list = g_list_find_custom (connection->names, name, (GCompareFunc) g_strcmp0);

    return list != NULL;

}

GDBusConnection *

bus_connection_get_dbus_connection (BusConnection *connection)

{

    g_assert (BUS_IS_CONNECTION (connection));

    return connection->connection;

}

void

bus_connection_set_filter (BusConnection             *connection,

                           GDBusMessageFilterFunction filter_func,

                           gpointer                   user_data,

                           GDestroyNotify             user_data_free_func)

{

    g_assert (BUS_IS_CONNECTION (connection));

    if (connection->filter_id != 0) {

        g_dbus_connection_remove_filter (connection->connection, connection->filter_id);

        connection->filter_id = 0;

    }

    if (filter_func != NULL) {

        connection->filter_id = g_dbus_connection_add_filter (connection->connection,

                                                              filter_func,

                                                              user_data,

                                                              user_data_free_func);

        /* Note: g_dbus_connection_add_filter seems not to return zero as a valid id. */

    }

}