/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.

 * Use is subject to license terms.

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <dirent.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <string.h>

#include <stdlib.h>

#include <stdio.h>

#include <errno.h>

#include <gtk/gtk.h>

#include <gconf/gconf-client.h>

#include <libgnome/libgnome.h>

#include <libgnomeui/libgnomeui.h>

#include <libgnomevfs/gnome-vfs.h>

#include <libgnomevfs/gnome-vfs-mime.h>

#include <glib.h>

#include <glib/gi18n.h>

#include <glade/glade.h>

#include "fsexam.h"

#include "fsexam-header.h"

#include "encoding.h"

#include "fsexam-history.h"

#include "fsexam-ui.h"

#include "callbacks.h"

#include "fsexam-dialog.h"

#include "fsexam-dnd.h"

FSEXAM_view *view;      // global variable 

typedef struct _TreeItem TreeItem;

struct _TreeItem

{

    GdkPixbuf   *icon;  // file icon

    gchar       *label;     // filename

    gboolean    loaded;  // meaningful only for directory

    TreeItem    *children;

};

static gchar    *get_root_dir_name (const gchar *dir);

static void     set_root_dir (const gchar *dir);

static void     fsexam_treeitem_free (TreeItem *);

static gint     get_dir_elements (DIR *dirp);

static void     fsexam_treeview_set_title (const gchar *);

static gint     set_item_collation (gconstpointer a, gconstpointer b);

static void     treemodel_create_with_treeitem (

                            GtkTreeStore *, 

                            TreeItem *, 

                            GtkTreeIter, 

                            gboolean);

static gchar    *get_last_path (GtkTextBuffer *, GtkTextIter *);

static void     common_construct_ui ();

static GString  *fsexam_filename_get_path (GtkTreeModel *, GtkTreeIter);

static GdkPixbuf    *get_file_pixbuf (const gchar *);

static TreeItem     *fsexam_treeitem_create (const gchar *);

static TreeItem     *fsexam_treeitem_create_from_list (GList *);

static GtkTreeModel *fsexam_treemodel_create_with_treeitem (TreeItem *root);

static void

mainwin_destroy (GtkObject *object, gpointer user_data)

{

    force_quit = TRUE;

    fsexam_cleanup_all ();

    gtk_main_quit ();

    return;

}

static gboolean

mainwin_delete (GtkObject *object, gpointer user_data)

{

    return FALSE;   /* return TRUE will not send 'destroy' signal */

}

/*

 *  dir can be NULL, ""(for file list), and abs_path

 */

static void

set_root_dir (const gchar *path)

{

    gchar    *uri = NULL;

    gchar    *dir = (gchar *)path;

    g_free (view->rootdir);     //free old rootdir first

    if (dir == NULL) {

        view->rootdir = NULL;

        return;

    }

    if (! g_file_test (path, G_FILE_TEST_IS_DIR)) {

        dir = g_path_get_dirname (path);

        if ((*dir == '\0') || (g_utf8_validate (dir, -1, NULL))) {

            view->rootdir = g_strdup (dir);

            return;

        }

        uri = g_filename_to_uri (dir, NULL, NULL);

        view->rootdir = uri;

        g_free (dir);

    }else{

        if ((*dir == '\0') || (g_utf8_validate (dir, -1, NULL))) {

            view->rootdir = g_strdup (dir);

            return;

        }

        uri = g_filename_to_uri (dir, NULL, NULL);

        view->rootdir = uri;

    }

    return;

} 

/*

 * Get the root dirname, may need convert from uri.

 * free when don't need again.

 */

static gchar *

get_root_dir_name (const gchar *rootdir)

{

    if (NULL == rootdir)

        return NULL;

    if (*rootdir == 'f')  /* file:///... */

        return g_filename_from_uri (rootdir, NULL, NULL);

    else

        return g_strdup (rootdir);

}

static gboolean

button_press (GtkWidget      *widget,

              GdkEventButton *button,

              gpointer       data)

{

    g_return_val_if_fail (button != NULL, FALSE);

    if (button->button == 1 && button->type == GDK_2BUTTON_PRESS) {

        cb_convert ();

        return TRUE;

    }else if (button->button == 2) {

        fsexam_content_peek (button->x_root, button->y_root);

        return TRUE;

    }else if (button->button == 3) {

        GtkWidget *menu = view->popup_menu;

        GtkWidget *w = NULL;

        gboolean  sensitive;

        /* undo menu */

        w = g_object_get_data (G_OBJECT (menu), "popup_undo");

        gtk_widget_set_sensitive (w, view->undo_list ? TRUE : FALSE);

        /* conversion mode menu */

        w = g_object_get_data (G_OBJECT (menu), 

                view->setting->pref->conv_content ? "popup_content_mode"

                                                  : "popup_name_mode");

        gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), TRUE);

        /* scenario menu */

        w = g_object_get_data (G_OBJECT (view->mainwin), "menu_scenario");

        sensitive = GTK_WIDGET_IS_SENSITIVE (w);

        w = g_object_get_data (G_OBJECT (menu), "popup_scenario");

        gtk_widget_set_sensitive (w, sensitive);

        //gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), sensitive);

        /* display the popup menu */

        gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, 

                button->button, button->time);

        return TRUE;

    }

        return FALSE;

}

static gboolean

button_release (GtkWidget *widget, GdkEventButton *event, gpointer data)

{

    if (view->peekwin && event->button == 2) {

        gtk_object_destroy (GTK_OBJECT (view->peekwin));

        view->peekwin = NULL;

    }

    return FALSE;

}

static gboolean

key_press (GtkWidget *widget, GdkEventKey *event, gpointer data)

{

    switch (event->keyval) {

        case GDK_space:

            cb_convert ();

            return TRUE;

       /* case GDK_F12:

            if (event->state == GDK_SHIFT_MASK) {

                printf ("shitf+F12\n");

            }

            printf ("F12\n");

            return TRUE; */

        default:

            break;

    }

    return FALSE;

}

/*

 * Search give string at the same level with given iter

 */

static GtkTreeIter *

search_model_at_same_level (GtkTreeModel *model,

                            GtkTreeIter *iter,

                            const gchar *string)

{

    if ((NULL == string) || (NULL == iter))

        return NULL;

    do {

        gchar *name = NULL;

        gchar *internal_name = NULL;    /* escaped name */

        /* get the escaped name */

        gtk_tree_model_get (model, iter, FILENAME_COLUMN, &internal_name, -1);

        /* unescaped the escaped name */

        name = g_strcompress (internal_name);

        g_free (internal_name);

        if (strcmp (name, string) == 0) {

            g_free (name);      /* found */

            return gtk_tree_iter_copy (iter);

        }

        g_free (name);

    } while (gtk_tree_model_iter_next (model, iter));

    return NULL;

}

/*

 * Update GtkTreeView which constructed from file list.

 * The underlying store is GtkListStore

 */

static void 

update_gui_for_filelist (GtkTreeModel *model, 

                        const gchar *oldname, 

                        const gchar *newname,

                        GtkTreePath *treepath,

                        gboolean    is_myself)

{

    GtkTreeIter iter;

    gint        old_name_len;

    if ((NULL == model) || (NULL == oldname) 

            || (NULL == newname) || (NULL == view->basedir))

        return;

    if (! fsexam_is_subpath (oldname, view->basedir))

        return;

    if (! gtk_tree_model_get_iter_first (model, &iter)) {

        return;

    }

    old_name_len = strlen (oldname);

    do {

        gchar *name = NULL;

        gchar *internal_name = NULL;

        gchar *tmp = NULL;

        /* get the filename from TreeView */

        gtk_tree_model_get (model, &iter, FILENAME_COLUMN, &internal_name, -1);

        name = g_strcompress (internal_name);

        g_free (internal_name);

        /* oldname is prefix path of name ? */

        if (g_str_has_prefix (name, oldname)) {

            tmp = name + old_name_len;

            /* construct new name */

            if (*tmp == '\0') {

                gchar *display_name = NULL;

                gchar *internal_name = NULL;

                internal_name = g_strescape (newname, "");

                display_name = fsexam_filename_display_basename (newname);

                gtk_list_store_set (GTK_LIST_STORE (model), &iter,

                        FILENAME_COLUMN, internal_name,

                        DISPLAYNAME_COLUMN, display_name,

                        -1);

                g_free (display_name);

                g_free (internal_name);

            }else if (*tmp == '/') {

                gchar *new_full_name;

                gchar *display_name;

                gchar *internal_name;

                new_full_name = g_strdup_printf ("%s/%s", newname, tmp + 1);

                display_name = fsexam_filename_display_basename (new_full_name);

                internal_name = g_strescape (new_full_name, "");

                gtk_list_store_set (GTK_LIST_STORE (model), &iter,

                        FILENAME_COLUMN, internal_name,

                        DISPLAYNAME_COLUMN, display_name,

                        -1);

                g_free (new_full_name);

                g_free (display_name);

                g_free (internal_name);

            }

        }

        g_free (name);

    } while (gtk_tree_model_iter_next (model, &iter));

    return;

}

/*

 *  Update treeview_file

 *

 *  is_myself is TRUE if conversion are caused by dir/file TreeView

 *  is_myself is FALSE if conversion are caused by search result Treeview 

 */

static void

update_gui_for_dir (GtkTreeModel *model,

                    const gchar *path,

                    const gchar *oldname,

                    const gchar *newname,

                    GtkTreePath *treepath,

                    gboolean    is_myself)

{

    GtkTreeIter iter;

    GtkTreeIter *match_iter = NULL;

    gchar       *rootdir = NULL;

    gchar       *remaining = NULL;

    gchar       *display_name = NULL;

    gchar       *internal_name = NULL;

    gchar       *path_clone = NULL;

    gint        len;

    display_name = fsexam_filename_display_name (newname);

    internal_name = g_strescape (newname, "");

    if (is_myself && treepath != NULL) {

        gtk_tree_model_get_iter (model, &iter, treepath);

        gtk_tree_store_set (GTK_TREE_STORE (model),

                            &iter,

                            FILENAME_COLUMN, internal_name,

                            DISPLAYNAME_COLUMN, display_name,

                            -1);

        goto CLEAN_UP;

    }

    rootdir = get_root_dir_name (view->rootdir);

    if (! g_str_has_prefix (path, rootdir)) 

        goto CLEAN_UP;

    path_clone = g_strdup (path);

    len = strlen (rootdir);

    remaining = path_clone + len;

    if (! gtk_tree_model_get_iter_first (model, &iter)) {

        goto CLEAN_UP;     /* empty tree */

    }

    if (*remaining == '\0') {   /* top level */

        match_iter = search_model_at_same_level (model,

                                                 &iter,

                                                 oldname);

        if (match_iter == NULL)

            goto CLEAN_UP;

        gtk_tree_store_set (GTK_TREE_STORE (model), match_iter,

                            FILENAME_COLUMN, internal_name,

                            DISPLAYNAME_COLUMN, display_name,

                            -1);

        gtk_tree_iter_free (match_iter);

    }else if (*remaining == '/') {  /* iterate each directory level */

        gchar       *cur = ++remaining; //skip the '/'

        gboolean    last_element;

        gboolean    loaded;

        while (TRUE) {

            if ((*remaining != '\0') && (*remaining != '/'))  {

                ++remaining;

                continue;

            }

            last_element = (*remaining == '\0') ? TRUE : FALSE;

            *remaining = '\0';

            match_iter = search_model_at_same_level (model,

                                                     &iter,

                                                     cur);

            if (match_iter == NULL)

                break;

            if (! gtk_tree_model_iter_children (model, &iter, match_iter)) {

                gtk_tree_iter_free (match_iter);    /* no children */

                break;

            }

            /* now iter is the first child of match_iter */

            gtk_tree_model_get (model, match_iter,

                                LOADED_COLUMN, &loaded,

                                -1);

            gtk_tree_iter_free (match_iter);

            if (! loaded) {

                break;

            }else if (last_element) {

                match_iter = search_model_at_same_level (model, 

                                            &iter, oldname);

                if (match_iter != NULL) {

                    gchar *display_name;

                    display_name = fsexam_filename_display_name (newname);

                    gtk_tree_store_set (

                            GTK_TREE_STORE (model), match_iter,

                            FILENAME_COLUMN, internal_name,

                            DISPLAYNAME_COLUMN, display_name,

                            -1);

                    gtk_tree_iter_free (match_iter);

                    g_free (display_name);

                }

                break;

            }

            cur = ++remaining;

        }

    }

CLEAN_UP:

    g_free (rootdir);

    g_free (display_name);

    g_free (internal_name);

    g_free (path_clone);

    return;

}

/*

 *  Get the last path of GtkTextBuffer of report pane

 */

static gchar *

get_last_path (GtkTextBuffer *buffer, GtkTextIter *iter)

{

    gchar   *text = NULL;

    gint    line;

    line = gtk_text_iter_get_line (iter) - 1;

    while (line >= 0) {

        GtkTextIter start, end;

        gtk_text_buffer_get_iter_at_line_offset (buffer, &start, line, 0);

        gtk_text_buffer_get_iter_at_line_offset (buffer, &end, line + 1, 0);

        text = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);

        if (*text != '\n' && *text != '\t') /* info line */

            break;

        --line;

        g_free (text);

    }

    if (text == NULL)

        return NULL;

    *(text + strlen (text) - 1) = '\0';     /* remove '\n' */

    if (strncmp (text, "file:///", 8) == 0) {

        gchar *tmp = g_filename_from_uri (text, NULL, NULL);

        g_free (text);

        text = tmp;

    }

    return text;

}

// dummy TreeItem

static TreeItem demo_toplevel[] =

{

    { NULL, "", TRUE, NULL},