/*

 * Copyright (C) 2009, 2011, 2012, 2014, 2016  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>

#include <errno.h>

#include <unistd.h>

#include <glib-object.h>

#include "plover/transaction.h"

#include "plover/plover.h"

G_DEFINE_TYPE(PloverTransaction,plover_transaction,G_TYPE_OBJECT);

enum {

    STATUS_CHANGED=0,

    N_SIGNALS

};

typedef struct _PloverTransactionPrivate {

    GMutex mutex;

    gchar *status;

} PloverTransactionPrivate;

#define PLOVER_TRANSACTION_GET_PRIVATE(obj)\

				G_TYPE_INSTANCE_GET_PRIVATE(obj,\

				  PLOVER_TYPE_TRANSACTION,\

				  PloverTransactionPrivate)

static guint signals[N_SIGNALS];

static void plover_transaction_finalize(PloverTransaction *transaction)

{

    PloverTransactionPrivate *priv=PLOVER_TRANSACTION_GET_PRIVATE(transaction);

    g_free(priv->status);

    g_mutex_clear(&priv->mutex);

    g_free(transaction->base);

    g_free(transaction->prefix);

    g_free(transaction->unsatisfied);

    if (transaction->trans)

	razor_transaction_destroy(transaction->trans);

    if (transaction->relocations)

	razor_relocations_destroy(transaction->relocations);

    if (transaction->install_iterator)

	razor_install_iterator_destroy(transaction->install_iterator);

    if (transaction->next)

	razor_set_unref(transaction->next);

    if (transaction->system)

	razor_set_unref(transaction->system);

}

static void plover_transaction_dispose(PloverTransaction *transaction)

{

    g_clear_object(&transaction->installed);

    g_clear_object(&transaction->relocated);

    g_clear_object(&transaction->upstream);

}

static void plover_transaction_class_init(PloverTransactionClass *klass)

{

    GObjectClass *gobject_class=G_OBJECT_CLASS(klass);

    plover__uri_handler_init();

    gobject_class->finalize=(void (*)(GObject *))plover_transaction_finalize;

    gobject_class->dispose=(void (*)(GObject *))plover_transaction_dispose;

    signals[STATUS_CHANGED]=g_signal_new("status-changed",

      G_TYPE_FROM_CLASS(klass),G_SIGNAL_RUN_LAST,0,NULL,NULL,

      g_cclosure_marshal_VOID__STRING,G_TYPE_NONE,1,G_TYPE_STRING);

    g_type_class_add_private(klass,sizeof(PloverTransactionPrivate));

}

static void plover_transaction_init(PloverTransaction *transaction)

{

    PloverTransactionPrivate *priv=PLOVER_TRANSACTION_GET_PRIVATE(transaction);

    g_mutex_init(&priv->mutex);

}

gboolean plover_transaction_resolve(PloverTransaction *transaction,

  GError **error)

{

    g_return_val_if_fail(PLOVER_IS_TRANSACTION(transaction),FALSE);

    if (!(transaction->flags&PLOVER_TRANSACTION_RESOLVED))

    {

	razor_transaction_resolve(transaction->trans);

	transaction->flags|=PLOVER_TRANSACTION_RESOLVED;

	g_free(transaction->unsatisfied);

	transaction->unsatisfied=NULL;

	if (razor_transaction_describe(transaction->trans)>0)

	    transaction->flags|=PLOVER_TRANSACTION_UNSATISFIED;

    }

    if (transaction->flags&PLOVER_TRANSACTION_UNSATISFIED)

    {

	g_set_error(error,PLOVER_GENERAL_ERROR,

	  PLOVER_GENERAL_ERROR_REQUIREMENTS_NOT_MET,

	  "Package requirements not met");

	return FALSE;

    }

    return TRUE;

}

static void plover_transaction_unsatisfied_callback(const char *requirement,

  struct razor_package *package,const char *name,const char *version,

  const char *arch,void *data)

{

    GString *string=data;

    g_string_append_printf(string,"%s is needed by %s-%s.%s\n",requirement,name,

      version,arch);

}

const char *plover_transaction_get_unsatisfied(PloverTransaction *transaction)

{

    GString *unsatisfied;

    g_return_val_if_fail(PLOVER_IS_TRANSACTION(transaction),NULL);

    if (plover_transaction_resolve(transaction,NULL))

	return NULL;

    else if (!transaction->unsatisfied)

    {

	unsatisfied=g_string_new(NULL);

	if (!razor_transaction_unsatisfied(transaction->trans,

	  plover_transaction_unsatisfied_callback,unsatisfied))

	    /* Impossible */

	    g_string_assign(unsatisfied,

	      "Unknown package requirements unsatisfied");

	transaction->unsatisfied=g_string_free(unsatisfied,FALSE);

    }

    return transaction->unsatisfied;

}

struct razor_set *plover_transaction_get_system_set(

  PloverTransaction *transaction)

{

    g_return_val_if_fail(PLOVER_IS_TRANSACTION(transaction),NULL);

    if (!transaction->system && transaction->installed)

    {

	transaction->system=

	  plover_package_set_get_razor(transaction->installed);

	if (transaction->system)

	    razor_set_ref(transaction->system);

    }

    return transaction->system;

}

struct razor_set *plover_transaction_get_next_set(

  PloverTransaction *transaction,GError **error)

{

    g_return_val_if_fail(PLOVER_IS_TRANSACTION(transaction),NULL);

    if (!transaction->next)

    {

	if (!plover_transaction_resolve(transaction,error))

	    return NULL;

	transaction->next=razor_transaction_commit(transaction->trans);

    }

    return transaction->next;

}

struct razor_install_iterator *plover_transaction_get_install_iterator(

  PloverTransaction *transaction,GError **error)

{

    g_return_val_if_fail(PLOVER_IS_TRANSACTION(transaction),NULL);

    if (!transaction->install_iterator)

    {

	if (!plover_transaction_get_next_set(transaction,error))

	    return NULL;

	(void)plover_transaction_get_system_set(transaction);

	transaction->install_iterator=

	  razor_set_create_install_iterator(transaction->system,

	  transaction->next);

    }

    razor_install_iterator_rewind(transaction->install_iterator);

    return transaction->install_iterator;

}

static gboolean

  plover_transaction_emit_status_changed(PloverTransaction *transaction)

{

    gchar *status;

    PloverTransactionPrivate *priv=PLOVER_TRANSACTION_GET_PRIVATE(transaction);

    g_mutex_lock(&priv->mutex);

    status=g_strdup(priv->status);

    g_mutex_unlock(&priv->mutex);

    g_signal_emit(transaction,signals[STATUS_CHANGED],0,status);

    g_free(status);

    return FALSE;	/* No more calls */

}

static void plover_transaction_set_status(PloverTransaction *transaction,

  gboolean via_g_idle,const char *status)

{

    PloverTransactionPrivate *priv=PLOVER_TRANSACTION_GET_PRIVATE(transaction);

    g_mutex_lock(&priv->mutex);

    g_free(priv->status);

    priv->status=g_strdup(status);

    g_mutex_unlock(&priv->mutex);

    if (via_g_idle)

	g_idle_add_full(G_PRIORITY_DEFAULT_IDLE,

	  (GSourceFunc)plover_transaction_emit_status_changed,

	  g_object_ref(transaction),g_object_unref);

    else

	plover_transaction_emit_status_changed(transaction);

}

gboolean plover_transaction_commit(PloverTransaction *transaction,

  GCancellable *cancellable,GError **error)

{

    int r,count;

    unsigned files_action;

    gboolean retval;

    size_t pos;

    struct razor_set *set;

    struct razor_package *pkg;

    enum razor_install_action action;

    struct razor_install_iterator *ii;

    struct razor_atomic *atomic;

    PloverPackageSet *next;

    gboolean via_g_idle;

    g_return_val_if_fail(PLOVER_IS_TRANSACTION(transaction),FALSE);

    if (g_cancellable_set_error_if_cancelled(cancellable,error))

	return FALSE;

    ii=plover_transaction_get_install_iterator(transaction,error);

    if (!ii)

	return FALSE;

    /*

     * If we are called from the default thread it is most useful to

     * emit signals directly however this is not safe when running in

     * a non-default thread and we want to use g_idle to emit signals

     * in the default thread instead.

     *

     * Note that the documentation for g_main_context_get_thread_default()

     * explicitly states that it may return a non-NULL value even when

     * called from the default thread. This would cause us to use g_idle

     * when not strictly necessary, but will still be safe.

     */

    via_g_idle=!!g_main_context_get_thread_default();

    do

    {

	if (g_cancellable_set_error_if_cancelled(cancellable,error))

	    return FALSE;

	pos=razor_install_iterator_tell(ii);

	plover_transaction_set_status(transaction,via_g_idle,

	  "Running pre-transaction scripts");

	atomic=razor_atomic_open("package transaction");

	next=plover_package_set_new_from_razor(transaction->next);

	r=plover_run_transaction(transaction->trans,ii,

	  plover_package_set_get_install_root(transaction->installed),

	  transaction->system,next,transaction->upstream,atomic,

	  transaction->relocations,RAZOR_STAGE_SCRIPTS_PRE,cancellable);

	if (r<0)

	{

	    plover_transaction_set_status(transaction,via_g_idle,

	      "Failed in pre-transaction scripts");

	    plover_propagate_razor_error_dup(error,

	      razor_atomic_get_error(atomic));

	    razor_atomic_destroy(atomic);

	    g_object_unref(next);

	    return FALSE;

	}

	else

	{

	    razor_install_iterator_seek(ii,pos);

	    files_action=0;

	    while (razor_install_iterator_next(ii,&pkg,&action,&count))

		if (action==RAZOR_INSTALL_ACTION_REMOVE)

		    files_action|=1;

		else if (action==RAZOR_INSTALL_ACTION_ADD)

		    files_action|=2;

		else

		    break;

	    plover_transaction_set_status(transaction,via_g_idle,

	      files_action==1?"Removing files":"Unpacking files");

	    razor_install_iterator_seek(ii,pos);

	    r=plover_run_transaction(transaction->trans,ii,

	      plover_package_set_get_install_root(transaction->installed),

	      transaction->system,next,transaction->upstream,

	      atomic,transaction->relocations,RAZOR_STAGE_FILES,

#if RAZOR_HAVE_ATOMIC_ROLLBACK

	      cancellable);

#else

	      NULL);

#endif

	    if (r==1)

	    {

		set=razor_install_iterator_commit_set(ii);

		plover_package_set_update(transaction->installed,set,atomic);

		razor_set_unref(set);

	    }

	    else if (!r)

		plover_package_set_update(transaction->installed,

		  transaction->next,atomic);

	    retval=!razor_atomic_commit(atomic);

	    if (!retval)

	    {

		plover_transaction_set_status(transaction,via_g_idle,

		  "Failed to unpack all files correctly");

		plover_propagate_razor_error_dup(error,

		  razor_atomic_get_error(atomic));

	    }

	    else

	    {

		plover_transaction_set_status(transaction,via_g_idle,

		  "Running post-transaction scripts");

		razor_install_iterator_seek(ii,pos);

		plover_run_transaction(transaction->trans,ii,

		  plover_package_set_get_install_root(transaction->installed),

		  transaction->system,next,transaction->upstream,

		  atomic,transaction->relocations,RAZOR_STAGE_SCRIPTS_POST,

		  NULL);

	    }

	}

	razor_atomic_destroy(atomic);

	g_object_unref(next);

    } while(retval && r==1);

    plover_transaction_set_status(transaction,via_g_idle,"Completed");

    return retval;

}

static void plover_transaction_commit_async_thread(GTask *task,

  gpointer source_object,gpointer task_data,GCancellable *cancellable)

{

    PloverTransaction *transaction=source_object;

    GError *error=NULL;

    GMainContext *context;

    gboolean retval;

    context=g_main_context_new();

    g_main_context_push_thread_default(context);

    retval=plover_transaction_commit(transaction,cancellable,&error);

    g_main_context_pop_thread_default(context);

    g_main_context_unref(context);

    if (!retval)

	g_task_return_error(task,error);

    else

	g_task_return_boolean(task,TRUE);

}

void plover_transaction_commit_async(PloverTransaction *transaction,

  GCancellable *cancellable,GAsyncReadyCallback callback,gpointer user_data)

{

    GTask *task;

    g_return_if_fail(PLOVER_IS_TRANSACTION(transaction));

    task=g_task_new(transaction,cancellable,callback,user_data);

    g_task_run_in_thread(task,plover_transaction_commit_async_thread);

    g_object_unref(task);

}

gboolean plover_transaction_commit_finish(PloverTransaction *transaction,

  GAsyncResult *result,GError **error)

{

    g_return_val_if_fail(PLOVER_IS_TRANSACTION(transaction),FALSE);

    g_return_val_if_fail(g_task_is_valid(result,transaction),FALSE);

    return g_task_propagate_boolean(G_TASK(result),error);

}

static int plover_mark_package_for_update(struct razor_transaction *trans,

  struct razor_set *set,const char *pkg)

{

    struct razor_package_iterator *pi;

    struct razor_package *package;

    const char *name;

    int retval=-1;

    pi=razor_package_iterator_create(set);

    while (razor_package_iterator_next(pi,&package,RAZOR_DETAIL_NAME,&name,

      RAZOR_DETAIL_LAST))

    {

	if (!strcmp(name,pkg))

	{

	    razor_transaction_update_package(trans,package);

	    retval=0;

	    break;

	}

    }

    razor_package_iterator_destroy(pi);

    return retval;

}

PloverTransaction *plover_transaction_new(void)

{

    return PLOVER_TRANSACTION(g_object_new(PLOVER_TYPE_TRANSACTION,NULL));

}

void plover_transaction_set_prefix(PloverTransaction *transaction,

  const char *prefix)

{

    g_return_if_fail(PLOVER_IS_TRANSACTION(transaction));

    g_return_if_fail(transaction->upstream == NULL);

    if (!g_strcmp0(prefix,transaction->prefix))

	return;

    if (transaction->relocations)

	razor_relocations_destroy(transaction->relocations);

    g_free(transaction->prefix);

    if (prefix)

    {

	transaction->relocations=razor_relocations_create();

	razor_relocations_add(transaction->relocations,"/usr",prefix);

    }

    else

	transaction->relocations=NULL;

    transaction->prefix=g_strdup(prefix);

}

void plover_transaction_set_installed(PloverTransaction *transaction,

  PloverPackageSet *installed)

{

    g_return_if_fail(PLOVER_IS_TRANSACTION(transaction));

    g_return_if_fail(PLOVER_IS_PACKAGE_SET(installed));

    if (transaction->system)

    {

	razor_set_unref(transaction->system);

	transaction->system=NULL;

    }

    if (transaction->installed)

	g_object_unref(transaction->installed);

    transaction->installed=g_object_ref(installed);

}

gboolean plover_transaction_root_open(PloverTransaction *transaction,

  const char *install_root,GError **error)

{

    PloverPackageSet *installed;

    const char *install_uri;

    gchar *install_path;

    GFile *file;

    gboolean retval;

    g_return_val_if_fail(PLOVER_IS_TRANSACTION(transaction),FALSE);

    if (!install_root)

    {

	install_uri=g_getenv("RAZOR_ROOT");

	if (install_uri)

	{

	    file=g_file_new_for_uri(install_uri);

	    install_path=g_file_get_path(file);

	    g_object_unref(file);

	    if (!install_path)

	    {

		g_set_error(error,PLOVER_GENERAL_ERROR,

		  PLOVER_GENERAL_ERROR_FAILED,

		  "%s: Not a local URI",install_uri);

		return FALSE;

	    }

	}

	else

	    install_path=g_strdup("/");

    }

    else

	install_path=g_strdup(install_root);

    if (transaction->installed && !g_strcmp0(install_path,

      plover_package_set_get_install_root(transaction->installed)))

    {

	g_free(install_path);

	return TRUE;

    }

    installed=plover_package_set_new();

    retval=plover_package_set_open(installed,install_path,TRUE,error);

    if (retval)

	plover_transaction_set_installed(transaction,installed);

    else

	g_object_unref(installed);

    g_free(install_path);

    return retval;

}

struct razor_set *plover_transaction_import_yum(PloverTransaction *transaction,

  const char *base,GError **error)

{

    g_return_val_if_fail(PLOVER_IS_TRANSACTION(transaction),NULL);

    g_return_val_if_fail(transaction->base == NULL,NULL);

    transaction->base=g_strdup(base);

    return plover_razor_set_create_from_yum(base,error);

}

gboolean plover_transaction_set_upstream(PloverTransaction *transaction,

  PloverRepository *upstream,GError **error)

{

    g_return_val_if_fail(PLOVER_IS_TRANSACTION(transaction),FALSE);

    g_return_val_if_fail(PLOVER_IS_REPOSITORY(upstream),FALSE);

    g_return_val_if_fail(transaction->upstream == NULL,FALSE);

    transaction->relocated=plover_package_set_new_from_repository(upstream,

      transaction->relocations,error);

    if (transaction->relocated)

	transaction->upstream=g_object_ref(upstream);

    return !!transaction->relocated;

}

gboolean

  plover_transaction_set_upstream_from_yum_uri(PloverTransaction *transaction,

  const char *base_uri,GError **error)

{

    gboolean retval;

    PloverRepository *upstream;

    g_return_val_if_fail(PLOVER_IS_TRANSACTION(transaction),FALSE);

    g_return_val_if_fail(transaction->upstream == NULL,FALSE);

    upstream=plover_repository_new_from_yum_uri(base_uri,error);

    if (!upstream)

	return FALSE;

    retval=plover_transaction_set_upstream(transaction,upstream,error);

    g_object_unref(upstream);

    return retval;

}

gboolean

  plover_transaction_set_upstream_from_yum(PloverTransaction *transaction,

  const char *base,GError **error)

{

    gboolean retval;

    gchar *base_uri;

    GFile *file;

    file=g_file_new_for_path(base);

    base_uri=g_file_get_uri(file);

    g_object_unref(file);

    retval=plover_transaction_set_upstream_from_yum_uri(transaction,base_uri,error);

    g_free(base_uri);

    return retval;

}

gboolean plover_transaction_install(PloverTransaction *transaction,

  char **pkgs,GError **error)

{

    int i;

    struct razor_set *system,*upstream;

    g_return_val_if_fail(PLOVER_IS_TRANSACTION(transaction),FALSE);

    g_return_val_if_fail(transaction->upstream != NULL,FALSE);

    g_return_val_if_fail(transaction->trans == NULL,FALSE);

    if (!plover_transaction_root_open(transaction,NULL,error))

	return FALSE;

    system=plover_transaction_get_system_set(transaction);

    if (!system)

    {

	/* Impossible */

	g_set_error(error,PLOVER_GENERAL_ERROR,PLOVER_GENERAL_ERROR_FAILED,

	  "Internal error: No system set");

	return FALSE;

    }

    upstream=plover_package_set_get_razor(transaction->relocated);

    transaction->trans=razor_transaction_create(system,upstream);

    for(i=0;pkgs[i];i++)

	if (plover_mark_package_for_update(transaction->trans,system,pkgs[i]) &&

	  plover_mark_package_for_update(transaction->trans,upstream,pkgs[i]))

	{

	    g_set_error(error,PLOVER_GENERAL_ERROR,

	      PLOVER_GENERAL_ERROR_NO_SUCH_PACKAGE,"%s: %s",pkgs[i],

	      "Package not found");

	    razor_transaction_destroy(transaction->trans);

	    transaction->trans=NULL;

	    return FALSE;

	    break;

	}

    return TRUE;

}

gboolean plover_transaction_update(PloverTransaction *transaction,

  char **pkgs,GError **error)

{

    int i;

    struct razor_set *system,*upstream;

    g_return_val_if_fail(PLOVER_IS_TRANSACTION(transaction),FALSE);

    g_return_val_if_fail(transaction->upstream != NULL,FALSE);

    g_return_val_if_fail(transaction->trans == NULL,FALSE);

    if (!plover_transaction_root_open(transaction,NULL,error))

	return FALSE;

    system=plover_transaction_get_system_set(transaction);

    if (!system)

    {

	/* Impossible */

	g_set_error(error,PLOVER_GENERAL_ERROR,PLOVER_GENERAL_ERROR_FAILED,

	  "Internal error: No system set");

	return FALSE;

    }

    upstream=plover_package_set_get_razor(transaction->relocated);

    transaction->trans=razor_transaction_create(system,upstream);

    if (!pkgs)

	razor_transaction_update_all(transaction->trans);

    else

	for(i=0;pkgs[i];i++)

	    if (plover_mark_package_for_update(transaction->trans,system,

	      pkgs[i]))

	    {

		g_set_error(error,PLOVER_GENERAL_ERROR,

		  PLOVER_GENERAL_ERROR_NO_SUCH_PACKAGE,"%s: %s",pkgs[i],

		  "Package not found");

		razor_transaction_destroy(transaction->trans);

		transaction->trans=NULL;

		return FALSE;

		break;

	    }

    return TRUE;

}

PloverTransaction *plover_transaction_new_install_uri(const char *base_uri,

  const char *prefix,char **pkgs,GError **error)

{

    PloverTransaction *transaction;

    transaction=plover_transaction_new();

    plover_transaction_set_prefix(transaction,prefix);

    if (!plover_transaction_set_upstream_from_yum_uri(transaction,base_uri,error))

    {

	g_object_unref(transaction);

	return NULL;

    }

    if (!plover_transaction_install(transaction,pkgs,error))

    {

	g_object_unref(transaction);

	return NULL;

    }

    return transaction;

}

PloverTransaction *plover_transaction_new_install(const char *base,

  const char *prefix,char **pkgs,GError **error)

{

    PloverTransaction *transaction;

    gchar *base_uri;

    GFile *file;

    file=g_file_new_for_path(base);

    base_uri=g_file_get_uri(file);

    g_object_unref(file);

    transaction=plover_transaction_new_install_uri(base_uri,prefix,pkgs,error);

    g_free(base_uri);

    return transaction;

}

PloverTransaction *plover_transaction_new_update_uri(const char *base_uri,

  const char *prefix,char **pkgs,GError **error)

{

    PloverTransaction *transaction;

    transaction=plover_transaction_new();

    plover_transaction_set_prefix(transaction,prefix);

    if (!plover_transaction_set_upstream_from_yum_uri(transaction,base_uri,

      error))

    {

	g_object_unref(transaction);

	return NULL;

    }

    if (!plover_transaction_update(transaction,pkgs,error))

    {

	g_object_unref(transaction);

	return NULL;

    }

    return transaction;

}

PloverTransaction *plover_transaction_new_update(const char *base,

  const char *prefix,char **pkgs,GError **error)

{

    PloverTransaction *transaction;

    transaction=plover_transaction_new();

    plover_transaction_set_prefix(transaction,prefix);

    if (!plover_transaction_set_upstream_from_yum(transaction,base,error))

    {

	g_object_unref(transaction);

	return NULL;

    }

    if (!plover_transaction_update(transaction,pkgs,error))

    {

	g_object_unref(transaction);

	return NULL;

    }

    return transaction;

}

static int plover_mark_packages_for_removal(struct razor_transaction *trans,

  struct razor_set *set,const char *pkg)

{

    struct razor_package_iterator *pi;

    struct razor_package *package;

    const char *name;

    int retval=pkg?-1:0;

    pi=razor_package_iterator_create(set);

    while (razor_package_iterator_next(pi,&package,RAZOR_DETAIL_NAME,&name,

      RAZOR_DETAIL_LAST))

    {

	if (!pkg || !strcmp(name,pkg))

	{

	    razor_transaction_remove_package(trans,package);

	    retval=0;

	}

    }

    razor_package_iterator_destroy(pi);

    return retval;

}

gboolean plover_transaction_remove(PloverTransaction *transaction,

  char **pkgs,GError **error)

{

    int i;

    struct razor_set *system,*empty;

    g_return_val_if_fail(PLOVER_IS_TRANSACTION(transaction),FALSE);

    g_return_val_if_fail(transaction->trans == NULL,FALSE);

    if (!plover_transaction_root_open(transaction,NULL,error))

	return FALSE;

    system=plover_transaction_get_system_set(transaction);

    if (!system)

    {

	/* Impossible */

	g_set_error(error,PLOVER_GENERAL_ERROR,PLOVER_GENERAL_ERROR_FAILED,

	  "Internal error: No system set");

	return FALSE;

    }

    empty=razor_set_create_without_root();

    transaction->trans=razor_transaction_create(system,empty);

    razor_set_unref(empty);

    if (!pkgs)

	plover_mark_packages_for_removal(transaction->trans,system,NULL);

    else

	for(i=0;pkgs[i];i++)

	    if (plover_mark_packages_for_removal(transaction->trans,system,

	      pkgs[i]))

	    {

		g_set_error(error,PLOVER_GENERAL_ERROR,

		  PLOVER_GENERAL_ERROR_NO_SUCH_PACKAGE,"%s: %s",pkgs[i],

		  "Package not found");

		razor_transaction_destroy(transaction->trans);

		transaction->trans=NULL;

		return FALSE;

		break;

	    }

    return TRUE;

}

PloverTransaction *plover_transaction_new_remove(char **pkgs,GError **error)

{

    PloverTransaction *transaction;

    transaction=plover_transaction_new();

    if (!plover_transaction_remove(transaction,pkgs,error))

    {

	g_object_unref(transaction);

	return NULL;

    }

    return transaction;

}

static GList *plover_what_has_property(struct razor_set *set,uint32_t prop_type,

  const char *ref_name)

{

    const char *name,*version;

    uint32_t flags;

    GList *list=NULL;

    struct razor_property *property;

    struct razor_package *package;

    struct razor_package_iterator *what_has;

    struct razor_property_iterator *all_props;

    all_props=razor_property_iterator_create(set,NULL);

    while (razor_property_iterator_next(all_props,&property,&name,&flags,

      &version))

    {

	if ((flags&RAZOR_PROPERTY_TYPE_MASK)!=prop_type)

	    continue;

	if (strcmp(name,ref_name))

	    continue;

	what_has=razor_package_iterator_create_for_property(set,property);

	while(razor_package_iterator_next(what_has,&package,

	  RAZOR_DETAIL_LAST))

	    list=g_list_prepend(list,package);

	razor_package_iterator_destroy(what_has);

    }

    razor_property_iterator_destroy(all_props);

    return list;

}

static GList *plover_what_provides(struct razor_set *set,const char *ref_name)

{

    return plover_what_has_property(set,RAZOR_PROPERTY_PROVIDES,ref_name);

}

static GList *plover_what_requires(struct razor_set *set,const char *ref_name)

{

    return plover_what_has_property(set,RAZOR_PROPERTY_REQUIRES,ref_name);

}

PloverTransaction *plover_transaction_new_remove_with_leaves(char **pkgs,

  GError **error)

{

    int i,changed,is_leaf;

    uint32_t flags;

    gchar *install_path;

    const char *install_uri;

    const char *name,*version,*maybe_unused_name;

    struct razor_set *system,*upstream;

    struct razor_transaction *trans;

    PloverPackageSet *installed;

    PloverTransaction *transaction;

    struct plover_vector *package_names;

    GList *to_remove,*lnk,*lnk2,*what_requires,*what_provides;

    GFile *file;

    struct razor_package *package,*maybe_unused_package;

    struct razor_property *property;

    struct razor_package_query *query;

    struct razor_package_iterator *all_packages,*removed;

    struct razor_property_iterator *removed_props;

    if (!pkgs)

	return plover_transaction_new_remove(NULL,error);

    install_uri=g_getenv("RAZOR_ROOT");

    if (install_uri)

    {

	file=g_file_new_for_uri(install_uri);

	install_path=g_file_get_path(file);

	g_object_unref(file);

	if (!install_path)

	{

	    g_set_error(error,PLOVER_GENERAL_ERROR,PLOVER_GENERAL_ERROR_FAILED,

	      "%s: Not a local URI",install_uri);

	    return NULL;

	}

    }

    else

	install_path=g_strdup("/");

    installed=plover_package_set_new();

    if (!plover_package_set_open(installed,install_path,TRUE,error))

    {

	g_object_unref(installed);

	g_free(install_path);

	return NULL;

    }

    g_free(install_path);

    system=plover_package_set_get_razor(installed);

    package_names=plover_vector_new();

    for(i=0;pkgs[i];i++)

	plover_vector_append(package_names,pkgs[i]);

    to_remove=NULL;

    all_packages=razor_package_iterator_create(system);

    while (razor_package_iterator_next(all_packages,&package,

      RAZOR_DETAIL_NAME,&name,RAZOR_DETAIL_LAST))

	if (plover_vector_remove(package_names,name))

	    to_remove=g_list_prepend(to_remove,package);

    razor_package_iterator_destroy(all_packages);

    if (package_names->len)

    {

	g_set_error(error,PLOVER_GENERAL_ERROR,

	  PLOVER_GENERAL_ERROR_NO_SUCH_PACKAGE,"%s: %s",

	  package_names->strings[0],"Package not found");

	plover_vector_free(package_names);

	g_list_free(to_remove);

	g_object_unref(installed);

	return NULL;

    }

    plover_vector_free(package_names);

    do

    {

	changed=FALSE;

	query=razor_package_query_create(system);

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

	    razor_package_query_add_package(query,lnk->data);

	removed=razor_package_query_finish(query);

	while(razor_package_iterator_next(removed,&package,RAZOR_DETAIL_LAST))

	{

	    removed_props=razor_property_iterator_create(system,package);

	    while (razor_property_iterator_next(removed_props,&property,&name,

	      &flags,&version))

	    {

		if ((flags&RAZOR_PROPERTY_TYPE_MASK)!=RAZOR_PROPERTY_REQUIRES)

		    continue;

		what_provides=plover_what_provides(system,name);

		for(lnk2=what_provides;lnk2;lnk2=lnk2->next)

		{

		    maybe_unused_package=lnk2->data;

		    if (g_list_find(to_remove,maybe_unused_package))

			continue;

		    is_leaf=TRUE;

		    razor_package_get_details(system,maybe_unused_package,

		      RAZOR_DETAIL_NAME,&maybe_unused_name,RAZOR_DETAIL_LAST);

		    what_requires=plover_what_requires(system,

		      maybe_unused_name);

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

			if (!g_list_find(to_remove,lnk->data))

			{

			    is_leaf=FALSE;

			    break;

			}

		    g_list_free(what_requires);

		    if (is_leaf)

		    {

			to_remove=g_list_prepend(to_remove,

			  maybe_unused_package);

			changed=TRUE;

		    }

		}

	    }

	    razor_property_iterator_destroy(removed_props);

	}

	razor_package_iterator_destroy(removed);

    } while(changed);

    upstream=razor_set_create_without_root();

    trans=razor_transaction_create(system,upstream);

    razor_set_unref(upstream);

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

	razor_transaction_remove_package(trans,lnk->data);

    transaction=plover_transaction_new();

    transaction->trans=trans;

    transaction->installed=installed;

    return transaction;

}