/*

 * GNOME Online Miners - crawls through your online content

 * Copyright (c) 2011, 2012 Red Hat, Inc.

 *

 * 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: Cosimo Cecchi <cosimoc@redhat.com>

 *

 */

#include <glib.h>

#include "gom-tracker.h"

#include "gom-utils.h"

static gchar *

_tracker_utils_format_into_graph (const gchar *graph)

{

  return (graph != NULL) ? g_strdup_printf ("INTO <%s> ", graph) : g_strdup ("");

}

static gboolean

gom_tracker_sparql_connection_get_string_attribute (TrackerSparqlConnection *connection,

                                                    GCancellable *cancellable,

                                                    GError **error,

                                                    const gchar *resource,

                                                    const gchar *attribute,

                                                    gchar **value)

{

  GString *select = g_string_new (NULL);

  TrackerSparqlCursor *cursor;

  const gchar *string_value = NULL;

  gboolean res;

  g_string_append_printf (select, "SELECT ?val { <%s> %s ?val }",

                          resource, attribute);

  cursor = tracker_sparql_connection_query (connection,

                                            select->str,

                                            cancellable, error);

  g_string_free (select, TRUE);

  if (*error != NULL)

    goto out;

  res = tracker_sparql_cursor_next (cursor, cancellable, error);

  if (*error != NULL)

    goto out;

  if (res)

    {

      string_value = tracker_sparql_cursor_get_string (cursor, 0, NULL);

      goto out;

    }

 out:

  if (string_value != NULL && value != NULL)

    *value = g_strdup (string_value);

  else if (string_value == NULL)

    res = FALSE;

  g_clear_object (&cursor);

  return res;

}

gchar *

gom_tracker_sparql_connection_ensure_resource (TrackerSparqlConnection *connection,

                                               GCancellable *cancellable,

                                               GError **error,

                                               gboolean *resource_exists,

                                               const gchar *graph,

                                               const gchar *identifier,

                                               const gchar *class,

                                               ...)

{

  GString *select, *insert, *inner;

  va_list args;

  const gchar *arg;

  TrackerSparqlCursor *cursor;

  gboolean res;

  gchar *retval = NULL;

  gchar *graph_str;

  GVariant *insert_res;

  GVariantIter *iter;

  gchar *key = NULL, *val = NULL;

  gboolean exists = FALSE;

  /* build the inner query with all the classes */

  va_start (args, class);

  inner = g_string_new (NULL);

  for (arg = class; arg != NULL; arg = va_arg (args, const gchar *))

    g_string_append_printf (inner, " a %s; ", arg);

  g_string_append_printf (inner, "nao:identifier \"%s\"", identifier);

  va_end (args);

  /* query if such a resource is already in the DB */

  select = g_string_new (NULL);

  g_string_append_printf (select,

                          "SELECT ?urn WHERE { ?urn %s }", inner->str);

  cursor = tracker_sparql_connection_query (connection,

                                            select->str,

                                            cancellable, error);

  g_string_free (select, TRUE);

  if (*error != NULL)

    goto out;

  res = tracker_sparql_cursor_next (cursor, cancellable, error);

  if (*error != NULL)

    goto out;

  if (res)

    {

      /* return the found resource */

      retval = g_strdup (tracker_sparql_cursor_get_string (cursor, 0, NULL));

      exists = TRUE;

      g_debug ("Found resource in the store: %s", retval);

      goto out;

    }

  /* not found, create the resource */

  insert = g_string_new (NULL);

  graph_str = _tracker_utils_format_into_graph (graph);

  g_string_append_printf (insert, "INSERT %s { _:res %s }",

                          graph_str, inner->str);

  g_free (graph_str);

  g_string_free (inner, TRUE);

  insert_res =

    tracker_sparql_connection_update_blank (connection, insert->str,

                                            G_PRIORITY_DEFAULT, NULL, error);

  g_string_free (insert, TRUE);

  if (*error != NULL)

    goto out;

  /* the result is an "aaa{ss}" variant */

  g_variant_get (insert_res, "aaa{ss}", &iter);

  g_variant_iter_next (iter, "aa{ss}", &iter);

  g_variant_iter_next (iter, "a{ss}", &iter);

  g_variant_iter_next (iter, "{ss}", &key, &val;;

  g_variant_iter_free (iter);

  g_variant_unref (insert_res);

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

    {

      retval = val;

    }

  else

    {

      g_free (val);

      goto out;

    }

  g_debug ("Created a new resource: %s", retval);

 out:

  if (resource_exists)

    *resource_exists = exists;

  g_clear_object (&cursor);

  return retval;

}

gboolean

gom_tracker_sparql_connection_insert_or_replace_triple (TrackerSparqlConnection *connection,

                                                        GCancellable *cancellable,

                                                        GError **error,

                                                        const gchar *graph,

                                                        const gchar *resource,

                                                        const gchar *property_name,

                                                        const gchar *property_value)

{

  GString *insert;

  gchar *graph_str, *quoted;

  gboolean retval = TRUE;

  graph_str = _tracker_utils_format_into_graph (graph);

  /* the "null" value must not be quoted */

  if (property_value == NULL)

    quoted = g_strdup ("null");

  else

    quoted = g_strdup_printf ("\"%s\"", property_value);

  insert = g_string_new (NULL);

  g_string_append_printf

    (insert,

     "INSERT OR REPLACE %s { <%s> a nie:InformationElement ; %s %s }",

     graph_str, resource, property_name, quoted);

  g_free (quoted);

  g_debug ("Insert or replace triple: query %s", insert->str);

  tracker_sparql_connection_update (connection, insert->str,

                                    G_PRIORITY_DEFAULT, cancellable,

                                    error);

  g_string_free (insert, TRUE);

  if (*error != NULL)

    retval = FALSE;

  g_free (graph_str);

  return retval;

}

gboolean

gom_tracker_sparql_connection_set_triple (TrackerSparqlConnection *connection,

                                          GCancellable *cancellable,

                                          GError **error,

                                          const gchar *graph,

                                          const gchar *resource,

                                          const gchar *property_name,

                                          const gchar *property_value)

{

  GString *delete;

  gboolean retval = TRUE;

  delete = g_string_new (NULL);

  g_string_append_printf

    (delete,

     "DELETE { <%s> %s ?val } WHERE { <%s> %s ?val }", resource,

     property_name, resource, property_name);

  tracker_sparql_connection_update (connection, delete->str,

                                    G_PRIORITY_DEFAULT, cancellable,

                                    error);

  g_string_free (delete, TRUE);

  if (*error != NULL)

    {

      retval = FALSE;

      goto out;

    }

  retval =

    gom_tracker_sparql_connection_insert_or_replace_triple (connection,

                                                            cancellable, error,

                                                            graph, resource,

                                                            property_name, property_value);

 out:

  return retval;

}

gboolean

gom_tracker_sparql_connection_toggle_favorite (TrackerSparqlConnection *connection,

                                               GCancellable *cancellable,

                                               GError **error,

                                               const gchar *resource,

                                               gboolean favorite)

{

  GString *update;

  const gchar *op_str = NULL;

  gboolean retval = TRUE;

  if (favorite)

    op_str = "INSERT OR REPLACE";

  else

    op_str = "DELETE";

  update = g_string_new (NULL);

  g_string_append_printf

    (update,

     "%s { <%s> nao:hasTag nao:predefined-tag-favorite }",

     op_str, resource);

  g_debug ("Toggle favorite: query %s", update->str);

  tracker_sparql_connection_update (connection, update->str,

                                    G_PRIORITY_DEFAULT, cancellable,

                                    error);

  g_string_free (update, TRUE);

  if (*error != NULL)

    retval = FALSE;

  return retval;

}

gchar*

gom_tracker_utils_ensure_contact_resource (TrackerSparqlConnection *connection,

                                           GCancellable *cancellable,

                                           GError **error,

                                           const gchar *email,

                                           const gchar *fullname)

{

  GString *select, *insert;

  TrackerSparqlCursor *cursor = NULL;

  gchar *retval = NULL, *mail_uri = NULL;

  gboolean res;

  GVariant *insert_res;

  GVariantIter *iter;

  gchar *key = NULL, *val = NULL;

  mail_uri = g_strconcat ("mailto:", email, NULL);

  select = g_string_new (NULL);

  g_string_append_printf (select,

                          "SELECT ?urn WHERE { ?urn a nco:Contact . "

                          "?urn nco:hasEmailAddress ?mail . "

                          "FILTER (fn:contains(?mail, \"%s\" )) }", mail_uri);

  cursor = tracker_sparql_connection_query (connection,

                                            select->str,

                                            cancellable, error);

  g_string_free (select, TRUE);

  if (*error != NULL)

    goto out;

  res = tracker_sparql_cursor_next (cursor, cancellable, error);

  if (*error != NULL)

    goto out;

  if (res)

    {

      /* return the found resource */

      retval = g_strdup (tracker_sparql_cursor_get_string (cursor, 0, NULL));

      g_debug ("Found resource in the store: %s", retval);

      goto out;

    }

  /* not found, create the resource */

  insert = g_string_new (NULL);

  g_string_append_printf (insert,

                          "INSERT { <%s> a nco:EmailAddress ; nco:emailAddress \"%s\" . "

                          "_:res a nco:Contact ; nco:hasEmailAddress <%s> ; nco:fullname \"%s\" . }",

                          mail_uri, email,

                          mail_uri, fullname);

  insert_res =

    tracker_sparql_connection_update_blank (connection, insert->str,

                                            G_PRIORITY_DEFAULT, cancellable, error);

  g_string_free (insert, TRUE);

  if (*error != NULL)

    goto out;

  /* the result is an "aaa{ss}" variant */

  g_variant_get (insert_res, "aaa{ss}", &iter);

  g_variant_iter_next (iter, "aa{ss}", &iter);

  g_variant_iter_next (iter, "a{ss}", &iter);

  g_variant_iter_next (iter, "{ss}", &key, &val;;

  g_variant_iter_free (iter);

  g_variant_unref (insert_res);

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

    {

      retval = val;

    }

  else

    {

      g_free (val);

      goto out;

    }

  g_debug ("Created a new contact resource: %s", retval);

 out:

  g_clear_object (&cursor);

  g_free (mail_uri);

  return retval;

}

gchar *

gom_tracker_utils_ensure_equipment_resource (TrackerSparqlConnection *connection,

                                             GCancellable *cancellable,

                                             GError **error,

                                             const gchar *make,

                                             const gchar *model)

{

  GError *local_error;

  TrackerSparqlCursor *cursor = NULL;

  gboolean res;

  gchar *equip_uri = NULL;

  gchar *insert = NULL;

  gchar *retval = NULL;

  gchar *select = NULL;

  g_return_val_if_fail (TRACKER_SPARQL_IS_CONNECTION (connection), NULL);

  g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), NULL);

  g_return_val_if_fail (error == NULL || *error == NULL, NULL);

  g_return_val_if_fail (make != NULL || model != NULL, NULL);

  equip_uri = tracker_sparql_escape_uri_printf ("urn:equipment:%s:%s:",

                                                make != NULL ? make : "",

                                                model != NULL ? model : "");

  select = g_strdup_printf ("SELECT <%s> WHERE { }", equip_uri);

  local_error = NULL;

  cursor = tracker_sparql_connection_query (connection, select, cancellable, &local_error);

  if (local_error != NULL)

    {

      g_propagate_error (error, local_error);

      goto out;

    }

  local_error = NULL;

  res = tracker_sparql_cursor_next (cursor, cancellable, &local_error);

  if (local_error != NULL)

    {

      g_propagate_error (error, local_error);

      goto out;

    }

  if (res)

    {

      const gchar *cursor_uri;

      cursor_uri = tracker_sparql_cursor_get_string (cursor, 0, NULL);

      if (g_strcmp0 (cursor_uri, equip_uri) == 0)

        {

          /* return the found resource */

          retval = g_strdup (cursor_uri);

          g_debug ("Found resource in the store: %s", retval);

          goto out;

        }

    }

  /* not found, create the resource */

  insert = g_strdup_printf ("INSERT { <%s> a nfo:Equipment ; nfo:manufacturer \"%s\" ; nfo:model \"%s\" }",

                            equip_uri,

                            make,

                            model);

  local_error = NULL;

  tracker_sparql_connection_update (connection, insert, G_PRIORITY_DEFAULT, cancellable, &local_error);

  if (local_error != NULL)

    {

      g_propagate_error (error, local_error);

      goto out;

    }

  retval = equip_uri;

  equip_uri = NULL;

  g_debug ("Created a new equipment resource: %s", retval);

 out:

  g_clear_object (&cursor);

  g_free (equip_uri);

  g_free (insert);

  g_free (select);

  return retval;

}

void

gom_tracker_update_datasource (TrackerSparqlConnection  *connection,

                               const gchar              *datasource_urn,

                               gboolean                  resource_exists,

                               const gchar              *identifier,

                               const gchar              *resource,

                               GCancellable             *cancellable,

                               GError                  **error)

{

  gboolean set_datasource;

  /* only set the datasource again if it has changed; this avoids touching the

   * DB completely if the entry didn't change at all, since we later also check

   * the mtime. */

  set_datasource = TRUE;

  if (resource_exists)

    {

      gboolean res;

      gchar *old_value;

      res = gom_tracker_sparql_connection_get_string_attribute

        (connection, cancellable, error,

         resource, "nie:dataSource", &old_value);

      g_clear_error (error);

      if (res)

        {

          res = g_str_equal (old_value, datasource_urn);

          g_free (old_value);

        }

      if (res)

        set_datasource = FALSE;

    }

  if (set_datasource)

    gom_tracker_sparql_connection_set_triple

      (connection, cancellable, error,

       identifier, resource,

       "nie:dataSource", datasource_urn);

}

gboolean

gom_tracker_update_mtime (TrackerSparqlConnection  *connection,

                          gint64                    new_mtime,

                          gboolean                  resource_exists,

                          const gchar              *identifier,

                          const gchar              *resource,

                          GCancellable             *cancellable,

                          GError                  **error)

{

  GTimeVal old_mtime;

  gboolean res;

  gchar *old_value;

  gchar *date;

  if (resource_exists)

    {

      res = gom_tracker_sparql_connection_get_string_attribute

        (connection, cancellable, error,

         resource, "nie:contentLastModified", &old_value);

      g_clear_error (error);

      if (res)

        {

          res = g_time_val_from_iso8601 (old_value, &old_mtime);

          g_free (old_value);

        }

      if (res && (new_mtime == old_mtime.tv_sec))

        return FALSE;

    }

  date = gom_iso8601_from_timestamp (new_mtime);

  gom_tracker_sparql_connection_insert_or_replace_triple

    (connection, cancellable, error,

     identifier, resource,

     "nie:contentLastModified", date);

  g_free (date);

  return TRUE;

}