/*  Glimmer - session.c
 *
 *  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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#include "declarations.h"
#include "session.h"
#include "dialogs.h"
#include "file-io.h"
#include "main.h"
#include "misc.h"
#include "settings.h"
#include "getprefs.h"

gchar *session_file = NULL;
static GList *session_directories = NULL;


guint
get_last_session (void)
{
    guint files;
    gchar buffer[256];

    if (!general_preferences.open_session)
        return (0);
    g_snprintf (buffer, sizeof (buffer), "%s/." PACKAGE "/session.last",
                getenv ("HOME"));
    files = open_session_from_file (session_file ? session_file : buffer);
    return (files);
}

void
save_session_cb (GtkWidget * widget, gpointer data)
{
    gint success;
    gchar buffer[256];

    g_snprintf (buffer, sizeof (buffer), "%s/." PACKAGE "/session.last",
                getenv ("HOME"));
    success = save_session_to_file (session_file ? session_file : buffer);
    if (!success)
        generic_dialog_with_text (_
                                  ("Session file could not be written.\nMake sure that you have write access to $HOME."));
    else
        display_message ("Session Saved.", FLASH);
}

void
open_session_cb (GtkWidget * widget, gpointer data)
{
    static GtkWidget *file_selector = NULL;
    gchar *path;

    if (!file_selector) {
        path = get_path_from_filename (session_file);
        widget =
            gnome_file_selector_new_with_path (path, GNOME_FILE_SELECTOR_SINGLE,
                                               general_preferences.show_dots,
                                               general_preferences.show_details,
                                               &session_directories);
        g_free (path);
        gnome_file_selector_set_title (GNOME_FILE_SELECTOR (widget),
                                       _("Open Session..."));
        gtk_signal_connect (GTK_OBJECT
                            (GNOME_FILE_SELECTOR (widget)->ok_button),
                            "clicked", GTK_SIGNAL_FUNC (open_session_continue),
                            (gpointer) widget);
        gtk_signal_connect_object (GTK_OBJECT
                                   (GNOME_FILE_SELECTOR (widget)->
                                    cancel_button), "clicked",
                                   GTK_SIGNAL_FUNC (gtk_widget_hide),
                                   GTK_OBJECT (widget));
        gtk_window_set_transient_for (GTK_WINDOW (widget), GTK_WINDOW (window));
        gtk_widget_show (widget);
        gtk_widget_grab_focus (GNOME_FILE_SELECTOR (widget)->selection_entry);
    } else {
        gtk_entry_set_text (GTK_ENTRY
                            (GNOME_FILE_SELECTOR (file_selector)->
                             selection_entry), "");
        gnome_file_selector_set_history (GNOME_FILE_SELECTOR (file_selector),
                                         &session_directories);
        gtk_widget_show (file_selector);
    }
}

void
open_session_continue (GtkWidget * widget, GnomeFileSelector * file_list)
{
    gchar *string;
    gchar *temp;
    gint files;
    gboolean autosave;

    temp = gnome_file_selector_get_filename (GNOME_FILE_SELECTOR (file_list));
    string = localize_uri_string (temp);
    g_free (temp);
    if (check_if_file_exists (string)) {
        gtk_widget_hide (GTK_WIDGET (file_list));
        if (general_preferences.close_all)
            close_all_files_cb (NULL, NULL);

        autosave = general_preferences.auto_save;
        general_preferences.auto_save = FALSE;

        files = open_session_from_file (string);
        if (!files) {
            generic_dialog_with_text (_("File contained no session data."));
            gtk_widget_show (GTK_WIDGET (file_list));
        } else {
            g_free (session_file);
            session_file = g_strdup (string);
            set_window_title ();
        }
        general_preferences.auto_save = autosave;
    } else {
        gtk_widget_hide (GTK_WIDGET (file_list));
        read_error (string);
        gtk_widget_show (GTK_WIDGET (file_list));
    }
    g_free (string);
}

void
save_session_as_cb (GtkWidget * widget, gpointer data)
{
    static GtkWidget *file_selector = NULL;
    gchar *string;

    if (!file_selector) {
        string =
            session_file ? g_strconcat (g_get_home_dir (), "/." PACKAGE,
                                        NULL) :
            get_path_from_filename (session_file);
        file_selector =
            gnome_file_selector_new_with_path (string,
                                               GNOME_FILE_SELECTOR_SINGLE,
                                               general_preferences.show_dots,
                                               general_preferences.show_details,
                                               &session_directories);
        g_free (string);
        gnome_file_selector_set_title (GNOME_FILE_SELECTOR (file_selector),
                                       _("Save session file..."));
        gtk_signal_connect (GTK_OBJECT
                            (GNOME_FILE_SELECTOR (file_selector)->ok_button),
                            "clicked",
                            GTK_SIGNAL_FUNC (save_session_as_continue),
                            file_selector);
        gtk_signal_connect_object (GTK_OBJECT
                                   (GNOME_FILE_SELECTOR (file_selector)->
                                    cancel_button), "clicked",
                                   GTK_SIGNAL_FUNC (gtk_widget_hide),
                                   GTK_OBJECT (file_selector));
        gtk_window_set_transient_for (GTK_WINDOW (file_selector),
                                      GTK_WINDOW (window));
        gtk_widget_show (file_selector);
    } else {
        if (gnome_file_selector_show_dots (GNOME_FILE_SELECTOR (file_selector))
            != general_preferences.show_dots)
            gnome_file_selector_set_show_dots (GNOME_FILE_SELECTOR
                                               (file_selector),
                                               general_preferences.show_dots);
        gnome_file_selector_set_history (GNOME_FILE_SELECTOR (file_selector),
                                         &session_directories);
        gtk_widget_show (file_selector);
    }
    if (session_file) {
        string = get_file_from_filename (session_file);
        gtk_entry_set_text (GTK_ENTRY
                            (GNOME_FILE_SELECTOR (file_selector)->
                             selection_entry), string);
        g_free (string);
    } else {
        gtk_entry_set_text (GTK_ENTRY
                            (GNOME_FILE_SELECTOR (file_selector)->
                             selection_entry), "");
    }
    gtk_widget_grab_focus (GNOME_FILE_SELECTOR (file_selector)->
                           selection_entry);
}

void
save_session_as_continue (GtkWidget * widget, GnomeFileSelector * file_list)
{
    gchar *string;
    gchar *temp;
    gint result;

    temp = gnome_file_selector_get_filename (GNOME_FILE_SELECTOR (file_list));
    string = localize_uri_string (temp);
    g_free (temp);
    if (check_if_file_exists (string)) {
        gtk_widget_hide (GTK_WIDGET (file_list));
        result =
            file_exists_error (string,
                               GTK_SIGNAL_FUNC
                               (save_session_as_error_continue));
        if (result)
            gtk_widget_show (GTK_WIDGET (file_list));
    } else {
        if (save_session_to_file (string)) {
            gtk_widget_hide (GTK_WIDGET (file_list));
            g_free (session_file);
            session_file = g_new (char, strlen (string) + 1);

            strcpy (session_file, string);
            set_window_title ();
        } else {
            save_error (string);
            gtk_widget_show (GTK_WIDGET (file_list));
        }
    }
    g_free (string);
}

void
save_session_as_error_continue (GtkWidget * widget, gchar * filename)
{
    gboolean success;

    success = save_session_to_file (filename);
    if (!success)
        generic_dialog_with_text (_("Session save failed."));
    else {
        g_free (session_file);
        session_file = g_new (char, strlen (filename) + 1);

        strcpy (session_file, filename);
        set_window_title ();
    }
}

gboolean
save_session_to_file (gchar * filename)
{
    FILE *file;
    GList *temp = NULL;
    GdsFile *current;

    if ((file = fopen (filename, "w"))) {
        temp = g_list_first (files_list);
        while (temp) {
            current = (GdsFile *) temp->data;
            fprintf (file, "<file>\n");
            fprintf (file, "filename=%s\n", current->filename);
            fprintf (file, "over_ride=%d\n", current->props.over_ride);
            fprintf (file, "bracketmatch=%d\n", current->props.bracketmatch);
            fprintf (file, "highlight=%d\n", current->props.syntax);
            fprintf (file, "use_spaces=%d\n", current->props.use_spaces);
            fprintf (file, "tab_stop=%d\n", current->props.spaces);
            fprintf (file, "line=%d\n",
                     gtk_extext_get_line (GTK_EXTEXT (current->text)));
            if (current->props.dir)
                fprintf (file, "directory=%s\n", current->props.dir);
            if (current->props.compiler)
                fprintf (file, "compiler=%s\n", current->props.compiler);
            if (current->props.debugger)
                fprintf (file, "debugger=%s\n", current->props.debugger);
            if (current->props.execution)
                fprintf (file, "execution=%s\n", current->props.execution);
            fprintf (file, "</file>\n");
            temp = temp->next;
        }
        fclose (file);
    } else {
        return (FALSE);
    }
    return (TRUE);
}


guint
open_session_from_file (gchar * filename)
{
    FILE *file;
    gint success = 0;
    gchar *text;
    gchar buffer[1024];
    gchar file_string[] = "filename=";
    gchar directory_string[] = "directory=";
    gchar compiler_string[] = "compiler=";
    gchar debugger_string[] = "debugger=";
    gchar execution_string[] = "execution=";
    gchar *newfile = NULL;
    GdsFileProperties props;
    gint line;

    props.bracketmatch = general_preferences.bracketmatch;
    props.dir = NULL;
    props.compiler = NULL;
    props.debugger = NULL;
    props.execution = NULL;

    if (!(file = fopen (filename, "r")))
        return (0);

    if (app->window != NULL)
        gdk_window_set_cursor (app->window, gdk_cursor_new (GDK_WATCH));

    while (fgets (buffer, sizeof (buffer), file)) {
        while (gtk_events_pending ())
            gtk_main_iteration ();
        if (strstr (buffer, "<file>")) {
            props.bracketmatch = general_preferences.bracketmatch;
            while (fgets (buffer, sizeof (buffer), file) != NULL) {
                if (strstr (buffer, "</file>"))
                    break;
                if ((text = strrchr (buffer, '\n')))
                    *text = '\0';
                if ((text = strstr (buffer, file_string))) {
                    g_free (newfile);
                    newfile = g_strdup (text + strlen (file_string));
                    continue;
                } else if (sscanf (buffer, "over_ride=%d", &props.over_ride)) {
                    continue;
                } else
                    if (sscanf (buffer, "bracketmatch=%d", &props.bracketmatch))
                {
                    continue;
                } else if (sscanf (buffer, "highlight=%d", &props.syntax)) {
                    continue;
                } else
                    if (sscanf (buffer, "auto_indent=%d", &props.auto_indent)) {
                    continue;
                } else if (sscanf (buffer, "use_spaces=%d", &props.use_spaces)) {
                    continue;
                } else if (sscanf (buffer, "tab_stop=%d", &props.spaces)) {
                    continue;
                } else if (sscanf (buffer, "line=%d", &line)) {
                    continue;
                } else if ((text = strstr (buffer, directory_string))) {
                    g_free (props.dir);
                    props.dir = g_strdup (text + strlen (directory_string));
                    continue;
                } else if ((text = strstr (buffer, compiler_string))) {
                    g_free (props.compiler);
                    props.compiler = g_strdup (text + strlen (compiler_string));
                    continue;
                } else if ((text = strstr (buffer, debugger_string))) {
                    g_free (props.debugger);
                    props.debugger = g_strdup (text + strlen (debugger_string));
                    continue;
                } else if ((text = strstr (buffer, execution_string))) {
                    g_free (props.execution);
                    props.execution =
                        g_strdup (text + strlen (execution_string));
                    continue;
                }
            }
            if (newfile && check_if_file_exists (newfile)) {
                open_file_real (newfile);
                success++;
                while (gtk_events_pending ())
                    gtk_main_iteration ();
                if (GTK_EXTEXT (cur_file->text)->scroll_line_count < 1)
                    GTK_EXTEXT (cur_file->text)->scroll_line_count = 10;
                gtk_extext_set_line (GTK_EXTEXT (cur_file->text), line);
                cur_file->props.over_ride = props.over_ride;
                cur_file->props.bracketmatch = props.bracketmatch;
                cur_file->props.syntax = props.syntax;
                cur_file->props.auto_indent = props.auto_indent;
                cur_file->props.use_spaces = props.use_spaces;
                cur_file->props.spaces = props.spaces;
                if (props.over_ride) {
                    gtk_extext_set_highlight (GTK_EXTEXT (cur_file->text),
                                              props.syntax);
                    GTK_EXTEXT (cur_file->text)->default_tab_width =
                        props.spaces;
                }
                if (props.dir) {
                    g_free (cur_file->props.dir);
                    cur_file->props.dir = g_strdup (props.dir);
                }
                if (props.compiler) {
                    g_free (cur_file->props.compiler);
                    cur_file->props.compiler = g_strdup (props.compiler);
                }
                if (props.debugger) {
                    g_free (cur_file->props.debugger);
                    cur_file->props.debugger = g_strdup (props.debugger);
                }
                if (props.execution) {
                    g_free (cur_file->props.execution);
                    cur_file->props.execution = g_strdup (props.execution);
                }
            }
        }
    }
    fclose (file);
    g_free (newfile);
    g_free (props.dir);
    g_free (props.compiler);
    g_free (props.debugger);
    g_free (props.execution);
    if (app->window)
        gdk_window_set_cursor (app->window, gdk_cursor_new (GDK_LEFT_PTR));
    return (success);
}

void
save_session_directory_history (void)
{
    save_directory_history (session_directories, "session");
}

void
load_session_directory_history (void)
{
    get_directory_history (&session_directories, "session");
}