/**

  * $Id$

  *

  * GD-Rom list manager - maintains the list of recently accessed images and

  * available devices for the UI + config. 

  *

  * Copyright (c) 2005 Nathan Keynes.

  *

  * 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.

  */

 #include <string.h>

 #include <stdlib.h>

 #include <glib/gstrfuncs.h>

 #include <libgen.h>

 #include "gettext.h"

 #include "gdrom/gdrom.h"

 #include "gdlist.h"

 #include "lxdream.h"

 #include "config.h"

 #define MAX_RECENT_ITEMS 5

 #define FIRST_RECENT_INDEX (gdrom_device_count+2)

 DEFINE_HOOK(gdrom_list_change_hook, gdrom_list_change_hook_t);

 static GList *gdrom_device_list = NULL;

 static GList *gdrom_recent_list = NULL;

 static unsigned int gdrom_device_count = 0, gdrom_recent_count = 0;

 gint gdrom_list_find( const gchar *name )

 {

     gint posn = 0;

     GList *ptr;

     for( ptr = gdrom_device_list; ptr != NULL; ptr = g_list_next(ptr) ) {

         gdrom_device_t device = (gdrom_device_t)ptr->data;

         posn++;

         if( strcmp(device->name, name) == 0 ) {

             return posn;

         }

     }

     posn++;

     for( ptr = gdrom_recent_list; ptr != NULL; ptr = g_list_next(ptr) ) {

         gchar *file = (gchar *)ptr->data;

         posn++;

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

             return posn;

         }

     }

     return -1;

 }

 /**

  * Update the recent list in the lxdream config (but does not save)  

  */

 void gdrom_list_update_config()

 {

     GList *ptr;

     int size = 0;

     for( ptr = gdrom_recent_list; ptr != NULL; ptr = g_list_next(ptr) ) {

         size += strlen( (gchar *)ptr->data ) + 1;

     }

     char buf[size];

     strcpy( buf, (gchar *)gdrom_recent_list->data );

     for( ptr = g_list_next(gdrom_recent_list); ptr != NULL; ptr = g_list_next(ptr) ) {

         strcat( buf, ":" );

         strcat( buf, (gchar *)ptr->data );

     }

     lxdream_set_global_config_value( CONFIG_RECENT, buf );

 }

 void gdrom_list_add_recent_item( const gchar *name )

 {

     gdrom_recent_list = g_list_prepend( gdrom_recent_list, g_strdup(name) );

     if( g_list_length(gdrom_recent_list) > MAX_RECENT_ITEMS ) {

         GList *ptr = g_list_nth( gdrom_recent_list, MAX_RECENT_ITEMS );

         g_free( ptr->data );

         gdrom_recent_list = g_list_remove( gdrom_recent_list, ptr->data );

     } else {

         gdrom_recent_count ++;

     }

     gdrom_list_update_config();

 }

 void gdrom_list_move_to_front( const gchar *name )

 {

     GList *ptr;

     for( ptr = gdrom_recent_list; ptr != NULL; ptr = g_list_next(ptr) ) {

         gchar *file = (gchar *)ptr->data;

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

             gdrom_recent_list = g_list_delete_link( gdrom_recent_list, ptr );

             gdrom_recent_list = g_list_prepend( gdrom_recent_list, file );

             gdrom_list_update_config();

             return;

         }

     }

 }

 /**

  * Disc-changed callback from the GD-Rom driver. Updates the list accordingly.

  */

 gboolean gdrom_list_disc_changed( gdrom_disc_t disc, const gchar *disc_name, void *user_data )

 {

     gboolean list_changed = FALSE;

     int posn = 0;

     if( disc != NULL ) {

         posn = gdrom_list_find( disc_name );

         if( posn == -1 ) {

             gdrom_list_add_recent_item( disc_name );

             posn = FIRST_RECENT_INDEX;

             list_changed = TRUE;

         } else if( posn > FIRST_RECENT_INDEX ) {

             gdrom_list_move_to_front( disc_name );

             posn = FIRST_RECENT_INDEX;

             list_changed = TRUE;

         }

     }

     lxdream_set_global_config_value( CONFIG_GDROM, disc_name );

     lxdream_save_config();   

     CALL_HOOKS( gdrom_list_change_hook, list_changed, posn );

     return TRUE;

 }

 /**

  * Drives-changed callback from the host CD-Rom drivers. Probably not likely to

  * happen too often unless you're adding/removing external drives...

  */

 void gdrom_list_drives_changed( GList *device_list )

 {

 }

 /************ Public interface ***********/

 void gdrom_list_init()

 {

     const gchar *recent = lxdream_get_config_value( CONFIG_RECENT );

     register_gdrom_disc_change_hook( gdrom_list_disc_changed, NULL );

     gdrom_device_list = cdrom_get_native_devices();

     if( recent != NULL ) {

         gchar **list = g_strsplit(recent, ":", MAX_RECENT_ITEMS);

         int i;

         for( i=0; list[i] != NULL; i++ ) {

             gdrom_recent_list = g_list_append( gdrom_recent_list, g_strdup(list[i]) );

         }

         g_strfreev(list);

     }

     gdrom_device_count = g_list_length(gdrom_device_list);

     gdrom_recent_count = g_list_length(gdrom_recent_list);

     // Run the hooks in case anyone registered before the list was initialized

     CALL_HOOKS( gdrom_list_change_hook, TRUE, gdrom_list_get_selection() );

 }

 gboolean gdrom_list_set_selection( int posn )

 {

     if( posn == 0 ) { // Always 'Empty'

         gdrom_unmount_disc();

         return TRUE;

     }

     if( posn <= gdrom_device_count ) {

         gdrom_device_t device = g_list_nth_data(gdrom_device_list, posn-1);

         return gdrom_mount_image(device->name);

     }

     posn -= FIRST_RECENT_INDEX;

     if( posn >= 0 && posn < gdrom_recent_count ) {

         gchar *entry = g_list_nth_data(gdrom_recent_list, posn);

         return gdrom_mount_image(entry);

     }

     return FALSE;

 }

 gint gdrom_list_get_selection( )

 {

     const char *name = gdrom_get_current_disc_name();

     if( name == NULL ) {

         return 0;

     } else {

         return gdrom_list_find(name);

     }

 }

 int gdrom_list_size()

 {

     return gdrom_device_count + gdrom_recent_count + 2;

 }

 const gchar *gdrom_list_get_display_name( int posn )

 {

     if( posn == 0 ) {

         return _("Empty");

     }

     if( posn <= gdrom_device_count ) {

         gdrom_device_t device = g_list_nth_data(gdrom_device_list, posn-1);

         return device->device_name;

     }

     if( posn == gdrom_device_count + 1) {

         return "";

     }

     if( posn < 0 || posn > gdrom_list_size() ) {

         return NULL;

     }

     gchar *entry = g_list_nth_data(gdrom_recent_list, posn-FIRST_RECENT_INDEX);

     return basename(entry);

 }

 const gchar *gdrom_list_get_filename( int posn )

 {

     if( posn == 0 ) {

         return _("Empty");

     }

     if( posn <= gdrom_device_count ) {

         gdrom_device_t device = g_list_nth_data(gdrom_device_list, posn-1);

         return device->name;

     }

     if( posn == gdrom_device_count + 1) {

         return "";

     }

     if( posn < 0 || posn > gdrom_list_size() ) {

         return NULL;

     }

     return g_list_nth_data(gdrom_recent_list, posn-FIRST_RECENT_INDEX);

 }