/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */

/* peony-bookmark.c - implementation of individual bookmarks.

   Copyright (C) 1999, 2000 Eazel, Inc.

   The Ukui Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.

   The Ukui 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with the Ukui Library; see the file COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
   Boston, MA 02110-1301, USA.

   Authors: John Sullivan <sullivan@eazel.com>
*/

#include <config.h>
#include "peony-bookmark.h"

#include "peony-file.h"
#include <eel/eel-gdk-pixbuf-extensions.h>
#include <eel/eel-gtk-extensions.h>
#include <eel/eel-gtk-macros.h>
#include <eel/eel-vfs-extensions.h>
#include <gtk/gtk.h>
#include <gio/gio.h>
#include <libpeony-private/peony-file.h>
#include <libpeony-private/peony-icon-names.h>

enum
{
    APPEARANCE_CHANGED,
    CONTENTS_CHANGED,
    LAST_SIGNAL
};

#define ELLIPSISED_MENU_ITEM_MIN_CHARS  32

static guint signals[LAST_SIGNAL] = { 0 };

struct PeonyBookmarkDetails
{
    char *name;
    gboolean has_custom_name;
    GFile *location;
    GIcon *icon;
    PeonyFile *file;

    char *scroll_file;
};

static void	  peony_bookmark_connect_file	  (PeonyBookmark	 *file);
static void	  peony_bookmark_disconnect_file	  (PeonyBookmark	 *file);

G_DEFINE_TYPE (PeonyBookmark, peony_bookmark, G_TYPE_OBJECT);

/* GObject methods.  */

static void
peony_bookmark_finalize (GObject *object)
{
    PeonyBookmark *bookmark;

    g_assert (PEONY_IS_BOOKMARK (object));

    bookmark = PEONY_BOOKMARK (object);

    peony_bookmark_disconnect_file (bookmark);

    g_free (bookmark->details->name);
    g_object_unref (bookmark->details->location);
    if (bookmark->details->icon)
    {
        g_object_unref (bookmark->details->icon);
    }
    g_free (bookmark->details->scroll_file);
    g_free (bookmark->details);

    G_OBJECT_CLASS (peony_bookmark_parent_class)->finalize (object);
}

/* Initialization.  */

static void
peony_bookmark_class_init (PeonyBookmarkClass *class)
{
    G_OBJECT_CLASS (class)->finalize = peony_bookmark_finalize;

    signals[APPEARANCE_CHANGED] =
        g_signal_new ("appearance_changed",
                      G_TYPE_FROM_CLASS (class),
                      G_SIGNAL_RUN_LAST,
                      G_STRUCT_OFFSET (PeonyBookmarkClass, appearance_changed),
                      NULL, NULL,
                      g_cclosure_marshal_VOID__VOID,
                      G_TYPE_NONE, 0);

    signals[CONTENTS_CHANGED] =
        g_signal_new ("contents_changed",
                      G_TYPE_FROM_CLASS (class),
                      G_SIGNAL_RUN_LAST,
                      G_STRUCT_OFFSET (PeonyBookmarkClass, contents_changed),
                      NULL, NULL,
                      g_cclosure_marshal_VOID__VOID,
                      G_TYPE_NONE, 0);

}

static void
peony_bookmark_init (PeonyBookmark *bookmark)
{
    bookmark->details = g_new0 (PeonyBookmarkDetails, 1);
}

/**
 * peony_bookmark_compare_with:
 *
 * Check whether two bookmarks are considered identical.
 * @a: first PeonyBookmark*.
 * @b: second PeonyBookmark*.
 *
 * Return value: 0 if @a and @b have same name and uri, 1 otherwise
 * (GCompareFunc style)
 **/
int
peony_bookmark_compare_with (gconstpointer a, gconstpointer b)
{
    PeonyBookmark *bookmark_a;
    PeonyBookmark *bookmark_b;

    g_return_val_if_fail (PEONY_IS_BOOKMARK (a), 1);
    g_return_val_if_fail (PEONY_IS_BOOKMARK (b), 1);

    bookmark_a = PEONY_BOOKMARK (a);
    bookmark_b = PEONY_BOOKMARK (b);

    if (g_strcmp0 (bookmark_a->details->name,
                    bookmark_b->details->name) != 0)
    {
        return 1;
    }

    if (!g_file_equal (bookmark_a->details->location,
                       bookmark_b->details->location))
    {
        return 1;
    }

    return 0;
}

/**
 * peony_bookmark_compare_uris:
 *
 * Check whether the uris of two bookmarks are for the same location.
 * @a: first PeonyBookmark*.
 * @b: second PeonyBookmark*.
 *
 * Return value: 0 if @a and @b have matching uri, 1 otherwise
 * (GCompareFunc style)
 **/
int
peony_bookmark_compare_uris (gconstpointer a, gconstpointer b)
{
    PeonyBookmark *bookmark_a;
    PeonyBookmark *bookmark_b;

    g_return_val_if_fail (PEONY_IS_BOOKMARK (a), 1);
    g_return_val_if_fail (PEONY_IS_BOOKMARK (b), 1);

    bookmark_a = PEONY_BOOKMARK (a);
    bookmark_b = PEONY_BOOKMARK (b);

    return !g_file_equal (bookmark_a->details->location,
                          bookmark_b->details->location);
}

PeonyBookmark *
peony_bookmark_copy (PeonyBookmark *bookmark)
{
    g_return_val_if_fail (PEONY_IS_BOOKMARK (bookmark), NULL);

    return peony_bookmark_new (
               bookmark->details->location,
               bookmark->details->name,
               bookmark->details->has_custom_name,
               bookmark->details->icon);
}

char *
peony_bookmark_get_name (PeonyBookmark *bookmark)
{
    g_return_val_if_fail(PEONY_IS_BOOKMARK (bookmark), NULL);

    return g_strdup (bookmark->details->name);
}


gboolean
peony_bookmark_get_has_custom_name (PeonyBookmark *bookmark)
{
    g_return_val_if_fail(PEONY_IS_BOOKMARK (bookmark), FALSE);

    return (bookmark->details->has_custom_name);
}


GdkPixbuf *
peony_bookmark_get_pixbuf (PeonyBookmark *bookmark,
                          GtkIconSize stock_size)
{
    GdkPixbuf *result;
    GIcon *icon;
    PeonyIconInfo *info;
    int pixel_size;


    g_return_val_if_fail (PEONY_IS_BOOKMARK (bookmark), NULL);

    icon = peony_bookmark_get_icon (bookmark);
    if (icon == NULL)
    {
        return NULL;
    }

    pixel_size = peony_get_icon_size_for_stock_size (stock_size);
    info = peony_icon_info_lookup (icon, pixel_size);
    result = peony_icon_info_get_pixbuf_at_size (info, pixel_size);
    g_object_unref (info);

    g_object_unref (icon);

    return result;
}

GIcon *
peony_bookmark_get_icon (PeonyBookmark *bookmark)
{
    g_return_val_if_fail (PEONY_IS_BOOKMARK (bookmark), NULL);

    /* Try to connect a file in case file exists now but didn't earlier. */
    peony_bookmark_connect_file (bookmark);

    if (bookmark->details->icon)
    {
        return g_object_ref (bookmark->details->icon);
    }
    return NULL;
}

GFile *
peony_bookmark_get_location (PeonyBookmark *bookmark)
{
    g_return_val_if_fail(PEONY_IS_BOOKMARK (bookmark), NULL);

    /* Try to connect a file in case file exists now but didn't earlier.
     * This allows a bookmark to update its image properly in the case
     * where a new file appears with the same URI as a previously-deleted
     * file. Calling connect_file here means that attempts to activate the
     * bookmark will update its image if possible.
     */
    peony_bookmark_connect_file (bookmark);

    return g_object_ref (bookmark->details->location);
}

char *
peony_bookmark_get_uri (PeonyBookmark *bookmark)
{
    GFile *file;
    char *uri;

    file = peony_bookmark_get_location (bookmark);
    uri = g_file_get_uri (file);
    g_object_unref (file);
    return uri;
}


/**
 * peony_bookmark_set_name:
 *
 * Change the user-displayed name of a bookmark.
 * @new_name: The new user-displayed name for this bookmark, mustn't be NULL.
 *
 * Returns: TRUE if the name changed else FALSE.
 **/
gboolean
peony_bookmark_set_name (PeonyBookmark *bookmark, const char *new_name)
{
    g_return_val_if_fail (new_name != NULL, FALSE);
    g_return_val_if_fail (PEONY_IS_BOOKMARK (bookmark), FALSE);

    if (g_strcmp0 (new_name, bookmark->details->name) == 0)
    {
        return FALSE;
    }
    else if (!bookmark->details->has_custom_name)
    {
        bookmark->details->has_custom_name = TRUE;
    }

    g_free (bookmark->details->name);
    bookmark->details->name = g_strdup (new_name);

    g_signal_emit (bookmark, signals[APPEARANCE_CHANGED], 0);

    if (bookmark->details->has_custom_name)
    {
        g_signal_emit (bookmark, signals[CONTENTS_CHANGED], 0);
    }

    return TRUE;
}

static gboolean
peony_bookmark_icon_is_different (PeonyBookmark *bookmark,
                                 GIcon *new_icon)
{
    g_assert (PEONY_IS_BOOKMARK (bookmark));
    g_assert (new_icon != NULL);

    if (bookmark->details->icon == NULL)
    {
        return TRUE;
    }

    return !g_icon_equal (bookmark->details->icon, new_icon) != 0;
}

/**
 * Update icon if there's a better one available.
 * Return TRUE if the icon changed.
 */
static gboolean
peony_bookmark_update_icon (PeonyBookmark *bookmark)
{
    GIcon *new_icon;

    g_assert (PEONY_IS_BOOKMARK (bookmark));

    if (bookmark->details->file == NULL)
    {
        return FALSE;
    }

    if (!peony_file_is_local (bookmark->details->file))
    {
        /* never update icons for remote bookmarks */
        return FALSE;
    }

    if (!peony_file_is_not_yet_confirmed (bookmark->details->file) &&
            peony_file_check_if_ready (bookmark->details->file,
                                      PEONY_FILE_ATTRIBUTES_FOR_ICON))
    {
        new_icon = peony_file_get_gicon (bookmark->details->file, 0);
        if (peony_bookmark_icon_is_different (bookmark, new_icon))
        {
            if (bookmark->details->icon)
            {
                g_object_unref (bookmark->details->icon);
            }
            bookmark->details->icon = new_icon;
            return TRUE;
        }
        g_object_unref (new_icon);
    }

    return FALSE;
}

static void
bookmark_file_changed_callback (PeonyFile *file, PeonyBookmark *bookmark)
{
    GFile *location;
    gboolean should_emit_appearance_changed_signal;
    gboolean should_emit_contents_changed_signal;
    char *display_name;

    g_assert (PEONY_IS_FILE (file));
    g_assert (PEONY_IS_BOOKMARK (bookmark));
    g_assert (file == bookmark->details->file);

    should_emit_appearance_changed_signal = FALSE;
    should_emit_contents_changed_signal = FALSE;
    location = peony_file_get_location (file);

    if (!g_file_equal (bookmark->details->location, location) &&
            !peony_file_is_in_trash (file))
    {
        g_object_unref (bookmark->details->location);
        bookmark->details->location = location;
        should_emit_contents_changed_signal = TRUE;
    }
    else
    {
        g_object_unref (location);
    }

    if (peony_file_is_gone (file) ||
            peony_file_is_in_trash (file))
    {
        /* The file we were monitoring has been trashed, deleted,
         * or moved in a way that we didn't notice. We should make
         * a spanking new PeonyFile object for this
         * location so if a new file appears in this place
         * we will notice. However, we can't immediately do so
         * because creating a new PeonyFile directly as a result
         * of noticing a file goes away may trigger i/o on that file
         * again, noticeing it is gone, leading to a loop.
         * So, the new PeonyFile is created when the bookmark
         * is used again. However, this is not really a problem, as
         * we don't want to change the icon or anything about the
         * bookmark just because its not there anymore.
         */
        peony_bookmark_disconnect_file (bookmark);
    }
    else if (peony_bookmark_update_icon (bookmark))
    {
        /* File hasn't gone away, but it has changed
         * in a way that affected its icon.
         */
        should_emit_appearance_changed_signal = TRUE;
    }

    if (!bookmark->details->has_custom_name)
    {
        display_name = peony_file_get_display_name (file);

        if (g_strcmp0 (bookmark->details->name, display_name) != 0)
        {
            g_free (bookmark->details->name);
            bookmark->details->name = display_name;
            should_emit_appearance_changed_signal = TRUE;
        }
        else
        {
            g_free (display_name);
        }
    }

    if (should_emit_appearance_changed_signal)
    {
        g_signal_emit (bookmark, signals[APPEARANCE_CHANGED], 0);
    }

    if (should_emit_contents_changed_signal)
    {
        g_signal_emit (bookmark, signals[CONTENTS_CHANGED], 0);
    }
}

/**
 * peony_bookmark_set_icon_to_default:
 *
 * Reset the icon to either the missing bookmark icon or the generic
 * bookmark icon, depending on whether the file still exists.
 */
static void
peony_bookmark_set_icon_to_default (PeonyBookmark *bookmark)
{
    GIcon *icon, *emblemed_icon, *folder;
    GEmblem *emblem;

    if (bookmark->details->icon)
    {
        g_object_unref (bookmark->details->icon);
    }

    folder = g_themed_icon_new (PEONY_ICON_FOLDER);

    if (peony_bookmark_uri_known_not_to_exist (bookmark))
    {
        icon = g_themed_icon_new ("dialog-warning");
        emblem = g_emblem_new (icon);

        emblemed_icon = g_emblemed_icon_new (folder, emblem);

        g_object_unref (emblem);
        g_object_unref (icon);
        g_object_unref (folder);

        folder = emblemed_icon;
    }

    bookmark->details->icon = folder;
}

static void
peony_bookmark_disconnect_file (PeonyBookmark *bookmark)
{
    g_assert (PEONY_IS_BOOKMARK (bookmark));

    if (bookmark->details->file != NULL)
    {
        g_signal_handlers_disconnect_by_func (bookmark->details->file,
                                              G_CALLBACK (bookmark_file_changed_callback),
                                              bookmark);
        peony_file_unref (bookmark->details->file);
        bookmark->details->file = NULL;
    }

    if (bookmark->details->icon != NULL)
    {
        g_object_unref (bookmark->details->icon);
        bookmark->details->icon = NULL;
    }
}

static void
peony_bookmark_connect_file (PeonyBookmark *bookmark)
{
    char *display_name;

    g_assert (PEONY_IS_BOOKMARK (bookmark));

    if (bookmark->details->file != NULL)
    {
        return;
    }

    if (!peony_bookmark_uri_known_not_to_exist (bookmark))
    {
        bookmark->details->file = peony_file_get (bookmark->details->location);
        g_assert (!peony_file_is_gone (bookmark->details->file));

        g_signal_connect_object (bookmark->details->file, "changed",
                                 G_CALLBACK (bookmark_file_changed_callback), bookmark, 0);
    }

    /* Set icon based on available information; don't force network i/o
     * to get any currently unknown information.
     */
    if (!peony_bookmark_update_icon (bookmark))
    {
        if (bookmark->details->icon == NULL || bookmark->details->file == NULL)
        {
            peony_bookmark_set_icon_to_default (bookmark);
        }
    }

    if (!bookmark->details->has_custom_name &&
            bookmark->details->file &&
            peony_file_check_if_ready (bookmark->details->file, PEONY_FILE_ATTRIBUTE_INFO))
    {
        display_name = peony_file_get_display_name (bookmark->details->file);
        if (g_strcmp0 (bookmark->details->name, display_name) != 0)
        {
            g_free (bookmark->details->name);
            bookmark->details->name = display_name;
        }
        else
        {
            g_free (display_name);
        }
    }
}

PeonyBookmark *
peony_bookmark_new (GFile *location, const char *name, gboolean has_custom_name,
                   GIcon *icon)
{
    PeonyBookmark *new_bookmark;

    new_bookmark = PEONY_BOOKMARK (g_object_new (PEONY_TYPE_BOOKMARK, NULL));
    g_object_ref_sink (new_bookmark);

    new_bookmark->details->name = g_strdup (name);
    new_bookmark->details->location = g_object_ref (location);
    new_bookmark->details->has_custom_name = has_custom_name;
    if (icon)
    {
        new_bookmark->details->icon = g_object_ref (icon);
    }

    peony_bookmark_connect_file (new_bookmark);

    return new_bookmark;
}

static GtkWidget *
create_image_widget_for_bookmark (PeonyBookmark *bookmark)
{
    GdkPixbuf *pixbuf;
    GtkWidget *widget;

    pixbuf = peony_bookmark_get_pixbuf (bookmark, GTK_ICON_SIZE_MENU);
    if (pixbuf == NULL)
    {
        return NULL;
    }

    widget = gtk_image_new_from_pixbuf (pixbuf);

    g_object_unref (pixbuf);
    return widget;
}

/**
 * peony_bookmark_menu_item_new:
 *
 * Return a menu item representing a bookmark.
 * @bookmark: The bookmark the menu item represents.
 * Return value: A newly-created bookmark, not yet shown.
 **/
GtkWidget *
peony_bookmark_menu_item_new (PeonyBookmark *bookmark)
{
    GtkWidget *menu_item;
    GtkWidget *image_widget;
    GtkLabel *label;

    menu_item = gtk_image_menu_item_new_with_label (bookmark->details->name);
    label = GTK_LABEL (gtk_bin_get_child (GTK_BIN (menu_item)));
    gtk_label_set_use_underline (label, FALSE);
    gtk_label_set_ellipsize (label, PANGO_ELLIPSIZE_END);
    gtk_label_set_max_width_chars (label, ELLIPSISED_MENU_ITEM_MIN_CHARS);

    image_widget = create_image_widget_for_bookmark (bookmark);
    if (image_widget != NULL)
    {
        gtk_widget_show (image_widget);
        gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item),
                                       image_widget);
    }

    return menu_item;
}

gboolean
peony_bookmark_uri_known_not_to_exist (PeonyBookmark *bookmark)
{
    char *path_name;
    gboolean exists;

    /* Convert to a path, returning FALSE if not local. */
    if (!g_file_is_native (bookmark->details->location))
    {
        return FALSE;
    }
    path_name = g_file_get_path (bookmark->details->location);

    /* Now check if the file exists (sync. call OK because it is local). */
    exists = g_file_test (path_name, G_FILE_TEST_EXISTS);
    g_free (path_name);

    return !exists;
}

void
peony_bookmark_set_scroll_pos (PeonyBookmark      *bookmark,
                              const char            *uri)
{
    g_free (bookmark->details->scroll_file);
    bookmark->details->scroll_file = g_strdup (uri);
}

char *
peony_bookmark_get_scroll_pos (PeonyBookmark      *bookmark)
{
    return g_strdup (bookmark->details->scroll_file);
}
