/*

  * Copyright (C) 2010, 2020  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	/* WIN32 */

 #include <lua.h>

 #include <glib.h>

 #include <gio/gio.h>

 #include <gtk/gtk.h>

 #include <whelk/whelk.h>

 #include <plover/plover.h>

 #include <plover/packageset.h>

 #include <plover-gtk/stockicons.h>

 #include "app-manager.h"

 #include "localmedia.h"

 LUALIB_API int luaopen_posix(lua_State *L);

 #define LOGO_NAME	"plover-applications"

 GtkBuilder *ui;

 GtkTreeModel *installed,*applications,*location,*local_media;

 char *prefix=NULL;

 struct razor_relocations *relocations=NULL;

 void show_busy_cursor(gboolean busy)

 {

     GList *list,*link,*remaining;

     GdkDisplay *display;

     GdkCursor *cursor;

     GtkWidget *w;

     list=gtk_window_list_toplevels();

     while(list)

     {

 	w=GTK_WIDGET(list->data);

 	if (!w->window)

 	{

 	    link=list;

 	    list=g_list_remove_link(list,link);

 	    g_list_free_1(link);

 	}

 	else

 	{

 	    display=gtk_widget_get_display(w);

 	    cursor=busy?gdk_cursor_new_for_display(display,GDK_WATCH):NULL;

 	    remaining=NULL;

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

 	    {

 		w=GTK_WIDGET(link->data);

 		if (w->window)

 		{

 		    if (gtk_widget_get_display(w)==display)

 			gdk_window_set_cursor(w->window,cursor);

 		    else

 			remaining=g_list_prepend(remaining,w);

 		}

 	    }

 	    gdk_display_flush(display);

 	    if (cursor)

 		gdk_cursor_unref(cursor);

 	    g_list_free(list);

 	    list=remaining;

 	}

     }

 }

 /*

  * In Gtk+ 2.16.6, the default handler generates g_warnings on error.

  * It should display an error to the user. Do it ourselves.

  */

 static void show_uri(GtkLinkButton *button,const gchar *uri,gpointer data)

 {

     GdkScreen *screen;

     GtkWidget *dialog;

     GError *error=NULL;

     if (gtk_widget_has_screen(GTK_WIDGET(button)))

 	screen=gtk_widget_get_screen(GTK_WIDGET(button));

     else

 	screen=NULL;

     gtk_show_uri(screen,uri,GDK_CURRENT_TIME,&error);

     if (error)

     {

 	dialog=gtk_message_dialog_new(

 	  GTK_WINDOW(gtk_builder_get_object(ui,"MainWindow")),

 	  GTK_DIALOG_DESTROY_WITH_PARENT,GTK_MESSAGE_ERROR,GTK_BUTTONS_CLOSE,

 	  "Unable to show '%s'",uri);

 	gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),

 	  error->message);

 	g_error_free(error);

 	gtk_dialog_run(GTK_DIALOG(dialog));

 	gtk_widget_destroy(dialog);

     }

 }

 #if 0

 /* Checks whether a loader for SVG files has been registered

  * with GdkPixbuf.

  */

 static gboolean pixbuf_supports_svg(void)

 {

     GSList *formats;

     GSList *tmp_list;

     static gint found_svg=-1;

     gchar **mime_types,**mime_type;

     if (found_svg!=-1)

 	return found_svg;

     formats=gdk_pixbuf_get_formats();

     found_svg=FALSE;

     for (tmp_list=formats;tmp_list && !found_svg;tmp_list=tmp_list->next)

     {

 	mime_types=gdk_pixbuf_format_get_mime_types(tmp_list->data);

 	for (mime_type=mime_types;*mime_type && !found_svg;mime_type++)

 	    if (!strcmp(*mime_type,"image/svg"))

 		found_svg=TRUE;

 	g_strfreev(mime_types);

     }

     g_slist_free(formats);

     return found_svg;

 }

 static void install_icon_at_size(const char *icon_name,GtkIconSet *icon_set,

   GtkIconSize size,const char *filename)

 {

     int w,h;

     GdkPixbuf *pixbuf;

     GtkIconSource *source;

     if (gtk_icon_size_lookup(size,&w,&h))

     {

 	pixbuf=gdk_pixbuf_new_from_file_at_size(filename,w,h,NULL);

 	if (pixbuf)

 	{

 	    source=gtk_icon_source_new();

 	    gtk_icon_source_set_size_wildcarded(source,FALSE);

 	    gtk_icon_source_set_size(source,size);

 	    gtk_icon_source_set_pixbuf(source,pixbuf);

 	    gtk_icon_set_add_source(icon_set,source);

 	    gtk_icon_source_free(source);

 	    g_object_unref(pixbuf);

 	}

     }

 }

 static void install_icons(void)

 {

     gchar *s;

     GtkIconSource *source;

     GtkIconSet *icon_set;

     GtkIconFactory *factory;

     factory=gtk_icon_factory_new();

     icon_set=gtk_icon_set_new();

     if (pixbuf_supports_svg())

     {

 	source=gtk_icon_source_new();

 	s=g_build_filename(prefix?prefix:"/usr",

 	  "share/icons/hicolor/scalable/apps/plover-applications.svg",NULL);

 	gtk_icon_source_set_filename(source,s);

 	g_free(s);

 	gtk_icon_set_add_source(icon_set,source);

 	gtk_icon_source_free(source);

     }

     else

     {

 	s=g_build_filename(prefix?prefix:"/usr",

 	  "share/icons/hicolor/24x24/apps/plover-applications.png",NULL);

 	install_icon_at_size(LOGO_NAME,icon_set,GTK_ICON_SIZE_MENU,s);

 	install_icon_at_size(LOGO_NAME,icon_set,GTK_ICON_SIZE_BUTTON,s);

 	install_icon_at_size(LOGO_NAME,icon_set,GTK_ICON_SIZE_SMALL_TOOLBAR,s);

 	install_icon_at_size(LOGO_NAME,icon_set,GTK_ICON_SIZE_LARGE_TOOLBAR,s);

 	g_free(s);

 	s=g_build_filename(prefix?prefix:"/usr",

 	  "share/icons/hicolor/48x48/apps/plover-applications.png",NULL);

 	install_icon_at_size(LOGO_NAME,icon_set,GTK_ICON_SIZE_DND,s);

 	install_icon_at_size(LOGO_NAME,icon_set,GTK_ICON_SIZE_DIALOG,s);

 	g_free(s);

     }

     gtk_icon_factory_add(factory,LOGO_NAME,icon_set);

     gtk_icon_set_unref(icon_set);

     icon_set=gtk_icon_factory_lookup(factory,LOGO_NAME);

     gtk_icon_factory_add_default(factory);

     g_object_unref(factory);

     icon_set=gtk_icon_factory_lookup_default(LOGO_NAME);

     gtk_window_set_default_icon_name(LOGO_NAME);

 }

 #endif

 static void install_icons(void)

 {

     GtkIconSet *icon_set;

     plover_icons_add_to_stock("apps",LOGO_NAME);

     icon_set=gtk_icon_factory_lookup_default(LOGO_NAME);

     gtk_window_set_default_icon_name(LOGO_NAME);

 }

 static gboolean uri_validate(const char *uri)

 {

     char *s;

     s=razor_path_relative_to_uri(uri,".",NULL);

     free(s);

     return !!s;

 }

 char *uri_from_base(const char *base,gboolean use_paths)

 {

     char *retval;

     if (use_paths)

     {

 	retval=razor_path_to_uri(base);

 	if (!retval)

 	{

 	    g_printerr("%s: Not a valid path\n",base);

 	    exit(1);

 	}

     }

     else if (!uri_validate(base))

     {

 	g_printerr("%s: Not a valid URI\n",base);

 	exit(1);

     }

     else

 	retval=strdup(base);

     return retval;

 }

 int main(int argc,char **argv)

 {

     gboolean use_paths=FALSE;

     GError *err=0;

     GtkWidget *w;

     char *uri;

     gchar *s,*database_uri,*contents;

     gchar *database=NULL,*setup_base=NULL,*update_base=NULL;

     gchar *default_action_base=NULL;

     gsize len;

     struct comps *comps;

     PloverPackageSet *set=NULL;

     GSList *objects,*lnk;

     gboolean started;

     GOptionEntry options[]={

 	{"database",0,0,G_OPTION_ARG_STRING,&database,

 	  "Operate on a distribution-local database","vendor/distribution"},

 	{"paths",0,0,G_OPTION_ARG_NONE,&use_paths,

 	  "Interpret locations as paths rather than URIs",NULL},

 	{"setup",0,0,G_OPTION_ARG_STRING,&setup_base,

 	  "Setup from installation media","location"},

 	{"update",0,0,G_OPTION_ARG_STRING,&update_base,

 	  "Update from upgrade media","location"},

 	{"default-action",0,0,G_OPTION_ARG_STRING,&default_action_base,

 	  "Install, remove or update from repository","location"},

 	{NULL}

     };

 #ifdef WIN32

     /*

      * app-manager is normally a GUI application, but rpm scripts may well

      * call console applications and it looks ugly if console windows keep

      * popping up. Avoid this by allocating our own console and hiding it.

      * Note:

      *	- If app-manager is a console application (typically for debugging),

      *    then skip this step.

      *  - Call ShowWindow twice to negate special handling on first call.

      */

     if (!GetConsoleWindow())

     {

 	AllocConsole();

 	ShowWindow(GetConsoleWindow(),SW_HIDE);

 	ShowWindow(GetConsoleWindow(),SW_HIDE);

     }

 #endif

     plover_exception_handler_init();

     razor_set_lua_loader("posix",(void (*)())luaopen_posix);

     razor_set_lua_loader("whelk",(void (*)())luaopen_whelk);

     if (!gtk_init_with_args(&argc,&argv,NULL,options,NULL,&err))

     {

 	g_printerr("%s\n",err->message);

 	exit(1);

     }

     if (!!setup_base+!!update_base+!!default_action_base>1)

     {

 	g_printerr(

 	  "--setup, --update and --default_action are mutually exclusive\n");

 	exit(1);

     }

 #ifdef WIN32

     prefix=g_win32_get_package_installation_directory_of_module(NULL);

 #endif

     install_icons();

     ui=gtk_builder_new();

     if (!g_file_get_contents("app-manager.ui",&contents,&len,&err) &&

       g_error_matches(err,G_FILE_ERROR,G_FILE_ERROR_NOENT))

     {

 #ifdef WIN32

 	s=g_build_filename(prefix,"share","plover","app-manager.ui",NULL);

 #else

 	s=g_build_filename(PLOVER_DATADIR,"app-manager.ui",NULL);

 #endif

 	g_clear_error(&err);

 	(void)g_file_get_contents(s,&contents,&len,&err);

 	g_free(s);

     }

     if (!err)

     {

 	(void)gtk_builder_add_from_string(ui,contents,len,&err);

 	g_free(contents);

     }

     if (err)

     {

 	g_error("%s",err->message);

 	exit(0);

     }

     gtk_builder_connect_signals(ui,NULL);

     gtk_link_button_set_uri_hook(show_uri,NULL,NULL);

     if (setup_base)

     {

 	uri=uri_from_base(setup_base,use_paths);

 	started=setup(uri);

 	free(uri);

     }

     else if (update_base)

     {

 	uri=uri_from_base(update_base,use_paths);

 	started=update(uri);

 	free(uri);

     }

     else if (default_action_base)

     {

 	uri=uri_from_base(default_action_base,use_paths);

 	started=default_action(uri);

 	free(uri);

     }

     else

     {

 	if (database)

 	{

 	    g_free(prefix);

 	    prefix=NULL;

 	    s=strchr(database,'/');

 	    if (*s)

 		*s++='\0';

 	    comps=plover_comps_new();

 	    plover_comps_set_vendor(comps,database);

 	    if (s)

 	    {

 		plover_comps_set_distribution(comps,s);

 		*--s='/';

 	    }

 	    prefix=plover_comps_get_default_prefix(comps);

 	    plover_comps_free(comps);

 	    s=g_strconcat(prefix,"/var/lib/razor",NULL);

 	    database_uri=razor_path_to_uri(s);

 	    g_free(s);

 	    razor_set_database_uri(database_uri);

 	    g_free(database_uri);

 	}

 	if (prefix)

 	{

 	    relocations=razor_relocations_create();

 	    razor_relocations_add(relocations,"/usr",prefix);

 	}

 	installed=GTK_TREE_MODEL(plover_package_store_new());

 	set=plover_package_set_new();

 	(void)plover_package_set_open(set,"",TRUE,NULL);

 	plover_package_store_add_set(PLOVER_PACKAGE_STORE(installed),set);

 	if (plover_package_set_get_no_details(set))

 	{

 	    w=GTK_WIDGET(gtk_builder_get_object(ui,"ViewFiles"));

 	    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(w),TRUE);

 	}

 	applications=plover_applications_model_new(installed);

 	set_package_model(applications);

 	w=GTK_WIDGET(gtk_builder_get_object(ui,"MainWindow"));

 	gtk_widget_show(w);

 	started=TRUE;

     }

     if (started)

 	gtk_main();

     g_clear_object(&set);

     objects=gtk_builder_get_objects(ui);

     for(lnk=objects;lnk;lnk=lnk->next)

 	if (GTK_IS_WIDGET(lnk->data) &&

 	  gtk_widget_is_toplevel(GTK_WIDGET(lnk->data)))

 	    gtk_widget_destroy(GTK_WIDGET(lnk->data));

     g_slist_free(objects);

     g_clear_object(&ui);

     g_clear_object(&installed);

     g_clear_object(&applications);

     g_clear_object(&location);

     g_clear_object(&local_media);

     if (relocations)

 	razor_relocations_destroy(relocations);

     g_free(prefix);

     g_free(setup_base);

     g_free(update_base);

     g_free(default_action_base);

     g_free(database);

     exit(0);

 }

 G_MODULE_EXPORT void

   on_applications_toggled(GtkToggleToolButton *button,gpointer data)

 {

     if (gtk_toggle_tool_button_get_active(button))

     {

 	if (!applications)

 	    applications=plover_applications_model_new(installed);

 	set_package_model(applications);

     }

 }

 G_MODULE_EXPORT void

   on_all_packages_toggled(GtkToggleToolButton *button,gpointer data)

 {

     if (gtk_toggle_tool_button_get_active(button))

 	set_package_model(installed);

 }

 G_MODULE_EXPORT void

   on_local_media_toggled(GtkToggleToolButton *button,gpointer data)

 {

     if (gtk_toggle_tool_button_get_active(button))

     {

 	if (!local_media)

 	{

 	    show_busy_cursor(TRUE);

 	    local_media=plover_local_media_store_new();

 	    show_busy_cursor(FALSE);

 	}

 	set_package_model(local_media);

     }

 }

 G_MODULE_EXPORT void

   on_location_toggled(GtkToggleToolButton *button,gpointer data)

 {

     if (gtk_toggle_tool_button_get_active(button))

 	set_package_model(location);

 }

 G_MODULE_EXPORT void on_open_location(GtkWidget *widget)

 {

     GtkWidget *w=GTK_WIDGET(gtk_builder_get_object(ui,"MainWindow"));

     GtkWidget *dialog;

     GFile *file,*parent;

     GFileInfo *fi;

     GMount *mount;

     gchar *path,*name;

     PloverPackageSet *set;

     GSList *sets;

     GError *err=NULL;

     dialog=gtk_file_chooser_dialog_new("Open Location",GTK_WINDOW(w),

       GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,GTK_STOCK_CANCEL,

       GTK_RESPONSE_CANCEL,GTK_STOCK_OPEN,GTK_RESPONSE_ACCEPT,NULL);

 #if GTK_CHECK_VERSION(2,18,0)

     gtk_file_chooser_set_create_folders(GTK_FILE_CHOOSER(dialog),FALSE);

 #endif

     if (gtk_dialog_run(GTK_DIALOG(dialog))==GTK_RESPONSE_ACCEPT)

     {

 	show_busy_cursor(TRUE);

 	path=gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));

 	set=plover_package_set_new_from_yum(path,relocations,&err);

 	if (set)

 	{

 	    if (!location)

 		location=GTK_TREE_MODEL(plover_package_store_new());

 	    while((sets=

 	      plover_package_store_get_sets(PLOVER_PACKAGE_STORE(location))))

 		plover_package_store_remove_set(PLOVER_PACKAGE_STORE(location),

 		  PLOVER_PACKAGE_SET(sets->data));

 	    plover_package_store_add_set(PLOVER_PACKAGE_STORE(location),set);

 	    g_object_unref(set);

 	    w=GTK_WIDGET(gtk_builder_get_object(ui,"LocationButton"));

 	    file=g_file_new_for_path(path);

 	    parent=g_file_get_parent(file);

 	    if (parent)

 	    {

 		g_object_unref(parent);

 		mount=NULL;

 	    }

 	    else

 		mount=g_file_find_enclosing_mount(file,NULL,NULL);

 	    if (mount)

 	    {

 		name=g_mount_get_name(mount);

 		g_object_unref(mount);

 	    }

 	    else

 	    {

 		fi=g_file_query_info(file,

 		  G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME,

 		  G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,NULL,NULL);

 		if (fi)

 		{

 		    name=g_strdup(g_file_info_get_display_name(fi));

 		    g_object_unref(fi);

 		}

 		else

 		    name=g_filename_display_basename(path);

 		g_object_unref(file);

 	    }

 	    gtk_tool_button_set_label(GTK_TOOL_BUTTON(w),name);

 	    g_free(name);

 	    gtk_widget_show(w);

 	    gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(w),TRUE);

 	}

 	else

 	{

 	    gtk_widget_destroy(dialog);

 	    dialog=gtk_message_dialog_new(GTK_WINDOW(w),

 	      GTK_DIALOG_DESTROY_WITH_PARENT,GTK_MESSAGE_ERROR,

 	      GTK_BUTTONS_CLOSE,"Error loading repository '%s'",path);

 	    gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),

 	      "%s",err->message);

 	    gtk_dialog_run(GTK_DIALOG(dialog));

 	    g_error_free(err);

 	}

 	g_free(path);

 	show_busy_cursor(FALSE);

     }

     gtk_widget_destroy(dialog);

 }

 G_MODULE_EXPORT void on_scan_local_media(GtkWidget *widget)

 {

     show_busy_cursor(TRUE);

     if (!local_media)

 	local_media=plover_local_media_store_new();

     plover_local_media_store_scan(PLOVER_LOCAL_MEDIA_STORE(local_media));

     show_busy_cursor(FALSE);

 }

 G_MODULE_EXPORT void on_help_about(GtkWidget *widget)

 {

     GtkWidget *w=GTK_WIDGET(gtk_builder_get_object(ui,"MainWindow"));

     gtk_show_about_dialog(GTK_WINDOW(w),"name",PACKAGE_NAME,

       "version",PACKAGE_VERSION,"comments","Application Manager",

       "copyright","Copyright © 2010, 2014 J. Ali Harlow",

       "logo-icon-name",LOGO_NAME,

       NULL);

 }

 G_MODULE_EXPORT void on_find_clicked(GtkButton *button)

 {

     gchar *text;

     GtkWidget *w=GTK_WIDGET(gtk_builder_get_object(ui,"SearchEntry"));

     text=g_strdup(gtk_entry_get_text(GTK_ENTRY(w)));

     gtk_entry_set_text(GTK_ENTRY(w),"");

     gtk_entry_set_text(GTK_ENTRY(w),text);

     g_free(text);

 }