/*

 * Nautilus

 *

 * Copyright (C) 2011 Red Hat, Inc.

 *

 * Nautilus 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.

 *

 * Nautilus 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; see the file COPYING.  If not,

 * see <http://www.gnu.org/licenses/>.

 *

 * Authors: Cosimo Cecchi <cosimoc@redhat.com>

 */

#include <config.h>

#include "nautilus-keyfile-metadata.h"

#include "nautilus-directory-notify.h"

#include "nautilus-file-private.h"

#include "nautilus-file-utilities.h"

#include <glib/gstdio.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

typedef struct

{

    GKeyFile *keyfile;

    guint save_in_idle_id;

} KeyfileMetadataData;

static GHashTable *data_hash = NULL;

static KeyfileMetadataData *

keyfile_metadata_data_new (const char *keyfile_filename)

{

    KeyfileMetadataData *data;

    GKeyFile *retval;

    GError *error = NULL;

    retval = g_key_file_new ();

    g_key_file_load_from_file (retval,

                               keyfile_filename,

                               G_KEY_FILE_NONE,

                               &error);

    if (error != NULL)

    {

        if (!g_error_matches (error,

                              G_FILE_ERROR,

                              G_FILE_ERROR_NOENT))

        {

            g_print ("Unable to open the desktop metadata keyfile: %s\n",

                     error->message);

        }

        g_error_free (error);

    }

    data = g_slice_new0 (KeyfileMetadataData);

    data->keyfile = retval;

    return data;

}

static void

keyfile_metadata_data_free (KeyfileMetadataData *data)

{

    g_key_file_unref (data->keyfile);

    if (data->save_in_idle_id != 0)

    {

        g_source_remove (data->save_in_idle_id);

    }

    g_slice_free (KeyfileMetadataData, data);

}

static GKeyFile *

get_keyfile (const char *keyfile_filename)

{

    KeyfileMetadataData *data;

    if (data_hash == NULL)

    {

        data_hash = g_hash_table_new_full (g_str_hash,

                                           g_str_equal,

                                           g_free,

                                           (GDestroyNotify) keyfile_metadata_data_free);

    }

    data = g_hash_table_lookup (data_hash, keyfile_filename);

    if (data == NULL)

    {

        data = keyfile_metadata_data_new (keyfile_filename);

        g_hash_table_insert (data_hash,

                             g_strdup (keyfile_filename),

                             data);

    }

    return data->keyfile;

}

static gboolean

save_in_idle_cb (const gchar *keyfile_filename)

{

    KeyfileMetadataData *data;

    gchar *contents;

    gsize length;

    GError *error = NULL;

    data = g_hash_table_lookup (data_hash, keyfile_filename);

    data->save_in_idle_id = 0;

    contents = g_key_file_to_data (data->keyfile, &length, NULL);

    if (contents != NULL)

    {

        g_file_set_contents (keyfile_filename,

                             contents, length,

                             &error);

        g_free (contents);

    }

    if (error != NULL)

    {

        g_warning ("Couldn't save the desktop metadata keyfile to disk: %s",

                   error->message);

        g_error_free (error);

    }

    return FALSE;

}

static void

save_in_idle (const char *keyfile_filename)

{

    KeyfileMetadataData *data;

    g_return_if_fail (data_hash != NULL);

    data = g_hash_table_lookup (data_hash, keyfile_filename);

    g_return_if_fail (data != NULL);

    if (data->save_in_idle_id != 0)

    {

        return;

    }

    data->save_in_idle_id = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,

                                             (GSourceFunc) save_in_idle_cb,

                                             g_strdup (keyfile_filename),

                                             g_free);

}

void

nautilus_keyfile_metadata_set_string (NautilusFile *file,

                                      const char   *keyfile_filename,

                                      const gchar  *name,

                                      const gchar  *key,

                                      const gchar  *string)

{

    GKeyFile *keyfile;

    keyfile = get_keyfile (keyfile_filename);

    g_key_file_set_string (keyfile,

                           name,

                           key,

                           string);

    save_in_idle (keyfile_filename);

    if (nautilus_keyfile_metadata_update_from_keyfile (file, keyfile_filename, name))

    {

        nautilus_file_changed (file);

    }

}

#define STRV_TERMINATOR "@x-nautilus-desktop-metadata-term@"

void

nautilus_keyfile_metadata_set_stringv (NautilusFile       *file,

                                       const char         *keyfile_filename,

                                       const char         *name,

                                       const char         *key,

                                       const char * const *stringv)

{

    GKeyFile *keyfile;

    guint length;

    gchar **actual_stringv = NULL;

    gboolean free_strv = FALSE;

    keyfile = get_keyfile (keyfile_filename);

    /* if we would be setting a single-length strv, append a fake

     * terminator to the array, to be able to differentiate it later from

     * the single string case

     */

    length = g_strv_length ((gchar **) stringv);

    if (length == 1)

    {

        actual_stringv = g_malloc0 (3 * sizeof (gchar *));

        actual_stringv[0] = (gchar *) stringv[0];

        actual_stringv[1] = STRV_TERMINATOR;

        actual_stringv[2] = NULL;

        length = 2;

        free_strv = TRUE;

    }

    else

    {

        actual_stringv = (gchar **) stringv;

    }

    g_key_file_set_string_list (keyfile,

                                name,

                                key,

                                (const gchar **) actual_stringv,

                                length);

    save_in_idle (keyfile_filename);

    if (nautilus_keyfile_metadata_update_from_keyfile (file, keyfile_filename, name))

    {

        nautilus_file_changed (file);

    }

    if (free_strv)

    {

        g_free (actual_stringv);

    }

}

gboolean

nautilus_keyfile_metadata_update_from_keyfile (NautilusFile *file,

                                               const char   *keyfile_filename,

                                               const gchar  *name)

{

    gchar **keys, **values;

    const gchar *actual_values[2];

    const gchar *key, *value;

    gchar *gio_key;

    gsize length, values_length;

    GKeyFile *keyfile;

    GFileInfo *info;

    gint idx;

    gboolean res;

    keyfile = get_keyfile (keyfile_filename);

    keys = g_key_file_get_keys (keyfile,

                                name,

                                &length,

                                NULL);

    if (keys == NULL)

    {

        return FALSE;

    }

    info = g_file_info_new ();

    for (idx = 0; idx < length; idx++)

    {

        key = keys[idx];

        values = g_key_file_get_string_list (keyfile,

                                             name,

                                             key,

                                             &values_length,

                                             NULL);

        gio_key = g_strconcat ("metadata::", key, NULL);

        if (values_length < 1)

        {

            continue;

        }

        else if (values_length == 1)

        {

            g_file_info_set_attribute_string (info,

                                              gio_key,

                                              values[0]);

        }

        else if (values_length == 2)

        {

            /* deal with the fact that single-length strv are stored

             * with an additional terminator in the keyfile string, to differentiate

             * them from the regular string case.

             */

            value = values[1];

            if (g_strcmp0 (value, STRV_TERMINATOR) == 0)

            {

                /* if the 2nd value is the terminator, remove it */

                actual_values[0] = values[0];

                actual_values[1] = NULL;

                g_file_info_set_attribute_stringv (info,

                                                   gio_key,

                                                   (gchar **) actual_values);

            }

            else

            {

                /* otherwise, set it as a regular strv */

                g_file_info_set_attribute_stringv (info,

                                                   gio_key,

                                                   values);

            }

        }

        else

        {

            g_file_info_set_attribute_stringv (info,

                                               gio_key,

                                               values);

        }

        g_free (gio_key);

        g_strfreev (values);

    }

    res = nautilus_file_update_metadata_from_info (file, info);

    g_strfreev (keys);

    g_object_unref (info);

    return res;

}