/* $Id: gedi.c,v 1.2 2011/11/30 05:27:31 khorben Exp $ */
static char const _copyright[] =
"Copyright (c) 2011 Pierre Pronchery <khorben@defora.org>";
/* This file is part of DeforaOS Devel GEDI */
static char const _license[] =
"This program is free software: you can redistribute it and/or modify\n"
"it under the terms of the GNU General Public License as published by\n"
"the Free Software Foundation, version 3 of the License.\n"
"\n"
"This program is distributed in the hope that it will be useful,\n"
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
"GNU General Public License for more details.\n"
"\n"
"You should have received a copy of the GNU General Public License\n"
"along with this program. If not, see <http://www.gnu.org/licenses/>.";



#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <gdk/gdkkeysyms.h>
#include <Desktop.h>
#include "callbacks.h"
#include "gedi.h"
#include "../config.h"

#ifndef PREFIX
# define PREFIX		"/usr/local"
#endif


/* GEDI */
/* private */
/* types */
struct _GEDI
{
	Config * config;
	Project ** projects;
	size_t projects_cnt;
	Project * cur;

	/* widgets */
	/* toolbar */
	GtkWidget * tb_window;

	/* preferences */
	GtkWidget * pr_window;
	GtkWidget * pr_editor_command;
	GtkWidget * pr_editor_terminal;

	/* files */
	GtkWidget * fi_window;
	GtkWidget * fi_combo;
	GtkWidget * fi_view;

	/* about */
	GtkWidget * ab_window;
};


/* constants */
#define ICON_NAME	"applications-development"

static char const * _authors[] =
{
	"Pierre Pronchery <khorben@defora.org>",
	NULL
};


/* variables */
/* menubar */
static DesktopMenu _gedi_menu_file[] =
{
	{ "_New file...", G_CALLBACK(on_file_new), GTK_STOCK_NEW,
		GDK_CONTROL_MASK, GDK_N },
	{ "_Open file...", G_CALLBACK(on_file_open), GTK_STOCK_OPEN,
		GDK_CONTROL_MASK, GDK_O },
	{ "", NULL , NULL, 0, 0 },
	{ "_Preferences...", G_CALLBACK(on_file_preferences),
		GTK_STOCK_PREFERENCES, GDK_CONTROL_MASK, GDK_P },
	{ "", NULL, NULL, 0, 0 },
	{ "_Exit", G_CALLBACK(on_file_exit), GTK_STOCK_QUIT, GDK_CONTROL_MASK,
		GDK_Q },
	{ NULL, NULL, NULL, 0, 0 }
};

static DesktopMenu _gedi_menu_projects[] = /* FIXME will certainly be dynamic */
{
	{ "_New project...", G_CALLBACK(on_project_new), GTK_STOCK_NEW, 0, 0 },
	{ "_Open project...", G_CALLBACK(on_project_open), GTK_STOCK_OPEN, 0,
		0 },
	{ "_Save project", G_CALLBACK(on_project_save), GTK_STOCK_SAVE,
		GDK_CONTROL_MASK, GDK_S },
	{ "Save project _as...", G_CALLBACK(on_project_save_as),
		GTK_STOCK_SAVE_AS, 0, 0 },
	{ "", NULL, NULL, 0, 0 },
	{ "_Properties...", G_CALLBACK(on_project_properties),
		GTK_STOCK_PROPERTIES, GDK_MOD1_MASK, GDK_Return },
	{ NULL, NULL, NULL, 0, 0 }
};

static DesktopMenu _gedi_menu_help[] =
{
	{ "_About", G_CALLBACK(on_help_about), GTK_STOCK_ABOUT, 0, 0 },
	{ NULL, NULL, NULL, 0, 0 }
};

static DesktopMenubar _gedi_menubar[] =
{
	{ "_File",	_gedi_menu_file },
	{ "_Projects",	_gedi_menu_projects },
	{ "_Help",	_gedi_menu_help },
	{ NULL,		NULL }
};

/* toolbar */
static DesktopToolbar _gedi_toolbar[] =
{
	{ "Exit", G_CALLBACK(on_file_exit), GTK_STOCK_QUIT, 0, 0, NULL },
	{ NULL, NULL, NULL, 0, 0, NULL }
};


/* prototypes */
static Project * _gedi_get_current_project(GEDI * gedi);


/* public */
/* functions */
/* gedi_new */
static void _new_config(GEDI * g);

GEDI * gedi_new(void)
{
	GEDI * gedi;
	GtkAccelGroup * group;
	GtkWidget * vbox;
	GtkWidget * hbox;
	GtkWidget * widget;

	if((gedi = malloc(sizeof(*gedi))) == NULL)
		return NULL;
	gedi->projects = NULL;
	gedi->projects_cnt = 0;
	gedi->cur = NULL;
	_new_config(gedi);
	/* main window */
	group = gtk_accel_group_new();
	gedi->tb_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_add_accel_group(GTK_WINDOW(gedi->tb_window), group);
#if GTK_CHECK_VERSION(2, 6, 0)
	gtk_window_set_icon_name(GTK_WINDOW(gedi->tb_window), ICON_NAME);
#endif
	gtk_window_set_title(GTK_WINDOW(gedi->tb_window), "Coder");
	gtk_window_set_resizable(GTK_WINDOW(gedi->tb_window), FALSE);
	g_signal_connect_swapped(G_OBJECT(gedi->tb_window), "delete-event",
			G_CALLBACK(on_closex), gedi);
	vbox = gtk_vbox_new(FALSE, 0);
	/* menubar */
	widget = desktop_menubar_create(_gedi_menubar, gedi, group);
	gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, TRUE, 0);
	/* toolbar */
	widget = desktop_toolbar_create(_gedi_toolbar, gedi, group);
	gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, TRUE, 0);
	gtk_container_add(GTK_CONTAINER(gedi->tb_window), vbox);
	/* files */
	gedi->fi_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_default_size(GTK_WINDOW(gedi->fi_window), 150, 200);
	gtk_window_set_title(GTK_WINDOW(gedi->fi_window), "Files");
	hbox = gtk_hbox_new(FALSE, 0);
	vbox = gtk_vbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 2);
	gedi->fi_combo = gtk_combo_box_new_text();
	gtk_box_pack_start(GTK_BOX(vbox), gedi->fi_combo, FALSE, TRUE, 2);
	gedi->fi_view = gtk_tree_view_new();
	gtk_box_pack_start(GTK_BOX(vbox), gedi->fi_view, TRUE, TRUE, 2);
	gtk_container_add(GTK_CONTAINER(gedi->fi_window), hbox);
	/* about */
	gedi->ab_window = NULL;
	gtk_widget_show_all(gedi->tb_window);
	gtk_widget_show_all(gedi->fi_window);
	return gedi;
}

static char * _config_file(void);
static void _new_config(GEDI * gedi)
{
	char * filename;

	if((gedi->config = config_new()) == NULL)
	{
		gedi_error(gedi, strerror(errno), 0);
		return;
	}
	config_load(gedi->config, PREFIX "/etc/" PACKAGE ".conf");
	if((filename = _config_file()) == NULL)
		return;
	config_load(gedi->config, filename);
	free(filename);
}

static char * _config_file(void)
{
	char const conffile[] = ".gedi";
	char const * homedir;
	size_t len;
	char * filename;

	if((homedir = getenv("HOME")) == NULL)
		return NULL;
	len = strlen(homedir) + 1 + strlen(conffile) + 1;
	if((filename = malloc(len)) == NULL)
		return NULL;
	snprintf(filename, len, "%s/%s", homedir, conffile);
	return filename;
}


/* gedi_delete */
void gedi_delete(GEDI * gedi)
{
	char * filename;
	size_t i;

	if((filename = _config_file()) != NULL)
	{
		config_save(gedi->config, filename);
		free(filename);
	}
	config_delete(gedi->config);
	for(i = 0; i < gedi->projects_cnt; i++)
		project_delete(gedi->projects[i]);
	free(gedi->projects);
	free(gedi);
}


/* useful */
/* gedi_about */
static gboolean _about_on_closex(gpointer data);

void gedi_about(GEDI * gedi)
{
	if(gedi->ab_window != NULL)
	{
		gtk_window_present(GTK_WINDOW(gedi->ab_window));
		return;
	}
	gedi->ab_window = desktop_about_dialog_new();
	gtk_window_set_transient_for(GTK_WINDOW(gedi->ab_window), GTK_WINDOW(
				gedi->tb_window));
	desktop_about_dialog_set_authors(gedi->ab_window, _authors);
	desktop_about_dialog_set_copyright(gedi->ab_window, _copyright);
	desktop_about_dialog_set_logo_icon_name(gedi->ab_window, ICON_NAME);
	desktop_about_dialog_set_license(gedi->ab_window, _license);
	desktop_about_dialog_set_name(gedi->ab_window, PACKAGE);
	desktop_about_dialog_set_version(gedi->ab_window, VERSION);
	g_signal_connect_swapped(G_OBJECT(gedi->ab_window), "delete-event",
			G_CALLBACK(_about_on_closex), gedi);
	gtk_widget_show(gedi->ab_window);
}

static gboolean _about_on_closex(gpointer data)
{
	GEDI * gedi = data;

	gtk_widget_hide(gedi->ab_window);
	return TRUE;
}


/* gedi_error */
int gedi_error(GEDI * gedi, char const * message, int ret)
{
	GtkWidget * dialog;

	dialog = gtk_message_dialog_new(GTK_WINDOW(gedi->tb_window),
			GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
			GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
#if GTK_CHECK_VERSION(2, 6, 0)
			"%s", "Error");
	gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
#endif
			"%s", message);
	gtk_window_set_title(GTK_WINDOW(dialog), "Error");
	gtk_dialog_run(GTK_DIALOG(dialog));
	gtk_widget_destroy(dialog);
	return ret;
}


/* gedi_file_open */
void gedi_file_open(GEDI * gedi, char const * filename)
{
	/* FIXME really use the MIME sub-system */
	char * argv[] = { NULL, NULL, NULL };
	char const * p;
	GError * error = NULL;

	if((p = config_get(gedi->config, "editor", "command")) == NULL)
		p = "editor"; /* XXX gather defaults in a common place */
	if((argv[0] = strdup(p)) == NULL)
		return; /* XXX report error */
	if(filename != NULL)
		argv[1] = strdup(filename); /* XXX check and report error */
	if(g_spawn_async(NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL,
				NULL, &error) != TRUE)
		gedi_error(gedi, error->message, 1);
	free(argv[1]);
	free(argv[0]);
}


/* gedi_project_open */
int gedi_project_open(GEDI * gedi, char const * filename)
{
	Project * project;

	if((project = project_new()) == NULL)
		return -gedi_error(gedi, error_get(), 1);
	if(project_load(project, filename) != 0
			|| gedi_project_open_project(gedi, project) != 0)
	{
		project_delete(project);
		return -gedi_error(gedi, error_get(), 1);
	}
	gedi->cur = project;
	gtk_combo_box_append_text(GTK_COMBO_BOX(gedi->fi_combo),
			project_get_package(project));
	/* FIXME doesn't always select the last project opened */
	gtk_combo_box_set_active(GTK_COMBO_BOX(gedi->fi_combo),
			gtk_combo_box_get_active(GTK_COMBO_BOX(gedi->fi_combo))
			+ 1);
	return 0;
}


/* gedi_project_open_dialog */
void gedi_project_open_dialog(GEDI * gedi)
{
	GtkWidget * dialog;
	GtkFileFilter * filter;
	gchar * filename = NULL;

	dialog = gtk_file_chooser_dialog_new("Open project...",
			GTK_WINDOW(gedi->tb_window),
			GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL,
			GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN,
			GTK_RESPONSE_ACCEPT, NULL);
	filter = gtk_file_filter_new();
	gtk_file_filter_set_name(filter, "Project files");
	gtk_file_filter_add_pattern(filter, "project.conf");
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
	gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
	filter = gtk_file_filter_new();
	gtk_file_filter_set_name(filter, "All files");
	gtk_file_filter_add_pattern(filter, "*");
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
	if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
		filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(
					dialog));
	gtk_widget_destroy(dialog);
	if(filename == NULL)
		return;
	gedi_project_open(gedi, filename);
	g_free(filename);
}


/* gedi_project_open_project */
int gedi_project_open_project(GEDI * gedi, Project * project)
{
	Project ** p;

	if(project == NULL)
		return -error_set_code(1, "%s", strerror(EINVAL));;
	if((p = realloc(gedi->projects, sizeof(*p) * (gedi->projects_cnt + 1)))
			== NULL)
		return -error_set_code(1, "%s", strerror(errno));
	gedi->projects = p;
	gedi->projects[gedi->projects_cnt++] = project;
	return 0;
}


/* gedi_project_properties */
void gedi_project_properties(GEDI * gedi)
{
	Project * project;

	if((project = _gedi_get_current_project(gedi)) == NULL)
		return;
	project_properties(project);
}


/* gedi_project_save */
int gedi_project_save(GEDI * gedi)
{
	Project * project;

	if((project = _gedi_get_current_project(gedi)) == NULL)
		return -1;
	if(project_get_pathname(project) == NULL)
		return gedi_project_save_dialog(gedi);
	return project_save(project);
}


/* gedi_project_save_as */
int gedi_project_save_as(GEDI * gedi, char const * filename)
{
	Project * project;

	if((project = _gedi_get_current_project(gedi)) == NULL)
		return -1;
	if(project_set_pathname(project, filename) != 0)
		return -1;
	return project_save(project);
}


/* gedi_project_save_dialog */
int gedi_project_save_dialog(GEDI * gedi)
{
	int ret = -1;
	Project * project;
	GtkWidget * dialog;
	gchar * filename = NULL;

	if((project = _gedi_get_current_project(gedi)) == NULL)
		return -1;
	dialog = gtk_file_chooser_dialog_new("Save project as...", NULL,
			GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL,
			GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN,
			GTK_RESPONSE_ACCEPT, NULL);
	/* FIXME add options? (recursive save) */
	if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
		filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(
					dialog));
	gtk_widget_destroy(dialog);
	if(filename != NULL)
		ret = gedi_project_save_as(gedi, filename);
	g_free(filename);
	return ret;
}


/* gedi_show_preferences */
static void _show_preferences_window(GEDI * gedi);
static void _preferences_set(GEDI * gedi);
static gboolean _on_preferences_closex(gpointer data);
static void _on_preferences_apply(gpointer data);
static void _on_preferences_cancel(gpointer data);
static void _on_preferences_ok(gpointer data);

void gedi_show_preferences(GEDI * gedi, gboolean show)
{
	if(gedi->pr_window == NULL)
		_show_preferences_window(gedi);
	if(show)
		gtk_window_present(GTK_WINDOW(gedi->pr_window));
	else
		gtk_widget_hide(gedi->pr_window);
}

static void _show_preferences_window(GEDI * gedi)
{
	GtkWidget * vbox;
	GtkWidget * nb;
	GtkWidget * nb_vbox;
	GtkWidget * hbox;
	GtkWidget * b_ok;
	GtkWidget * b_apply;
	GtkWidget * b_cancel;

	gedi->pr_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); /* XXX dialog */
	gtk_container_set_border_width(GTK_CONTAINER(gedi->pr_window), 4);
	gtk_window_set_title(GTK_WINDOW(gedi->pr_window), "Preferences");
	g_signal_connect_swapped(G_OBJECT(gedi->pr_window), "delete-event",
			G_CALLBACK(_on_preferences_closex), gedi);
	vbox = gtk_vbox_new(FALSE, 4);
	nb = gtk_notebook_new();
	/* notebook page editor */
	nb_vbox = gtk_vbox_new(FALSE, 4);
	gtk_container_set_border_width(GTK_CONTAINER(nb_vbox), 4);
	hbox = gtk_hbox_new(FALSE, 4);
	gtk_box_pack_start(GTK_BOX(hbox), gtk_label_new("Editor:"), FALSE, TRUE,
			0);
	gedi->pr_editor_command = gtk_entry_new();
	gtk_box_pack_start(GTK_BOX(hbox), gedi->pr_editor_command, TRUE, TRUE,
			0);
	gtk_box_pack_start(GTK_BOX(nb_vbox), hbox, FALSE, TRUE, 0);
	gedi->pr_editor_terminal = gtk_check_button_new_with_mnemonic(
			"Run in a _terminal");
	gtk_box_pack_start(GTK_BOX(nb_vbox), gedi->pr_editor_terminal, FALSE,
			TRUE, 0);
	gtk_notebook_append_page(GTK_NOTEBOOK(nb), nb_vbox, gtk_label_new(
				"Editor"));
	/* notebook page plug-ins */
	nb_vbox = gtk_vbox_new(FALSE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(nb_vbox), 4);
	gtk_notebook_append_page(GTK_NOTEBOOK(nb), nb_vbox, gtk_label_new(
				"Plug-ins"));
	gtk_box_pack_start(GTK_BOX(vbox), nb, TRUE, TRUE, 0);
	/* buttons */
	hbox = gtk_hbox_new(TRUE, 4);
	b_ok = gtk_button_new_from_stock(GTK_STOCK_OK);
	g_signal_connect_swapped(G_OBJECT(b_ok), "clicked", G_CALLBACK(
				_on_preferences_ok), gedi);
	gtk_box_pack_end(GTK_BOX(hbox), b_ok, FALSE, TRUE, 0);
	b_apply = gtk_button_new_from_stock(GTK_STOCK_APPLY);
	g_signal_connect_swapped(G_OBJECT(b_apply), "clicked", G_CALLBACK(
				_on_preferences_apply), gedi);
	gtk_box_pack_end(GTK_BOX(hbox), b_apply, FALSE, TRUE, 0);
	b_cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
	g_signal_connect_swapped(G_OBJECT(b_cancel), "clicked", G_CALLBACK(
				_on_preferences_cancel), gedi);
	gtk_box_pack_end(GTK_BOX(hbox), b_cancel, FALSE, TRUE, 0);
	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
	gtk_container_add(GTK_CONTAINER(gedi->pr_window), vbox);
	_preferences_set(gedi);
	gtk_widget_show_all(vbox);
}

static void _preferences_set(GEDI * gedi)
{
	char const * p;

	if((p = config_get(gedi->config, "editor", "command")) == NULL)
		p = "editor";
	gtk_entry_set_text(GTK_ENTRY(gedi->pr_editor_command), p);
	/* FIXME implement the rest */
}

static void _on_preferences_apply(gpointer data)
{
	GEDI * gedi = data;

	config_set(gedi->config, "editor", "command", gtk_entry_get_text(
				GTK_ENTRY(gedi->pr_editor_command)));
	/* FIXME implement the rest */
}


static void _on_preferences_cancel(gpointer data)
{
	GEDI * gedi = data;

	_preferences_set(gedi);
	gtk_widget_hide(gedi->pr_window);
}

static void _on_preferences_ok(gpointer data)
{
	GEDI * gedi = data;

	_on_preferences_apply(gedi);
	gtk_widget_hide(gedi->pr_window);
	/* FIXME actually save preferences */
}

static gboolean _on_preferences_closex(gpointer data)
{
	GEDI * gedi = data;

	_on_preferences_cancel(gedi);
	return TRUE;
}


/* private */
/* gedi_get_current_project */
static Project * _gedi_get_current_project(GEDI * gedi)
{
	if(gedi->cur == NULL)
	{
		/* FIXME should not happen (disable callback action) */
		gedi_error(gedi, "No project opened", 1);
		return NULL;
	}
	return gedi->cur;
}