/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */
/* Copyright (C) 1998 Redhat Software Inc. 
 * Authors: Jonathan Blandford <jrb@redhat.com>
 */

#ifdef HAVE_CONFIG_H
#   include <config.h>
#endif

#include "capplet-widget.h"
#include "gnome.h"
#include <string.h>
#include <sys/types.h>
#include <dirent.h>
#include <regex.h>
#include <ctype.h>
#include "edit-window.h"
#include "mime-data.h"
#include "mime-info.h"
#include "new-mime-window.h"
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>


/* Prototypes */
static void mime_fill_from_file (const char *filename, gboolean init_user);
static void mime_load_from_dir (const char *mime_info_dir, gboolean system_dir);
void add_to_key (char *mime_type, char *def, GHashTable *table, gboolean init_user);
static char *get_priority (char *def, int *priority);


/* Global variables */
static char *current_lang;
static GHashTable *mime_types = NULL;
static GHashTable *initial_user_mime_types = NULL;
GHashTable *user_mime_types = NULL;
static GtkWidget *clist = NULL;
extern GtkWidget *delete_button;
extern GtkWidget *capplet;
/* Initialization functions */
static void
run_error (gchar *message)
{
	GtkWidget *error_box;

	error_box = gnome_message_box_new (
		message,
		GNOME_MESSAGE_BOX_ERROR,
		GNOME_STOCK_BUTTON_OK,
		NULL);
	gnome_dialog_run_and_close (GNOME_DIALOG (error_box));
}
static char *
get_priority (char *def, int *priority)
{
	*priority = 0;
	
	if (*def == ','){
		def++;
		if (*def == '1'){
			*priority = 0;
			def++;
		} else if (*def == '2'){
			*priority = 1;
			def++;
		}
	}

	while (*def && *def == ':')
		def++;

	return def;
}
static void
free_mime_info (MimeInfo *mi)
{

}
void
add_to_key (char *mime_type, char *def, GHashTable *table, gboolean init_user)
{
	int priority = 1;
	char *s, *p, *ext;
	int used;
	MimeInfo *info;

	info = g_hash_table_lookup (table, (const void *) mime_type);
	if (info == NULL) {
		info = g_malloc (sizeof (MimeInfo));
		info->mime_type = g_strdup (mime_type);
		info->regex[0] = NULL;
		info->regex[1] = NULL;
		info->ext[0] = NULL;
		info->ext[1] = NULL;
                info->user_ext[0] = NULL;
                info->user_ext[1] = NULL;
                info->regex_readable[0] = NULL;
                info->regex_readable[1] = NULL;
                info->ext_readable[0] = NULL;
                info->ext_readable[1] = NULL;
                info->keys = gnome_mime_get_keys (mime_type);
		g_hash_table_insert (table, info->mime_type, info);
	}
	if (strncmp (def, "ext", 3) == 0){
		char *tokp;

		def += 3;
		def = get_priority (def, &priority);
		s = p = g_strdup (def);

		used = 0;
		
		while ((ext = strtok_r (s, " \t\n\r,", &tokp)) != NULL){
                        /* FIXME: We really need to check for duplicates before entering this. */
                        if (!init_user) {
                                info->ext[priority] = g_list_prepend (info->ext[priority], ext);
                        } else {
                                info->user_ext[priority] = g_list_prepend (info->user_ext[priority], ext);
                        }
			used = 1;
			s = NULL;
		}
		if (!used)
			g_free (p);
	}

	if (strncmp (def, "regex", 5) == 0){
		regex_t *regex;

		regex = g_new (regex_t, 1);
		def += 5;
		def = get_priority (def, &priority);

		while (*def && isspace (*def))
			def++;

		if (!*def)
			return;
		if (regcomp (regex, def, REG_EXTENDED | REG_NOSUB))
			g_free (regex);
		else {
			info->regex[priority] = regex;
                        g_free (info->regex_readable[priority]);
                        info->regex_readable[priority] = g_strdup (def);
                }
	}
}
static void
mime_fill_from_file (const char *filename, gboolean init_user)
{
	FILE *f;
	char buf [1024];
	char *current_key;
	gboolean used;
	
	g_assert (filename != NULL);

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

	current_key = NULL;
	used = FALSE;
	while (fgets (buf, sizeof (buf), f)){
		char *p;

		if (buf [0] == '#')
			continue;

		/* Trim trailing spaces */
		for (p = buf + strlen (buf) - 1; p >= buf; p--){
			if (isspace (*p) || *p == '\n')
				*p = 0;
			else
				break;
		}
		
		if (!buf [0])
			continue;
		
		if (buf [0] == '\t' || buf [0] == ' '){
			if (current_key){
				char *p = buf;

				while (*p && isspace (*p))
					p++;

				if (*p == 0)
					continue;
				add_to_key (current_key, p, mime_types, init_user);
				if (init_user) {
                                        add_to_key (current_key, p, 
                                                    initial_user_mime_types,
                                                    TRUE);
                                        add_to_key (current_key, p, 
                                                    user_mime_types, TRUE);
                                }
				used = TRUE;
			}
		} else {
			if (!used && current_key)
				g_free (current_key);
			current_key = g_strdup (buf);
			if (current_key [strlen (current_key)-1] == ':')
				current_key [strlen (current_key)-1] = 0;
			
			used = FALSE;
		}
	}
	fclose (f);
}

static void
mime_load_from_dir (const char *mime_info_dir, gboolean system_dir)
{
	DIR *dir;
	struct dirent *dent;
	const int extlen = sizeof (".mime") - 1;
	char *filename;
	
	dir = opendir (mime_info_dir);
	if (!dir)
		return;
	if (system_dir) {
		filename = g_build_filename (mime_info_dir, "gnome.mime", NULL);
		mime_fill_from_file (filename, FALSE);
		g_free (filename);
	}
	while ((dent = readdir (dir)) != NULL){
		
		int len = strlen (dent->d_name);

		if (len <= extlen)
			continue;
		
		if (strcmp (dent->d_name + len - extlen, ".mime"))
			continue;
		if (system_dir && !strcmp (dent->d_name, "gnome.mime"))
			continue;
		if (!system_dir && !strcmp (dent->d_name, "user.mime"))
			continue;
		
		filename = g_build_filename (mime_info_dir, dent->d_name, NULL);
		mime_fill_from_file (filename, FALSE);
		g_free (filename);
	}
	if (!system_dir) {
		filename = g_build_filename (mime_info_dir, "user.mime", NULL);
		mime_fill_from_file (filename, TRUE);
		g_free (filename);
	}
	closedir (dir);
}
static int
add_mime_vals_to_clist (gchar *mime_type, gpointer mi, gpointer cl)
{
        /* we also finalize the MimeInfo structure here, now that we're done
         * loading it */
        static gchar *text[2];
        GList *list;
        GString *extension;
        gint row;
        
        extension = g_string_new ("");
        for (list = ((MimeInfo *) mi)->ext[0];list; list=list->next) {
                g_string_append (extension, (gchar *) list->data);
                if (list->next != NULL)
                        g_string_append (extension, ", ");
        }
        if (strcmp (extension->str, "") != 0 && ((MimeInfo *)mi)->user_ext[0])
                g_string_append (extension, ", ");
        for (list = ((MimeInfo *) mi)->user_ext[0]; list; list=list->next) {
                g_string_append (extension, (gchar *) list->data);
                if (list->next != NULL)
                        g_string_append (extension, ", ");
        }
        ((MimeInfo *) mi)->ext_readable[0] = extension->str;
        g_string_free (extension, FALSE);
        
        extension = g_string_new ("");
        for (list = ((MimeInfo *) mi)->ext[1];list; list=list->next) {
                g_string_append (extension, (gchar *) list->data);
                if (list->next)
                        g_string_append (extension, ", ");
        }
        if (strcmp (extension->str, "") != 0 && ((MimeInfo *)mi)->user_ext[1])
                g_string_append (extension, ", ");
        for (list = ((MimeInfo *) mi)->user_ext[1]; list; list=list->next) {
                g_string_append (extension, (gchar *) list->data);
                if (list->next != NULL)
                        g_string_append (extension, ", ");
        }
        ((MimeInfo *) mi)->ext_readable[1] = extension->str;
        g_string_free (extension, FALSE);

        if (((MimeInfo *) mi)->ext[0] || ((MimeInfo *) mi)->user_ext[0]) {
                extension = g_string_new ((((MimeInfo *) mi)->ext_readable[0]));
                if (((MimeInfo *) mi)->ext[1] || ((MimeInfo *) mi)->user_ext[1]) {
                        g_string_append (extension, ", ");
                        g_string_append (extension, (((MimeInfo *) mi)->ext_readable[1]));
                }
        } else if (((MimeInfo *) mi)->ext[1] || ((MimeInfo *) mi)->user_ext[1])
                extension = g_string_new ((((MimeInfo *) mi)->ext_readable[1]));
        else
                extension = g_string_new ("");

        text[0] = ((MimeInfo *) mi)->mime_type;
        text[1] = extension->str;

        row = gtk_clist_insert (GTK_CLIST (cl), 1, text);
        gtk_clist_set_row_data (GTK_CLIST (cl), row, mi);
        g_string_free (extension, TRUE);
        return row;
}
static void
selected_row_callback (GtkWidget *widget, gint row, gint column, GdkEvent *event, gpointer data)
{
        MimeInfo *mi;
        if (column < 0)
                return;
        
        mi = (MimeInfo *) gtk_clist_get_row_data (GTK_CLIST (widget),row);
        
        if (event && event->type == GDK_2BUTTON_PRESS)
                launch_edit_window (mi);

        if (g_hash_table_lookup (user_mime_types, mi->mime_type)) {
                gtk_widget_set_sensitive (delete_button, TRUE);
        } else
                gtk_widget_set_sensitive (delete_button, FALSE);
}

/* public functions */
void
delete_clicked (GtkWidget *widget, gpointer data)
{
        MimeInfo *mi;
        gint row = 0;

        if (GTK_CLIST (clist)->selection)
                row = GPOINTER_TO_INT ((GTK_CLIST (clist)->selection)->data);
        else
                return;
        mi = (MimeInfo *) gtk_clist_get_row_data (GTK_CLIST (clist), row);

        gtk_clist_remove (GTK_CLIST (clist), row);
        g_hash_table_remove (user_mime_types, mi->mime_type);
        remove_mime_info (mi->mime_type);
        free_mime_info (mi);
        capplet_widget_state_changed (CAPPLET_WIDGET (capplet),
                                      TRUE);
}

void
edit_clicked (GtkWidget *widget, gpointer data)
{
        MimeInfo *mi;
        gint row = 0;

        if (GTK_CLIST (clist)->selection)
                row = GPOINTER_TO_INT ((GTK_CLIST (clist)->selection)->data);
        else
                return;
        mi = (MimeInfo *) gtk_clist_get_row_data (GTK_CLIST (clist), row);
        if (mi)
                launch_edit_window (mi);
        gtk_clist_remove (GTK_CLIST (clist), row);
        row = add_mime_vals_to_clist (mi->mime_type, mi, clist);
        gtk_clist_select_row (GTK_CLIST (clist), row, 0);
}
void
add_clicked (GtkWidget *widget, gpointer data)
{
        launch_new_mime_window ();
}

GtkWidget *
get_mime_clist (void)
{
        GtkWidget *retval;
        gchar *titles[2];

        titles[0] = _("Mime Type");
        titles[1] = _("Extension");
        retval = gtk_scrolled_window_new (NULL, NULL);
        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (retval),
                                        GTK_POLICY_AUTOMATIC,
                                        GTK_POLICY_AUTOMATIC);
	clist = gtk_clist_new_with_titles (2, titles);
	gtk_widget_set_usize (clist, 400, 300); 
        gtk_signal_connect (GTK_OBJECT (clist),
                            "select_row",
                            GTK_SIGNAL_FUNC (selected_row_callback),
                            NULL);
        gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_BROWSE);
        gtk_clist_set_auto_sort (GTK_CLIST (clist), TRUE);
        if (clist)
                g_hash_table_foreach (mime_types, (GHFunc) add_mime_vals_to_clist, clist);
        gtk_clist_columns_autosize (GTK_CLIST (clist));
        gtk_clist_select_row (GTK_CLIST (clist), 0, 0);
        gtk_container_add (GTK_CONTAINER (retval), clist);
        return retval;
}

static void
finalize_mime_type_foreach (gpointer mime_type, gpointer info, gpointer data)
{
        MimeInfo *mi = (MimeInfo *)info;
        GList *list;
        GString *extension;
        
        extension = g_string_new ("");
        for (list = ((MimeInfo *) mi)->ext[0];list; list=list->next) {
                g_string_append (extension, (gchar *) list->data);
                if (list->next != NULL)
                        g_string_append (extension, ", ");
        }
        if (strcmp (extension->str, "") != 0 && mi->user_ext[0])
                g_string_append (extension, ", ");
        for (list = ((MimeInfo *) mi)->user_ext[0]; list; list=list->next) {
                g_string_append (extension, (gchar *) list->data);
                if (list->next != NULL)
                        g_string_append (extension, ", ");
        }
        ((MimeInfo *) mi)->ext_readable[0] = extension->str;
        g_string_free (extension, FALSE);
        
        extension = g_string_new ("");
        for (list = ((MimeInfo *) mi)->ext[1];list; list=list->next) {
                g_string_append (extension, (gchar *) list->data);
                if (list->next)
                        g_string_append (extension, ", ");
        }
        if (strcmp (extension->str, "") != 0 && mi->user_ext[1]) 
                g_string_append (extension, ", ");
        for (list = ((MimeInfo *) mi)->user_ext[1]; list; list=list->next) {
                g_string_append (extension, (gchar *) list->data);
                if (list->next != NULL)
                        g_string_append (extension, ", ");
        }
        ((MimeInfo *) mi)->ext_readable[1] = extension->str;
        g_string_free (extension, FALSE);

        if (((MimeInfo *) mi)->ext[0] || ((MimeInfo *) mi)->user_ext[0]) {
                extension = g_string_new ((((MimeInfo *) mi)->ext_readable[0]));
                if (((MimeInfo *) mi)->ext[1] || ((MimeInfo *) mi)->user_ext[1]) {
                        g_string_append (extension, ", ");
                        g_string_append (extension, (((MimeInfo *) mi)->ext_readable[1]));
                }
        } else if (((MimeInfo *) mi)->ext[1] || ((MimeInfo *) mi)->user_ext[1])
                extension = g_string_new ((((MimeInfo *) mi)->ext_readable[1]));
        else
                extension = g_string_new ("");
        g_string_free (extension, TRUE);
}
static void
finalize_user_mime ()
{
        g_hash_table_foreach (user_mime_types, finalize_mime_type_foreach, NULL);
        g_hash_table_foreach (initial_user_mime_types, finalize_mime_type_foreach, NULL);
}
void
init_mime_type (void)
{
	char *mime_info_dir;
	
	mime_types = g_hash_table_new (g_str_hash, g_str_equal);
	initial_user_mime_types = g_hash_table_new (g_str_hash, g_str_equal);
	user_mime_types = g_hash_table_new (g_str_hash, g_str_equal);

	mime_info_dir = gnome_unconditional_datadir_file ("mime-info");
	mime_load_from_dir (mime_info_dir, TRUE);
	g_free (mime_info_dir);

	mime_info_dir = g_build_filename (gnome_util_user_home (), ".gnome/mime-info", NULL);
	mime_load_from_dir (mime_info_dir, FALSE);
	g_free (mime_info_dir);
        finalize_user_mime ();
        init_mime_info ();
}
void
add_new_mime_type (gchar *mime_type, gchar *raw_ext, gchar *regexp1, gchar *regexp2)
{
        gchar *temp;
        MimeInfo *mi = NULL;
        gint row;
        gchar *ext = NULL;
        gchar *ptr, *ptr2;
        
        /* first we make sure that the information is good */
        if (mime_type == NULL || *mime_type == '\000') {
                run_error (_("You must enter a mime-type"));
                return;
        } else if ((raw_ext == NULL || *raw_ext == '\000') &&
                   (regexp1 == NULL || *regexp1 == '\000') &&
                   (regexp2 == NULL || *regexp2 == '\000')){
                run_error (_("You must add either a regular-expression or\na file-name extension"));
                return;
        }
        if (strchr (mime_type, '/') == NULL) {
                run_error (_("Please put your mime-type in the format:\nCATEGORY/TYPE\n\nFor Example:\nimage/png"));
                return;
        }
        if (g_hash_table_lookup (user_mime_types, mime_type) ||
            g_hash_table_lookup (mime_types, mime_type)) {
                run_error (_("This mime-type already exists"));
                return;
        }
        if (raw_ext || *raw_ext) {
                ptr2 = ext = g_malloc (sizeof (raw_ext));
                for (ptr = raw_ext;*ptr; ptr++) {
                        if (*ptr != '.' && *ptr != ',') {
                                *ptr2 = *ptr;
                                ptr2 += 1;
                        }
                }
                *ptr2 = '\000';
        }
        /* passed check, now we add it. */
        if (ext) {
                temp = g_strconcat ("ext: ", ext, NULL);
                add_to_key (mime_type, temp, user_mime_types, TRUE);
                mi = (MimeInfo *) g_hash_table_lookup (user_mime_types, mime_type);
                g_free (temp);
        }
        if (regexp1) {
                temp = g_strconcat ("regex: ", regexp1, NULL);
                add_to_key (mime_type, temp, user_mime_types, TRUE);
                g_free (temp);
        }
        if (regexp2) {
                temp = g_strconcat ("regex,2: ", regexp2, NULL);
                add_to_key (mime_type, temp, user_mime_types, TRUE);
                g_free (temp);
        }
        /* Finally add it to the clist */
        if (mi) {
                row = add_mime_vals_to_clist (mime_type, mi, clist);
                gtk_clist_select_row (GTK_CLIST (clist), row, 0);
                gtk_clist_moveto (GTK_CLIST (clist), row, 0, 0.5, 0.0);
        }
        g_free (ext);
}
static void
write_mime_foreach (gpointer mime_type, gpointer info, gpointer data)
{
	gchar *buf;
	MimeInfo *mi = (MimeInfo *) info;
	fwrite ((char *) mi->mime_type, 1, strlen ((char *) mi->mime_type), (FILE *) data);
	fwrite ("\n", 1, 1, (FILE *) data);
        if (mi->ext_readable[0]) {
                fwrite ("\text: ", 1, strlen ("\text: "), (FILE *) data);
                fwrite (mi->ext_readable[0], 1,
                        strlen (mi->ext_readable[0]),
                        (FILE *) data);
                fwrite ("\n", 1, 1, (FILE *) data);
        }
        if (mi->regex_readable[0]) {
                fwrite ("\tregex: ", 1, strlen ("\tregex: "), (FILE *) data);
                fwrite (mi->regex_readable[0], 1,
                        strlen (mi->regex_readable[0]),
                        (FILE *) data);
                fwrite ("\n", 1, 1, (FILE *) data);
        }
        if (mi->regex_readable[1]) {
                fwrite ("\tregex,2: ", 1, strlen ("\tregex,2: "), (FILE *) data);
                fwrite (mi->regex_readable[1], 1,
                        strlen (mi->regex_readable[1]),
                        (FILE *) data);
                fwrite ("\n", 1, 1, (FILE *) data);
        }
        fwrite ("\n", 1, 1, (FILE *) data);
}

static void
write_mime (GHashTable *hash)
{
	struct stat s;
	gchar *dirname, *filename;
	FILE *file;
	GtkWidget *error_box;

	dirname = g_build_filename (gnome_util_user_home (), ".gnome/mime-info", NULL);
	if ((stat (dirname, &s) < 0) || !(S_ISDIR (s.st_mode))){
		if (errno == ENOENT) {
			if (mkdir (dirname, S_IRWXU) < 0) {
				run_error (_("We are unable to create the directory\n"
					   "~/.gnome/mime-info\n\n"
					   "We will not be able to save the state."));
				return;
			}
		} else {
			run_error (_("We are unable to access the directory\n"
				   "~/.gnome/mime-info\n\n"
				   "We will not be able to save the state."));
			return;
		}
	}
	filename = g_build_filename (dirname, "user.mime", NULL);
        
        remove (filename);
	file = fopen (filename, "w");
	if (file == NULL) {
		run_error (_("Cannot create the file\n~/.gnome/mime-info/user.mime\n\n"
			     "We will not be able to save the state"));
		return;
	}
	g_hash_table_foreach (hash, write_mime_foreach, file);
	fclose (file);
}

void
write_user_mime (void)
{
        write_mime (user_mime_types);
}

void
write_initial_mime (void)
{
        write_mime (initial_user_mime_types);
}

void
reread_list ()
{
        gtk_clist_freeze (GTK_CLIST (clist));
        gtk_clist_clear (GTK_CLIST (clist));
        g_hash_table_foreach (mime_types, (GHFunc) add_mime_vals_to_clist, clist);
        gtk_clist_thaw (GTK_CLIST (clist));
}
static void
clean_mime_type (gpointer mime_type, gpointer mime_info, gpointer data)
{
        /* we should write this )-: */
}
void
discard_mime_info ()
{
        gchar *filename;
	g_hash_table_foreach (user_mime_types, clean_mime_type, NULL);
	g_hash_table_destroy (user_mime_types);
	g_hash_table_foreach (initial_user_mime_types, clean_mime_type, NULL);
	g_hash_table_destroy (initial_user_mime_types);
	user_mime_types = g_hash_table_new (g_str_hash, g_str_equal);
        initial_user_mime_types = g_hash_table_new (g_str_hash, g_str_equal);
        
	filename = g_build_filename (gnome_util_user_home (), "/.gnome/mime-info/user.keys", NULL);
	mime_fill_from_file (filename, TRUE);
        finalize_user_mime ();
        reread_list ();
	g_free (filename);
}