/*

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

  * Copyright (C) 2008  Red Hat, Inc

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

 #include <razor.h>

 #include "config.h"

 #include "plover/plover.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 plover_strconcat(name,"-",v,".",arch,".rpm",NULL);

 }

 struct razor_set *plover_relocate_packages(struct razor_set *set,

   struct razor_atomic *atomic,const char *base,

   struct razor_relocations *relocations)

 {

     struct razor_importer *importer;

     struct razor_property_iterator *prop_iter;

     struct razor_package_iterator *pkg_iter;

     struct razor_file_iterator *file_iter;

     struct razor_package *package;

     struct razor_property *property;

     struct razor_rpm *rpm;

     struct razor_set *new;

     const char *name,*version,*arch,*summary,*desc,*url,*license;

     char *s,*file;

     uint32_t flags;

     importer=razor_importer_create();

     pkg_iter=razor_package_iterator_create(set);

     while (razor_package_iterator_next(pkg_iter,&package,RAZOR_DETAIL_NAME,

       &name,RAZOR_DETAIL_VERSION,&version,RAZOR_DETAIL_ARCH,&arch,

       RAZOR_DETAIL_SUMMARY,&summary,RAZOR_DETAIL_DESCRIPTION,&desc,

       RAZOR_DETAIL_URL,&url,RAZOR_DETAIL_LICENSE,&license,RAZOR_DETAIL_LAST))

     {

 	s=rpm_filename(name,version,arch);

 	file=plover_strconcat(base,"/rpms/",s,NULL);

 	free(s);

 	rpm=razor_rpm_open(file,atomic);

 	free(file);

 	if (!rpm)

 	{

 	    razor_package_iterator_destroy(pkg_iter);

 	    razor_importer_destroy(importer);

 	    return NULL;

 	}

 	razor_relocations_set_rpm(relocations,rpm);

 	razor_rpm_close(rpm);

 	razor_importer_begin_package(importer,name,version,arch);

 	razor_importer_add_details(importer,summary,desc,url,license);

 	prop_iter=razor_property_iterator_create(set,package);

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

 	  &version))

 	    razor_importer_add_property(importer,name,flags,version);

 	razor_property_iterator_destroy(prop_iter);

 	file_iter=razor_file_iterator_create(set,package,0);

 	while (razor_file_iterator_next(file_iter,&name))

 	{

 	    name=razor_relocations_apply(relocations,name);

 	    razor_importer_add_file(importer,name);

 	}

 	razor_file_iterator_destroy(file_iter);

 	razor_importer_finish_package(importer);

     }

     razor_package_iterator_destroy(pkg_iter);

     new=razor_importer_finish(importer);

     if (new)

 	razor_set_set_header_version(new,razor_set_get_header_version(set));

     return new;

 }

 int plover_run_transaction(struct razor_transaction *trans,

   struct razor_install_iterator *ii,const char *base,const char *install_root,

   struct razor_set *system,struct razor_set *next,struct razor_atomic *atomic,

   struct razor_relocations *relocations,enum razor_stage_type stage)

 {

     struct razor_package *package;

     enum razor_install_action action;

     struct razor_rpm *rpm;

     const char *name,*version,*arch;

     char *s,*file;

     int count;

     razor_install_iterator_rewind(ii);

     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,&package,&action,&count))

     {

 	if (action==RAZOR_INSTALL_ACTION_REMOVE)

 	{

 	    razor_package_get_details(system,package,RAZOR_DETAIL_NAME,&name,

 	      RAZOR_DETAIL_LAST);

 	    if (stage==RAZOR_STAGE_FILES)

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

 	    razor_package_remove(system,next,atomic,package,install_root,

 	      count,stage);

 	    if (stage==RAZOR_STAGE_FILES)

 		printf("\n");

 	}

 	else

 	{

 	    razor_package_get_details(next,package,RAZOR_DETAIL_NAME,&name,

 	      RAZOR_DETAIL_VERSION,&version,RAZOR_DETAIL_ARCH,&arch,

 	      RAZOR_DETAIL_LAST);

 	    s=rpm_filename(name,version,arch);

 	    file=plover_strconcat(base,"/rpms/",s,NULL);

 	    free(s);

 	    rpm=razor_rpm_open(file,atomic);

 	    free(file);

 	    if (!rpm)

 		return -1;

 	    if (stage==RAZOR_STAGE_FILES)

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

 	    if (relocations)

 		razor_rpm_set_relocations(rpm,relocations);

 	    razor_transaction_fixup_package(trans,package,rpm);

 	    razor_rpm_install(rpm,atomic,install_root,1,stage);

 	    razor_rpm_close(rpm);

 	    if (stage==RAZOR_STAGE_FILES)

 		printf("\n");

 	}

 	if (razor_atomic_in_error_state(atomic))

 	    return -1;

     }

     return 0;

 }

 /*

  * Note: plover_commit_transaction() takes ownership of root which should

  * not be used after it returns.

  */

 int plover_commit_transaction(struct razor_transaction *trans,const char *base,

   const char *install_root,struct razor_root *root,struct razor_atomic *atomic,

   struct razor_relocations *relocations)

 {

     int retval;

     struct razor_set *next,*system;

     struct razor_install_iterator *ii;

     razor_transaction_resolve(trans);

     if (razor_transaction_describe(trans)>0)

     {

 	razor_root_close(root);

 	return -1;

     }

     next=razor_transaction_commit(trans);

     system=razor_root_get_system_set(root);

     ii=razor_set_create_install_iterator(system,next);

     plover_run_transaction(trans,ii,base,install_root,system,next,atomic,

       relocations,RAZOR_STAGE_SCRIPTS_PRE);

     plover_run_transaction(trans,ii,base,install_root,system,next,atomic,

       relocations,RAZOR_STAGE_FILES);

     razor_root_update(root,next);

     razor_root_commit(root);

     retval=razor_atomic_commit(atomic);

     if (!retval)

 	plover_run_transaction(trans,ii,base,install_root,system,next,atomic,

 	  relocations,RAZOR_STAGE_SCRIPTS_POST);

     razor_set_unref(next);

     razor_install_iterator_destroy(ii);

     return retval;

 }

 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;

 }

 int plover_install(const char *base,const char *prefix,char **pkgs)

 {

     int i,retval;

     char *s;

     char *install_root;

     struct razor_root *root;

     struct razor_set *system,*set,*upstream;

     struct razor_transaction *trans;

     struct razor_relocations *relocations;

     struct razor_atomic *atomic;

     install_root=getenv("RAZOR_ROOT");

     if (!install_root)

 	install_root="";

     if (prefix)

     {

 	relocations=razor_relocations_create();

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

     }

     else

 	relocations=NULL;

     atomic=razor_atomic_open("Install packages");

     /*

      * Calling razor_root_open() on a system that hasn't yet had

      * razor_root_create() run generates a confusing error message

      * on stderr. Avoid this by trying to open it R/O first which

      * fails without generating any error.

      */

     set=razor_root_open_read_only(install_root,atomic);

     if (set)

 	razor_set_unref(set);

     else

 	razor_root_create(install_root);

     root=razor_root_open(install_root,atomic);

     if (!root)

     {

 	fprintf(stderr,"%s\n",razor_atomic_get_error_msg(atomic));

 	razor_atomic_destroy(atomic);

 	if (relocations)

 	    razor_relocations_destroy(relocations);

 	return -1;

     }

     system=razor_root_get_system_set(root);

     if (!system)

     {

 	fprintf(stderr,"%s\n",razor_atomic_get_error_msg(atomic));

 	razor_root_close(root);

 	razor_atomic_destroy(atomic);

 	if (relocations)

 	    razor_relocations_destroy(relocations);

 	return -1;

     }

     s=plover_strconcat(base,"/repodata",NULL);

     if (s)

     {

 	retval=chdir(s);

 	if (retval<0)

 	    perror(s);

     }

     else

 	retval=-1;

     free(s);

     if (retval<0)

     {

 	fprintf(stderr,"%s\n",razor_atomic_get_error_msg(atomic));

 	razor_root_close(root);

 	razor_atomic_destroy(atomic);

 	if (relocations)

 	    razor_relocations_destroy(relocations);

 	return -1;

     }

     set=plover_razor_set_create_from_yum(base);

     if (set)

     {

 	upstream=plover_relocate_packages(set,atomic,base,relocations);

 	razor_set_unref(set);

     }

     else

 	upstream=NULL;

     if (!upstream)

     {

 	fprintf(stderr,"%s\n",razor_atomic_get_error_msg(atomic));

 	razor_root_close(root);

 	razor_atomic_destroy(atomic);

 	if (relocations)

 	    razor_relocations_destroy(relocations);

 	return -1;

     }

     trans=razor_transaction_create(system,upstream);

     razor_set_unref(upstream);

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

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

 	  plover_mark_package_for_update(trans,upstream,pkgs[i]))

 	{

 	    fprintf(stderr,"%s: Package not found\n",pkgs[i]);

 	    retval=-1;

 	    break;

 	}

     if (!retval)

     {

 	retval=plover_commit_transaction(trans,base,install_root,root,atomic,

 	  relocations);

 	if (retval)

 	    fprintf(stderr,"%s\n",razor_atomic_get_error_msg(atomic));

     }

     else

 	razor_root_close(root);

     razor_transaction_destroy(trans);

     razor_atomic_destroy(atomic);

     if (relocations)

 	razor_relocations_destroy(relocations);

     return retval;

 }

 int plover_update(const char *base,const char *prefix,char **pkgs)

 {

     int i,retval;

     char *install_root,*s;

     struct razor_root *root;

     struct razor_set *system,*set,*upstream;

     struct razor_transaction *trans;

     struct razor_relocations *relocations;

     struct razor_atomic *atomic;

     install_root=getenv("RAZOR_ROOT");

     if (!install_root)

 	install_root="";

     if (prefix)

     {

 	relocations=razor_relocations_create();

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

     }

     else

 	relocations=NULL;

     atomic=razor_atomic_open("Update packages");

     set=razor_root_open_read_only(install_root,atomic);

     if (!set)

     {

 	fprintf(stderr,"%s\n",razor_atomic_get_error_msg(atomic));

 	razor_atomic_destroy(atomic);

 	if (relocations)

 	    razor_relocations_destroy(relocations);

 	return 0;

     }

     razor_set_unref(set);

     root=razor_root_open(install_root,atomic);

     if (!root)

     {

 	fprintf(stderr,"%s\n",razor_atomic_get_error_msg(atomic));

 	razor_atomic_destroy(atomic);

 	if (relocations)

 	    razor_relocations_destroy(relocations);

 	return -1;

     }

     system=razor_root_get_system_set(root);

     if (!system)

     {

 	fprintf(stderr,"%s\n",razor_atomic_get_error_msg(atomic));

 	razor_root_close(root);

 	razor_atomic_destroy(atomic);

 	if (relocations)

 	    razor_relocations_destroy(relocations);

 	return -1;

     }

     s=plover_strconcat(base,"/repodata",NULL);

     if (s)

     {

 	retval=chdir(s);

 	if (retval)

 	    perror(s);

     }

     else

 	retval=-1;

     free(s);

     if (retval)

     {

 	fprintf(stderr,"%s\n",razor_atomic_get_error_msg(atomic));

 	razor_root_close(root);

 	razor_atomic_destroy(atomic);

 	if (relocations)

 	    razor_relocations_destroy(relocations);

 	return -1;

     }

     set=plover_razor_set_create_from_yum(base);

     if (set)

     {

 	upstream=plover_relocate_packages(set,atomic,base,relocations);

 	razor_set_unref(set);

     }

     else

 	upstream=NULL;

     if (!upstream)

     {

 	fprintf(stderr,"%s\n",razor_atomic_get_error_msg(atomic));

 	razor_root_close(root);

 	razor_atomic_destroy(atomic);

 	if (relocations)

 	    razor_relocations_destroy(relocations);

 	return -1;

     }

     trans=razor_transaction_create(system,upstream);

     razor_set_unref(upstream);

     if (pkgs)

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

 	{

 	    if (plover_mark_package_for_update(trans,system,pkgs[i]))

 	    {

 		fprintf(stderr,"%s: Package not found\n",pkgs[i]);

 		retval=-1;

 		break;

 	    }

 	}

     else

 	razor_transaction_update_all(trans);

     if (!retval) {

 	retval=plover_commit_transaction(trans,base,install_root,root,atomic,

 	  relocations);

 	if (retval)

 	    fprintf(stderr,"%s\n",razor_atomic_get_error_msg(atomic));

     }

     else

 	razor_root_close(root);

     razor_transaction_destroy(trans);

     if (relocations)

 	razor_relocations_destroy(relocations);

     razor_atomic_destroy(atomic);

     return retval;

 }

 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;

 }

 int plover_remove(char **pkgs)

 {

     int i,retval=0;

     char *install_root;

     struct razor_root *root;

     struct razor_set *system,*set,*upstream;

     struct razor_transaction *trans;

     struct razor_atomic *atomic;

     install_root=getenv("RAZOR_ROOT");

     if (!install_root)

 	install_root="";

     atomic=razor_atomic_open("Remove packages");

     set=razor_root_open_read_only(install_root,atomic);

     if (!set)

     {

 	fprintf(stderr,"%s\n",razor_atomic_get_error_msg(atomic));

 	razor_atomic_destroy(atomic);

 	return 0;

     }

     razor_set_unref(set);

     root=razor_root_open(install_root,atomic);

     if (!root)

     {

 	fprintf(stderr,"%s\n",razor_atomic_get_error_msg(atomic));

 	razor_atomic_destroy(atomic);

 	return -1;

     }

     system=razor_root_get_system_set(root);

     if (!system)

     {

 	fprintf(stderr,"%s\n",razor_atomic_get_error_msg(atomic));

 	razor_root_close(root);

 	razor_atomic_destroy(atomic);

 	return -1;

     }

     upstream=razor_set_create_without_root();

     trans=razor_transaction_create(system,upstream);

     razor_set_unref(upstream);

     if (pkgs)

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

 	{

 	    if (plover_mark_packages_for_removal(trans,system,pkgs[i]))

 	    {

 		fprintf(stderr,"%s: Package not found\n",pkgs[i]);

 		retval=-1;

 		break;

 	    }

 	}

     else

 	plover_mark_packages_for_removal(trans,system,NULL);

     if (!retval)

     {

 	retval=

 	  plover_commit_transaction(trans,NULL,install_root,root,atomic,NULL);

 	if (retval)

 	    fprintf(stderr,"%s\n",razor_atomic_get_error_msg(atomic));

     }

     else

 	razor_root_close(root);

     razor_transaction_destroy(trans);

     razor_atomic_destroy(atomic);

     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;

     char *install_root;

     struct razor_set *set;

     struct razor_atomic *atomic;

     struct razor_package *package;

     struct razor_package_iterator *pi;

     struct razor_file_iterator *fi;

     len=strlen(prefix);

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

 	len--;

     install_root=getenv("RAZOR_ROOT");

     if (!install_root)

 	install_root="";

     atomic=razor_atomic_open("Query packages");

     set=razor_root_open_read_only(install_root,atomic);

     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);

     }

     razor_atomic_destroy(atomic);

     return matches;

 }