/*

 * Copyright © 2013 Intel Corporation.

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms and conditions of the GNU Lesser General Public License,

 * version 2.1, as published by the Free Software Foundation.

 *

 * This program is distributed in the hope 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 Lesser General Public License

 * along with this program; if not, see <http://www.gnu.org/licenses>

 *

 * Author: Michael Wood <michael.g.wood@intel.com>

 */

#include "mpris-controller.h"

#include "bus-watch-namespace.h"

#include <gio/gio.h>

G_DEFINE_TYPE (MprisController, mpris_controller, G_TYPE_OBJECT)

#define CONTROLLER_PRIVATE(o) \

  (G_TYPE_INSTANCE_GET_PRIVATE ((o), MPRIS_TYPE_CONTROLLER, MprisControllerPrivate))

enum {

  PROP_0,

  PROP_HAS_ACTIVE_PLAYER

};

struct _MprisControllerPrivate

{

  GCancellable *cancellable;

  GDBusProxy *mpris_client_proxy;

  guint namespace_watcher_id;

  GSList *other_players;

  gboolean connecting;

};

static void

mpris_controller_dispose (GObject *object)

{

  MprisControllerPrivate *priv = MPRIS_CONTROLLER (object)->priv;

  g_clear_object (&priv->cancellable);

  g_clear_object (&priv->mpris_client_proxy);

  if (priv->namespace_watcher_id)

    {

      bus_unwatch_namespace (priv->namespace_watcher_id);

      priv->namespace_watcher_id = 0;

    }

  if (priv->other_players)

    {

      g_slist_free_full (priv->other_players, g_free);

      priv->other_players = NULL;

    }

  G_OBJECT_CLASS (mpris_controller_parent_class)->dispose (object);

}

static void

mpris_proxy_call_done (GObject      *object,

                       GAsyncResult *res,

                       gpointer      user_data)

{

  GError *error = NULL;

  GVariant *ret;

  if (!(ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (object), res, &error)))

    {

      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))

        g_warning ("Error calling method %s", error->message);

      g_clear_error (&error);

      return;

    }

  g_variant_unref (ret);

}

gboolean

mpris_controller_key (MprisController *self, const gchar *key)

{

  MprisControllerPrivate *priv = MPRIS_CONTROLLER (self)->priv;

  if (!priv->mpris_client_proxy)

    return FALSE;

  if (g_strcmp0 (key, "Play") == 0)

    key = "PlayPause";

  g_debug ("calling %s over dbus to mpris client %s",

           key, g_dbus_proxy_get_name (priv->mpris_client_proxy));

  g_dbus_proxy_call (priv->mpris_client_proxy,

                     key, NULL, 0, -1, priv->cancellable,

                     mpris_proxy_call_done,

                     NULL);

  return TRUE;

}

static void

mpris_proxy_ready_cb (GObject      *object,

                      GAsyncResult *res,

                      gpointer      user_data)

{

  MprisControllerPrivate *priv;

  GError *error = NULL;

  GDBusProxy *proxy;

  proxy = g_dbus_proxy_new_for_bus_finish (res, &error);

  if (!proxy)

    {

      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))

        g_warning ("Error connecting to mpris interface %s", error->message);

      g_clear_error (&error);

      return;

    }

  priv = MPRIS_CONTROLLER (user_data)->priv;

  priv->mpris_client_proxy = proxy;

  priv->connecting = FALSE;

  g_object_notify (user_data, "has-active-player");

}

static void

start_mpris_proxy (MprisController *self, const gchar *name)

{

  MprisControllerPrivate *priv = MPRIS_CONTROLLER (self)->priv;

  g_debug ("Creating proxy for for %s", name);

  g_dbus_proxy_new_for_bus (G_BUS_TYPE_SESSION,

                            0,

                            NULL,

                            name,

                            "/org/mpris/MediaPlayer2",

                            "org.mpris.MediaPlayer2.Player",

                            priv->cancellable,

                            mpris_proxy_ready_cb,

                            self);

  priv->connecting = TRUE;

}

static void

mpris_player_appeared (GDBusConnection *connection,

                       const gchar     *name,

                       const gchar     *name_owner,

                       gpointer         user_data)

{

  MprisController *self = user_data;

  MprisControllerPrivate *priv = MPRIS_CONTROLLER (self)->priv;

  if (priv->mpris_client_proxy == NULL && !priv->connecting)

    start_mpris_proxy (self, name);

  else

    self->priv->other_players = g_slist_prepend (self->priv->other_players, g_strdup (name));

}

static void

mpris_player_vanished (GDBusConnection *connection,

                       const gchar     *name,

                       gpointer         user_data)

{

  MprisController *self = user_data;

  MprisControllerPrivate *priv = MPRIS_CONTROLLER (self)->priv;

  if (priv->mpris_client_proxy &&

      g_strcmp0 (name, g_dbus_proxy_get_name (priv->mpris_client_proxy)) == 0)

    {

      g_clear_object (&priv->mpris_client_proxy);

      g_object_notify (user_data, "has-active-player");

      /* take the next one if there's one */

      if (self->priv->other_players && !priv->connecting)

        {

          GSList *first;

          gchar *name;

          first = self->priv->other_players;

          name = first->data;

          start_mpris_proxy (self, name);

          self->priv->other_players = self->priv->other_players->next;

          g_free (name);

          g_slist_free_1 (first);

        }

    }

}

static void

mpris_controller_constructed (GObject *object)

{

  MprisControllerPrivate *priv = MPRIS_CONTROLLER (object)->priv;

  priv->namespace_watcher_id = bus_watch_namespace (G_BUS_TYPE_SESSION,

                                                    "org.mpris.MediaPlayer2",

                                                    mpris_player_appeared,

                                                    mpris_player_vanished,

                                                    MPRIS_CONTROLLER (object),

                                                    NULL);

}

static void

mpris_controller_get_property (GObject    *object,

                               guint       prop_id,

                               GValue     *value,

                               GParamSpec *pspec)

{

  MprisController *self = MPRIS_CONTROLLER (object);

  switch (prop_id) {

  case PROP_HAS_ACTIVE_PLAYER:

    g_value_set_boolean (value,

                         mpris_controller_get_has_active_player (self));

    break;

  default:

    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

    break;

  }

}

static void

mpris_controller_class_init (MprisControllerClass *klass)

{

  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  g_type_class_add_private (klass, sizeof (MprisControllerPrivate));

  object_class->constructed = mpris_controller_constructed;

  object_class->dispose = mpris_controller_dispose;

  object_class->get_property = mpris_controller_get_property;

  g_object_class_install_property (object_class,

                                   PROP_HAS_ACTIVE_PLAYER,

                                   g_param_spec_boolean ("has-active-player",

                                                         NULL,

                                                         NULL,

                                                         FALSE,

                                                         G_PARAM_READABLE));

}

static void

mpris_controller_init (MprisController *self)

{

  self->priv = CONTROLLER_PRIVATE (self);

}

gboolean

mpris_controller_get_has_active_player (MprisController *controller)

{

  g_return_val_if_fail (MPRIS_IS_CONTROLLER (controller), FALSE);

  return (controller->priv->mpris_client_proxy != NULL);

}

MprisController *

mpris_controller_new (void)

{

  return g_object_new (MPRIS_TYPE_CONTROLLER, NULL);

}