/*

 * GNOME Online Miners - crawls through your online content

 * Copyright (c) 2014, 2015 Pranav Kant

 *

 * 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

 * 02110-1301, USA.

 *

 * Author: Pranav Kant <pranavk@gnome.org>

 *

 */

#include "config.h"

#include "gom-dleyna-server-media-device.h"

#include "gom-upnp-media-container2.h"

#include "gom-dlna-server.h"

#include "gom-utils.h"

struct _GomDlnaServerPrivate

{

  DleynaServerMediaDevice *device;

  UpnpMediaContainer2 *container;

  GBusType bus_type;

  GDBusProxyFlags flags;

  gchar *object_path;

  gchar *well_known_name;

};

enum{

  PROP_0,

  PROP_BUS_TYPE,

  PROP_FLAGS,

  PROP_OBJECT_PATH,

  PROP_WELL_KNOWN_NAME,

};

static void gom_dlna_server_initable_iface_init (GInitableIface *iface);

G_DEFINE_TYPE_WITH_CODE (GomDlnaServer, gom_dlna_server, G_TYPE_OBJECT,

                         G_ADD_PRIVATE (GomDlnaServer)

                         G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,

                                                gom_dlna_server_initable_iface_init));

static GomDlnaPhotoItem *

photo_item_new (GVariant *var)

{

  GVariant *tmp;

  GomDlnaPhotoItem *photo;

  const gchar *str;

  photo = g_slice_new0 (GomDlnaPhotoItem);

  g_variant_lookup (var, "DisplayName", "&s", &str);

  photo->name = gom_filename_strip_extension (str);

  g_variant_lookup (var, "MIMEType", "&s", &str);

  photo->mimetype = g_strdup (str);

  g_variant_lookup (var, "Path", "&o", &str);

  photo->path = g_strdup (str);

  g_variant_lookup (var, "Type", "s", &str);

  photo->type = g_strdup (str);

  if (g_str_equal (photo->type, "container"))

    {

      photo->url = NULL;

      goto out;

    }

  g_variant_lookup (var, "URLs", "@as", &tmp);

  g_variant_get_child (tmp, 0, "&s", &str);

  photo->url = g_strdup (str);

  g_variant_unref (tmp);

 out:

  return photo;

}

static GList *

process_children (GVariant *children, GList **photos_list)

{

  GVariantIter *iter = NULL;

  GVariant *var = NULL;

  GList *containers = NULL;

  GomDlnaPhotoItem *photo;

  g_variant_get (children, "aa{sv}", &iter);

  while (g_variant_iter_loop (iter, "@a{sv}", &var))

    {

      photo = photo_item_new (var);

      if (g_str_equal (photo->type, "image.photo"))

        {

          *photos_list = g_list_prepend (*photos_list, photo);

        }

      else if (g_str_equal (photo->type, "container"))

        {

          containers = g_list_prepend (containers, g_strdup (photo->path));

          gom_dlna_photo_item_free (photo);

        }

    }

  return containers;

}

static void

find_photos (const gchar   *obj_path,

             GList        **photos_list)

{

  GError *error = NULL;

  GList *containers = NULL;

  GList *l;

  GVariant *children = NULL;

  UpnpMediaContainer2 *proxy = NULL;

  const gchar *const filter[] = {"DisplayName","Type","Path", "URLs", "MIMEType", NULL};

  proxy = upnp_media_container2_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,

                                                        G_DBUS_PROXY_FLAGS_NONE,

                                                        "com.intel.dleyna-server",

                                                        obj_path,

                                                        NULL, /* GCancellable */

                                                        &error);

  if (error != NULL)

    {

      g_warning ("Unable to get proxy for Upnp.MediaContainer2 : %s",

                 error->message);

      g_error_free (error);

      goto out;

    }

  upnp_media_container2_call_list_children_sync (proxy,

                                                 0,

                                                 0,

                                                 filter,

                                                 &children,

                                                 NULL, /* GCancellable */

                                                 &error);

  if (error != NULL)

    {

      g_warning ("Unable to call ListChildren : %s",

                 error->message);

      g_error_free (error);

      goto out;

    }

  if (children == NULL)

    goto out;

  containers = process_children (children, photos_list);

  if (containers == NULL)

    goto out;

  for (l = containers; l != NULL; l = l->next)

    {

      const gchar *obj_path = (gchar *) l->data;

      find_photos (obj_path, photos_list);

    }

 out:

  g_list_free_full (containers, g_free);

  g_clear_pointer (&children, (GDestroyNotify) g_variant_unref);

  g_clear_object (&proxy);

}

static void

gom_dlna_server_dispose (GObject *object)

{

  GomDlnaServer *self = GOM_DLNA_SERVER (object);

  GomDlnaServerPrivate *priv = self->priv;

  g_clear_object (&priv->device);

  g_clear_object (&priv->container);

  G_OBJECT_CLASS (gom_dlna_server_parent_class)->dispose (object);

}

static void

gom_dlna_server_finalize (GObject *object)

{

  GomDlnaServer *self = GOM_DLNA_SERVER (object);

  GomDlnaServerPrivate *priv = self->priv;

  g_free (priv->well_known_name);

  g_free (priv->object_path);

  G_OBJECT_CLASS (gom_dlna_server_parent_class)->finalize (object);

}

static void

gom_dlna_server_get_property (GObject *object,

                              guint prop_id,

                              GValue *value,

                              GParamSpec *pspec)

{

  GomDlnaServer *self = GOM_DLNA_SERVER (object);

  switch (prop_id)

    {

    case PROP_OBJECT_PATH:

      g_value_set_string (value, gom_dlna_server_get_object_path (self));

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void

gom_dlna_server_set_property (GObject *object,

                              guint prop_id,

                              const GValue *value,

                              GParamSpec *pspec)

{

  GomDlnaServer *self = GOM_DLNA_SERVER (object);

  GomDlnaServerPrivate *priv = self->priv;

  switch (prop_id)

    {

    case PROP_BUS_TYPE:

      priv->bus_type = g_value_get_enum (value);

      break;

    case PROP_FLAGS:

      priv->flags = g_value_get_flags (value);

      break;

    case PROP_OBJECT_PATH:

      priv->object_path = g_value_dup_string (value);

      break;

    case PROP_WELL_KNOWN_NAME:

      priv->well_known_name = g_value_dup_string (value);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void

gom_dlna_server_init (GomDlnaServer *self)

{

  self->priv = gom_dlna_server_get_instance_private (self);

}

static void

gom_dlna_server_class_init (GomDlnaServerClass *class)

{

  GObjectClass *gobject_class = G_OBJECT_CLASS (class);

  gobject_class->dispose = gom_dlna_server_dispose;

  gobject_class->finalize = gom_dlna_server_finalize;

  gobject_class->set_property = gom_dlna_server_set_property;

  gobject_class->get_property = gom_dlna_server_get_property;

  g_object_class_install_property (gobject_class,

                                   PROP_BUS_TYPE,

                                   g_param_spec_enum ("bus-type",

                                                      "Bus Type",

                                                      "The bus to connect to, defaults to the session one",

                                                      G_TYPE_BUS_TYPE,

                                                      G_BUS_TYPE_SESSION,

                                                      G_PARAM_WRITABLE |

                                                      G_PARAM_CONSTRUCT_ONLY |

                                                      G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class,

                                   PROP_FLAGS,

                                   g_param_spec_flags ("flags",

                                                       "Flags",

                                                       "Proxy flags",

                                                       G_TYPE_DBUS_PROXY_FLAGS,

                                                       G_DBUS_PROXY_FLAGS_NONE,

                                                       G_PARAM_READWRITE |

                                                       G_PARAM_CONSTRUCT_ONLY |

                                                       G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class,

                                   PROP_OBJECT_PATH,

                                   g_param_spec_string ("object-path",

                                                        "Object Path",

                                                        "The object path the proxy is for",

                                                        NULL,

                                                        G_PARAM_READWRITE |

                                                        G_PARAM_CONSTRUCT_ONLY |

                                                        G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class,

                                   PROP_WELL_KNOWN_NAME,

                                   g_param_spec_string ("well-known-name",

                                                        "Well-Known Name",

                                                        "The well-known name of the service",

                                                        NULL,

                                                        G_PARAM_READWRITE |

                                                        G_PARAM_CONSTRUCT_ONLY |

                                                        G_PARAM_STATIC_STRINGS));

}

void

gom_dlna_photo_item_free (GomDlnaPhotoItem *photo)

{

  g_free (photo->name);

  g_free (photo->mimetype);

  g_free (photo->path);

  g_free (photo->url);

  g_free (photo->type);

  g_slice_free (GomDlnaPhotoItem, photo);

}

GomDlnaServer *

gom_dlna_server_new_for_bus (GBusType bus_type,

                             GDBusProxyFlags flags,

                             const gchar *well_known_name,

                             const gchar *object_path,

                             GCancellable *cancellable,

                             GError **error)

{

  return g_initable_new (GOM_TYPE_DLNA_SERVER,

                         cancellable,

                         error,

                         "bus-type", bus_type,

                         "flags", flags,

                         "object-path", object_path,

                         "well-known-name", well_known_name,

                         NULL);

}

static gboolean

gom_dlna_server_initable_init (GInitable *initable,

                               GCancellable *cancellable,

                               GError **error)

{

  GomDlnaServer *self = GOM_DLNA_SERVER (initable);

  GomDlnaServerPrivate *priv = self->priv;

  gboolean ret_val = TRUE;

  priv->device =

    dleyna_server_media_device_proxy_new_for_bus_sync (priv->bus_type,

                                                       G_DBUS_PROXY_FLAGS_NONE,

                                                       priv->well_known_name,

                                                       priv->object_path,

                                                       NULL,

                                                       error);

  if (*error != NULL)

    {

      ret_val = FALSE;

      goto out;

    }

  priv->container =

    upnp_media_container2_proxy_new_for_bus_sync (priv->bus_type,

                                                  G_DBUS_PROXY_FLAGS_NONE,

                                                  priv->well_known_name,

                                                  priv->object_path,

                                                  NULL,

                                                  error);

  if (*error != NULL)

    {

      ret_val = FALSE;

      goto out;

    }

 out:

  return ret_val;

}

static void

gom_dlna_server_initable_iface_init (GInitableIface *iface)

{

  iface->init = gom_dlna_server_initable_init;

}

const gchar *

gom_dlna_server_get_object_path (GomDlnaServer *self)

{

  return self->priv->object_path;

}

const gchar *

gom_dlna_server_get_friendly_name (GomDlnaServer *self)

{

  GomDlnaServerPrivate *priv = self->priv;

  return dleyna_server_media_device_get_friendly_name (priv->device);

}

GVariant *

gom_dlna_server_search_objects (GomDlnaServer *self, GError **error)

{

  GomDlnaServerPrivate *priv = self->priv;

  GVariant *out = NULL;

  gchar *query = g_strdup_printf ("Type = \"image.photo\"");

  const gchar const *filter[] = {"DisplayName", "URLs", "Path", "MIMEType", NULL};

  upnp_media_container2_call_search_objects_sync (priv->container,

                                                  query,

                                                  0,

                                                  0,

                                                  filter,

                                                  &out,

                                                  NULL,

                                                  error);

  g_free (query);

  return out;

}

GList *

gom_dlna_server_get_photos (GomDlnaServer *server)

{

  GError *error = NULL;

  GList *photos_list = NULL;

  GVariant *out, *var;

  GVariantIter *iter = NULL;

  GomDlnaPhotoItem *photo;

  if (gom_dlna_server_get_searchable (server))

    {

      out = gom_dlna_server_search_objects (server, &error);

      if (error != NULL)

        {

          g_warning ("Unable to search objects on server : %s",

                     error->message);

          g_error_free (error);

          return NULL;

        }

      g_variant_get (out, "aa{sv}", &iter);

      while (g_variant_iter_loop (iter, "@a{sv}", &var))

        {

          photo = photo_item_new (var);

          photos_list = g_list_prepend (photos_list, photo);

        }

      g_variant_iter_free (iter);

    }

  else

    {

      const gchar *obj_path;

      obj_path = gom_dlna_server_get_object_path (server);

      find_photos (obj_path, &photos_list);

    }

  return photos_list;

}

const gchar *

gom_dlna_server_get_udn (GomDlnaServer *self)

{

  GomDlnaServerPrivate *priv = self->priv;

  return dleyna_server_media_device_get_udn (priv->device);

}

gboolean

gom_dlna_server_get_searchable (GomDlnaServer *self)

{

  GomDlnaServerPrivate *priv = self->priv;

  return upnp_media_container2_get_searchable (priv->container);

}