/*

 * Copyright (C) 2008  Kristian Høgsberg <krh@redhat.com>

 * Copyright (C) 2008  Red Hat, Inc

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

#include <stdio.h>

#include <stdarg.h>

#include <string.h>

#include <errno.h>

#include <unistd.h>

#include <razor.h>

#include <glib.h>

#include <gio/gio.h>

#include "config.h"

#include "plover/plover.h"

#include "plover/transaction.h"

#include "plover/uri-handler.h"

static char *rpm_filename(const char *name,const char *version,const char *arch)

{

    const char *v;

    v=strchr(version,':');	      /* Skip epoch */

    if (v)

	v++;

    else

	v=version;

    return g_strconcat(name,"-",v,".",arch,".rpm",NULL);

}

/*

 * Returns 0 on success, -1 on failure and 1 if a RAZOR_INSTALL_ACTION_COMMIT

 * is met (in which case the action is consumed).

 */

int plover_run_transaction(struct razor_transaction *trans,

  struct razor_install_iterator *ii,const char *install_root,

  struct razor_set *system,PloverPackageSet *next,PloverRepository *upstream,

  struct razor_atomic *atomic,struct razor_relocations *relocations,

  enum razor_stage_type stage,GCancellable *cancellable)

{

    struct razor_package *pkg;

    enum razor_install_action action;

    struct razor_rpm *rpm;

    struct razor_error *error=NULL;

    const char *name,*version,*arch;

    gchar *t;

    int r,count;

    GError *tmp_error=NULL;

    PloverPackage *package;

    GFile *file;

    gchar *uri;

    plover__uri_handler_init();

    file=g_file_new_for_path(*install_root?install_root:"/");

    uri=g_file_get_uri(file);

    g_object_unref(file);

    g_message("Using %s as URI",uri);

    switch(stage)

    {

	case RAZOR_STAGE_SCRIPTS_PRE:

	    printf("Running pre-transaction scripts\n");

	    break;

	case RAZOR_STAGE_FILES:

	    printf("Running Transaction\n");

	    break;

	case RAZOR_STAGE_SCRIPTS_POST:

	    printf("Running post-transaction scripts\n");

	    break;

	default:

	    /* Keep the compiler happy */

	    break;

    }

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

    {

	if (g_cancellable_is_cancelled(cancellable))

	{

	    razor_atomic_abort(atomic,PLOVER_GENERAL_ERROR,

	      PLOVER_GENERAL_ERROR_CANCELLED,"Operation was cancelled");

	    g_free(uri);

	    return -1;

	}

	if (action==RAZOR_INSTALL_ACTION_REMOVE)

	{

	    razor_package_get_details(system,pkg,RAZOR_DETAIL_NAME,&name,

	      RAZOR_DETAIL_LAST);

	    if (stage==RAZOR_STAGE_FILES)

		printf("  Removing : %s ",name);

	    r=razor_package_remove(system,plover_package_set_get_razor(next),

	      atomic,pkg,uri,count,stage);

	    if (stage==RAZOR_STAGE_FILES)

		printf("\n");

	}

	else if (action==RAZOR_INSTALL_ACTION_ADD)

	{

	    package=plover_package_set_lookup(next,pkg);

	    rpm=plover_repository_open_rpm(upstream,package,&tmp_error);

	    if (!rpm)

	    {

		plover_propagate_g_error(&error,tmp_error);

		razor_atomic_propagate_error(atomic,error,NULL);

		razor_error_free(error);

		g_free(uri);

		return -1;

	    }

	    if (stage==RAZOR_STAGE_FILES)

		printf("  Installing : %s ",plover_package_get_name(package));

	    if (relocations)

		razor_rpm_set_relocations(rpm,relocations);

	    razor_transaction_fixup_package(trans,pkg,rpm);

	    r=razor_rpm_install(rpm,atomic,uri,1,stage);

	    razor_rpm_close(rpm);

	    if (stage==RAZOR_STAGE_FILES)

		printf("\n");

	}

	else if (action==RAZOR_INSTALL_ACTION_COMMIT)

	    return 1;

	else

	    r=0;

	if (razor_atomic_in_error_state(atomic))

	{

	    g_free(uri);

	    return -1;

	}

	else if (r)

	{

	    if (action==RAZOR_INSTALL_ACTION_REMOVE)

	    {

		razor_package_get_details(system,pkg,RAZOR_DETAIL_NAME,&name,

		  RAZOR_DETAIL_VERSION,&version,RAZOR_DETAIL_ARCH,&arch,

		  RAZOR_DETAIL_LAST);

	    }

	    else

	    {

		package=plover_package_set_lookup(next,pkg);

		name=plover_package_get_name(package);

		version=plover_package_get_version(package);

		arch=plover_package_get_arch(package);

	    }

	    /*

	     * If a pre or preun script fails, then we should

	     * treat that as a fatal error. post and postun

	     * script failures are treated as warnings. Be

	     * nice and tell the user _which_ script failed.

	     */

	    if (stage==RAZOR_STAGE_SCRIPTS_PRE)

	    {

		t=g_strconcat(action==RAZOR_INSTALL_ACTION_ADD?

		  "%pre":"%preun","(",name,"-",version,".",arch,

		  ") scriptlet failed",NULL);

		fprintf(stderr,"error: %s, exit status %d\n",t,r);

		razor_atomic_abort(atomic,PLOVER_SCRIPTLET_ERROR,r,t);

		g_free(t);

		g_free(uri);

		return -1;

	    }

	    else

		fprintf(stderr,

		  "warning: %s(%s-%s.%s) scriptlet failed, exit status %d\n",

		  action==RAZOR_INSTALL_ACTION_ADD?"%post":"%postun",

		  name,version,arch,r);

	}

    }

    g_free(uri);

    return 0;

}

gboolean plover_install_uri(const char *base_uri,const char *prefix,char **pkgs,

  GError **error)

{

    gboolean retval;

    PloverTransaction *transaction;

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

    if (!transaction)

	return FALSE;

    retval=plover_transaction_commit(transaction,NULL,error);

    g_object_unref(transaction);

    return retval;

}

gboolean plover_install(const char *base,const char *prefix,char **pkgs,

  GError **error)

{

    gboolean retval;

    GFile *file;

    gchar *base_uri;

    file=g_file_new_for_path(base);

    base_uri=g_file_get_uri(file);

    g_object_unref(file);

    retval=plover_install_uri(base_uri,prefix,pkgs,error);

    g_free(base_uri);

    return retval;

}

gboolean plover_update(const char *base,const char *prefix,char **pkgs,

  GError **error)

{

    gboolean retval;

    GError *tmp_error=NULL;

    PloverTransaction *transaction;

    transaction=plover_transaction_new_update(base,prefix,pkgs,&tmp_error);

    if (!transaction)

    {

	retval=g_error_matches(tmp_error,PLOVER_POSIX_ERROR,ENOENT);

	if (retval)

	    g_error_free(tmp_error);

	else

	    g_propagate_error(error,tmp_error);

    }

    else

    {

	retval=plover_transaction_commit(transaction,NULL,error);

	g_object_unref(transaction);

    }

    return retval;

}

gboolean plover_remove(char **pkgs,GError **error)

{

    gboolean retval;

    GError *tmp_error=NULL;

    PloverTransaction *transaction;

    transaction=plover_transaction_new_remove(pkgs,&tmp_error);

    if (!transaction)

    {

	retval=g_error_matches(tmp_error,PLOVER_POSIX_ERROR,ENOENT);

	if (retval)

	{

	    g_error_free(tmp_error);

	    if (pkgs)

	    {

		g_set_error(error,PLOVER_GENERAL_ERROR,

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

		  "Package not found");

		retval=FALSE;

	    }

	}

	else

	    g_propagate_error(error,tmp_error);

    }

    else

    {

	retval=plover_transaction_commit(transaction,NULL,error);

	g_object_unref(transaction);

    }

    return retval;

}

/*

 * Note: If there are no installed files, then any prefix will match.

 */

int plover_installed_files_match_prefix(const char *prefix)

{

    int len,matches=1;

    const char *name;

    const char *install_root;

    struct razor_set *set;

    struct razor_package *package;

    struct razor_package_iterator *pi;

    struct razor_file_iterator *fi;

    plover__uri_handler_init();

    len=strlen(prefix);

    while(len && prefix[len-1]=='/')

	len--;

    install_root=g_getenv("RAZOR_ROOT");

    if (!install_root)

	install_root="file:///";

    set=razor_root_open_read_only(install_root,NULL);

    if (!set)

	g_message("Failed to open root");

    if (set)

    {

	pi=razor_package_iterator_create(set);

	while (matches &&

	  razor_package_iterator_next(pi,&package,RAZOR_DETAIL_LAST))

	{

	    fi=razor_file_iterator_create(set,package,0);

	    while (matches && razor_file_iterator_next(fi,&name))

	    {

		if (strncmp(name,prefix,len) ||

		  name[len]!='\0' && name[len]!='/')

		    matches=0;

	    }

	    razor_file_iterator_destroy(fi);

	}

	razor_package_iterator_destroy(pi);

	razor_set_unref(set);

    }

    return matches;

}