/*

  * Copyright (C) 2010  J. Ali Harlow <ali@juiblex.co.uk>

  *

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

  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

  */

 #include "config.h"

 #include <stdlib.h>

 #include <string.h>

 #ifdef WIN32

 #include <windows.h>

 #endif

 #include <glib.h>

 #include <gio/gio.h>

 #include <gtk/gtk.h>

 #include <plover-gtk/packagestore.h>

 #include "app-manager.h"

 #include "localmedia.h"

 G_DEFINE_TYPE(PloverLocalMediaStore,plover_local_media_store,

   PLOVER_TYPE_PACKAGE_STORE);

 static void plover_local_media_store_dispose(GObject *obj)

 {

     PloverLocalMediaStore *store=PLOVER_LOCAL_MEDIA_STORE(obj);

     if (store->monitor)

     {

 	g_object_unref(store->monitor);

 	store->monitor=NULL;

     }

     if (G_OBJECT_CLASS(plover_local_media_store_parent_class)->dispose)

 	G_OBJECT_CLASS(plover_local_media_store_parent_class)->dispose(obj);

 }

 static void

   plover_local_media_store_class_init(PloverLocalMediaStoreClass *klass)

 {

     GObjectClass *oclass=G_OBJECT_CLASS(klass);

     oclass->dispose=plover_local_media_store_dispose;

 }

 GtkTreeModel *plover_local_media_store_new(void)

 {

     return g_object_new(PLOVER_TYPE_LOCAL_MEDIA_STORE,NULL);

 }

 static void local_media_scan_mount(PloverLocalMediaStore *store,GMount *mount)

 {

     GFile *root;

     gchar *path;

 #ifdef WIN32

     gunichar2 *path2;

     UINT type;

 #endif

     PloverPackageSet *set;

     root=g_mount_get_root(mount);

     path=g_file_get_path(root);

 #ifdef WIN32

     if (path)

     {

 	path2=g_utf8_to_utf16(path,-1,NULL,NULL,NULL);

 	if (path2)

 	{

 	    type=GetDriveTypeW(path2);

 	    g_free(path2);

 	}

 	else

 	    type=DRIVE_UNKNOWN;

 	if (type!=DRIVE_REMOVABLE && type!=DRIVE_CDROM)

 	{

 	    gchar *name=g_mount_get_name(mount);

 	    g_debug("Skipping non-local mount \"%s\"",name);

 	    g_free(name);

 	    g_free(path);

 	    path=NULL;

 	}

     }

 #endif

     if (path)

     {

 	set=plover_package_set_new_from_repository(path,relocations,NULL);

 	if (set)

 	{

 	    g_object_set_data(G_OBJECT(mount),"plover-local-media-set",set);

 	    plover_package_store_add_set(PLOVER_PACKAGE_STORE(store),set);

 	    g_object_ref(mount);

 	}

 	g_free(path);

     }

     g_object_unref(root);

 }

 static void local_media_mounted(GObject *source,GAsyncResult *res,gpointer data)

 {

     GVolume *volume=G_VOLUME(source);

     GMount *mount;

     PloverLocalMediaStore *store=PLOVER_LOCAL_MEDIA_STORE(data);

     if (g_volume_mount_finish(volume,res,NULL))

     {

 	mount=g_volume_get_mount(volume);

 	if (mount)

 	{

 	    local_media_scan_mount(store,mount);

 	    g_object_unref(mount);

 	}

     }

     g_object_unref(volume);

 }

 static void local_media_scan_drive(PloverLocalMediaStore *store,GDrive *drive)

 {

     GVolume *volume;

     GMount *mount;

     GList *volumes,*mounts,*link;

     if (!drive)

 	volumes=g_volume_monitor_get_volumes(store->monitor);

     else if (g_drive_has_media(drive))

 	volumes=g_drive_get_volumes(drive);

     else

 	volumes=NULL;

     for(link=volumes;link;link=link->next)

     {

 	volume=G_VOLUME(link->data);

 	mount=g_volume_get_mount(volume);

 	if (mount)

 	{

 	    local_media_scan_mount(store,mount);

 	    g_object_unref(mount);

 	}

 	else if (!store->implicit_scan && g_volume_can_mount(volume))

 	    g_volume_mount(volume,G_MOUNT_MOUNT_NONE,NULL,NULL,

 	      local_media_mounted,store);

 	g_object_unref(volume);

     }

     g_list_free(volumes);

     if (!drive)

     {

 	mounts=g_volume_monitor_get_mounts(store->monitor);

 	for(link=mounts;link;link=link->next)

 	{

 	    mount=G_MOUNT(link->data);

 	    local_media_scan_mount(store,mount);

 	    g_object_unref(mount);

 	}

 	g_list_free(mounts);

     }

 }

 static void local_media_polled(GObject *source,GAsyncResult *res,gpointer data)

 {

     GDrive *drive=G_DRIVE(source);

     PloverLocalMediaStore *store=PLOVER_LOCAL_MEDIA_STORE(data);

     if (g_drive_poll_for_media_finish(drive,res,NULL))

 	local_media_scan_drive(store,drive);

     g_object_unref(drive);

 }

 void plover_local_media_store_scan(PloverLocalMediaStore *store)

 {

     GSList *sets,*slink;

     GList *drives,*link;

     GDrive *drive;

     g_return_if_fail(PLOVER_IS_LOCAL_MEDIA_STORE(store));

     sets=

       g_slist_copy(plover_package_store_get_sets(PLOVER_PACKAGE_STORE(store)));

     for(slink=sets;slink;slink=slink->next)

 	plover_package_store_remove_set(PLOVER_PACKAGE_STORE(store),

 	  PLOVER_PACKAGE_SET(slink->data));

     g_slist_free(sets);

     drives=g_volume_monitor_get_connected_drives(store->monitor);

     for(link=drives;link;link=link->next)

     {

 	drive=G_DRIVE(link->data);

 	if (g_drive_is_media_removable(drive))

 	{

 	    if (!g_drive_is_media_check_automatic(drive) &&

 	      g_drive_can_poll_for_media(drive) ||

 	      !g_drive_has_media(drive) && !store->implicit_scan)

 	    {

 		g_object_ref(drive);

 		g_drive_poll_for_media(drive,NULL,local_media_polled,store);

 	    }

 	    else

 		local_media_scan_drive(store,drive);

 	}

 	g_object_unref(drive);

     }

     g_list_free(drives);

     local_media_scan_drive(store,NULL);

 }

 static void local_media_mount_added(GVolumeMonitor *volume_monitor,

   GMount *mount,PloverLocalMediaStore *store)

 {

     local_media_scan_mount(store,mount);

 }

 static void local_media_mount_removed(GVolumeMonitor *volume_monitor,

   GMount *mount,PloverLocalMediaStore *store)

 {

     PloverPackageSet *set=

       g_object_get_data(G_OBJECT(mount),"plover-local-media-set");

     if (set)

     {

 	plover_package_store_remove_set(PLOVER_PACKAGE_STORE(store),set);

 	g_object_set_data(G_OBJECT(mount),"plover-local-media-set",NULL);

 	g_object_unref(set);

 	g_object_unref(mount);

     }

 }

 static void local_media_mount_changed(GVolumeMonitor *volume_monitor,

   GMount *mount,PloverLocalMediaStore *store)

 {

     local_media_mount_removed(volume_monitor,mount,store);

     local_media_mount_added(volume_monitor,mount,store);

 }

 static void plover_local_media_store_init(PloverLocalMediaStore *store)

 {

     store->monitor=g_volume_monitor_get();

     store->implicit_scan=TRUE;

     plover_local_media_store_scan(store);

     store->implicit_scan=FALSE;

     g_signal_connect(store->monitor,"mount-added",

       G_CALLBACK(local_media_mount_added),store);

     g_signal_connect(store->monitor,"mount-changed",

       G_CALLBACK(local_media_mount_changed),store);

     g_signal_connect(store->monitor,"mount-removed",

       G_CALLBACK(local_media_mount_removed),store);

 }