/*

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

  * Copyright (C) 2008  Red Hat, Inc

  * Copyright (C) 2009  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,

   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;

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

 	if (!rpm)

 	{

 	    fprintf(stderr,"failed to open rpm %s\n",file);

 	    razor_package_iterator_destroy(pkg_iter);

 	    razor_importer_destroy(importer);

 	    free(file);

 	    return NULL;

 	}

 	free(file);

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

     return razor_importer_finish(importer);

 }

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

   const char *install_root,struct razor_set *system,struct razor_set *next,

   struct razor_relocations *relocations)

 {

     struct razor_install_iterator *ii;

     struct razor_package *package;

     struct razor_set *set;

     enum razor_install_action action;

     struct razor_rpm *rpm;

     const char *name,*version,*arch;

     char *s,*file;

     int count;

     ii=razor_set_create_install_iterator(system,next);

     printf("Running Transaction\n");

     while (razor_install_iterator_next(ii,&set,&package,&action,&count))

     {

 	if (action==RAZOR_INSTALL_ACTION_REMOVE)

 	{

 	    razor_package_get_details(set,package,RAZOR_DETAIL_NAME,&name,

 	      RAZOR_DETAIL_LAST);

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

 	    if (razor_package_remove(set,package,install_root,0)<0)

 		printf(

 		  "\nWarning: one or more errors occurred while removing %s",

 		  name);

 	    printf("\n");

 	}

 	else

 	{

 	    razor_package_get_details(set,package,RAZOR_DETAIL_NAME,&name,

 	      RAZOR_DETAIL_VERSION,&version,RAZOR_DETAIL_ARCH,&arch,

 	      RAZOR_DETAIL_LAST);

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

 	    s=rpm_filename(name,version,arch);

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

 	    free(s);

 	    rpm=razor_rpm_open(file);

 	    if (!rpm)

 	    {

 		fprintf(stderr,"failed to open rpm %s\n",file);

 		free(file);

 		razor_install_iterator_destroy(ii);

 		return -1;

 	    }

 	    if (relocations)

 		razor_rpm_set_relocations(rpm,relocations);

 	    razor_transaction_fixup_package(trans,package,rpm);

 	    if (razor_rpm_install(rpm,install_root,1)<0)

 	    {

 		fprintf(stderr,"failed to install rpm %s\n",file);

 		razor_rpm_close(rpm);

 		free(file);

 		razor_install_iterator_destroy(ii);

 		return -1;

 	    }

 	    razor_rpm_close(rpm);

 	    free(file);

 	    printf("\n");

 	}

     }

     razor_install_iterator_destroy(ii);

     return 0;

 }

 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;

     char *s;

     char *install_root;

     struct razor_root *root;

     struct razor_set *system,*set,*upstream,*next;

     struct razor_transaction *trans;

     struct razor_relocations *relocations;

     install_root=getenv("RAZOR_ROOT");

     if (!install_root)

 	install_root="";

     if (prefix)

     {

 	relocations=razor_relocations_create();

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

     }

     /*

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

     if (set)

 	razor_set_destroy(set);

     else

 	razor_root_create(install_root);

     root=razor_root_open(install_root);

     if (!root)

 	return -1;

     system=razor_root_get_system_set(root);

     if (!system)

     {

 	razor_root_close(root);

 	return -1;

     }

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

     if (!s)

     {

 	razor_root_close(root);

 	return -1;

     }

     if (chdir(s)<0)

     {

 	perror(s);

 	free(s);

 	razor_root_close(root);

 	return -1;

     }

     free(s);

     set=plover_razor_set_create_from_yum(base);

     if (!set)

     {

 	razor_root_close(root);

 	return -1;

     }

     upstream=plover_relocate_packages(set,base,relocations);

     razor_set_destroy(set);

     trans=razor_transaction_create(system,upstream);

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

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

 	{

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

 	    razor_root_close(root);

 	    return -1;

 	}

     razor_transaction_resolve(trans);

     if (razor_transaction_describe(trans)>0)

     {

 	razor_root_close(root);

 	return -1;

     }

     next=razor_transaction_commit(trans);

     plover_run_transaction(trans,base,install_root,system,next,relocations);

     razor_root_update(root,next);

     razor_transaction_destroy(trans);

     razor_set_destroy(next);

     razor_set_destroy(upstream);

     if (prefix)

 	razor_relocations_destroy(relocations);

     return razor_root_commit(root);

 }

 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;

     char *install_root;

     struct razor_root *root;

     struct razor_set *system,*set,*upstream,*next;

     struct razor_transaction *trans;

     install_root=getenv("RAZOR_ROOT");

     if (!install_root)

 	install_root="";

     set=razor_root_open_read_only(install_root);

     if (!set)

 	return 0;

     razor_set_destroy(set);

     root=razor_root_open(install_root);

     if (!root)

 	return -1;

     system=razor_root_get_system_set(root);

     if (!system)

     {

 	razor_root_close(root);

 	return -1;

     }

     upstream=razor_set_create_without_root();

     trans=razor_transaction_create(system,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]);

 		razor_transaction_destroy(trans);

 		razor_set_destroy(upstream);

 		razor_set_destroy(system);

 		razor_root_close(root);

 		return -1;

 	    }

 	}

     else

 	plover_mark_packages_for_removal(trans,system,NULL);

     razor_transaction_resolve(trans);

     if (razor_transaction_describe(trans)>0)

     {

 	razor_transaction_destroy(trans);

 	razor_set_destroy(upstream);

 	razor_set_destroy(system);

 	razor_root_close(root);

 	return -1;

     }

     next=razor_transaction_commit(trans);

     plover_run_transaction(trans,NULL,install_root,system,next,NULL);

     razor_root_update(root,next);

     razor_transaction_destroy(trans);

     razor_set_destroy(next);

     razor_set_destroy(upstream);

     return razor_root_commit(root);

 }