/*

 * Copyright (C) 2010-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 "config.h"

#include <stdlib.h>

#include <string.h>

#include <fcntl.h>

#include <errno.h>

#include <unistd.h>

#include <glib-object.h>

#include <razor.h>

#include "plover/plover.h"

#include "plover/package.h"

#include "plover/packageset.h"

G_DEFINE_TYPE(PloverPackageSet,plover_package_set,G_TYPE_OBJECT);

typedef struct _PloverPackageSetPrivate {

    gchar *install_root;

    struct razor_root *root;

    struct razor_set *set;

    GSList *packages;

    int no_details;

    gchar *guessed_prefix;

} PloverPackageSetPrivate;

#define PLOVER_PACKAGE_SET_GET_PRIVATE(obj)\

				G_TYPE_INSTANCE_GET_PRIVATE(obj,\

				  PLOVER_TYPE_PACKAGE_SET,\

				  PloverPackageSetPrivate)

enum {

    CHANGED=0,

    N_SIGNALS

};

static guint signals[N_SIGNALS];

static void plover_package_set_finalize(GObject *obj)

{

    PloverPackageSetPrivate *priv=PLOVER_PACKAGE_SET_GET_PRIVATE(obj);

    g_free(priv->guessed_prefix);

    G_OBJECT_CLASS(plover_package_set_parent_class)->finalize(obj);

}

static void plover_package_set_dispose(GObject *obj)

{

    PloverPackageSetPrivate *priv=PLOVER_PACKAGE_SET_GET_PRIVATE(obj);

    if (priv->set)

    {

	razor_set_unref(priv->set);

	priv->set=NULL;

    }

    if (priv->root)

    {

	g_free(priv->install_root);

	priv->install_root=NULL;

	razor_root_close(priv->root);

	priv->root=NULL;

    }

    G_OBJECT_CLASS(plover_package_set_parent_class)->dispose(obj);

}

static void plover_package_set_class_init(PloverPackageSetClass *klass)

{

    GObjectClass *oclass=G_OBJECT_CLASS(klass);

    oclass->finalize=plover_package_set_finalize;

    oclass->dispose=plover_package_set_dispose;

    g_type_class_add_private(klass,sizeof(PloverPackageSetPrivate));

    signals[CHANGED]=g_signal_newv("changed",

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

      g_cclosure_marshal_VOID__VOID,G_TYPE_NONE,0,NULL);

}

static void plover_package_set_init(PloverPackageSet *set)

{

    PloverPackageSetPrivate *priv;

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    priv->no_details=-1;

}

PloverPackageSet *plover_package_set_new(void)

{

    return g_object_new(PLOVER_TYPE_PACKAGE_SET,NULL);

}

void plover_package_set_close(PloverPackageSet *set)

{

    PloverPackageSetPrivate *priv;

    g_return_if_fail(PLOVER_IS_PACKAGE_SET(set));

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    if (priv->root)

    {

	razor_root_close(priv->root);

	priv->root=NULL;

    }

}

gboolean plover_package_set_open(PloverPackageSet *set,const char *install_root,

  gboolean exclusive,GError **err)

{

    struct razor_root *root=NULL;

    struct razor_set *system=NULL;

    PloverPackageSetPrivate *priv;

    struct razor_error *error=NULL;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),FALSE);

    if (exclusive)

    {

	root=razor_root_open(install_root,NULL);

	if (!root)

	{

	    if (razor_root_create(install_root,&error))

	    {

		if (razor_error_get_domain(error)==RAZOR_GENERAL_ERROR &&

		  razor_error_get_code(error)==

		  RAZOR_GENERAL_ERROR_DATABASE_EXISTS)

		{

		    razor_error_free(error);

		    error=NULL;

		    root=razor_root_open(install_root,&error);

		}                             

	    }

	    else

		root=razor_root_open(install_root,&error);

	    if (!root)                        

	    {

		plover_propagate_razor_error(err,error);

		return FALSE;

	    }

	}

	system=razor_root_get_system_set(root);

	if (system)

	    razor_set_ref(system);

    }

    else

	system=razor_root_open_read_only(install_root,&error);

    if (error)

    {

	g_set_error_literal(err,PLOVER_RAZOR_ERROR,RAZOR_GENERAL_ERROR_FAILED,

	  razor_error_get_msg(error));

	razor_error_free(error);

	return FALSE;

    }

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    if (priv->set)

    {

	razor_set_unref(priv->set);

	priv->set=NULL;

    }

    if (priv->root)

    {

	razor_root_close(priv->root);

	priv->root=NULL;

    }

    g_free(priv->install_root);

    priv->install_root=g_strdup(install_root);

    priv->root=root;

    priv->set=system;

    return TRUE;

}

const char *plover_package_set_get_install_root(PloverPackageSet *set)

{

    PloverPackageSetPrivate *priv;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),NULL);

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    return priv->install_root;

}

gboolean plover_package_set_get_exclusive(PloverPackageSet *set)

{

    PloverPackageSetPrivate *priv;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),FALSE);

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    return !!priv->root;

}

gboolean plover_package_set_update(PloverPackageSet *set,struct razor_set *next,

  struct razor_atomic *atomic)

{

    gboolean retval;

    PloverPackageSetPrivate *priv;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),FALSE);

    g_return_val_if_fail(plover_package_set_get_exclusive(set) != FALSE,FALSE);

    g_return_val_if_fail(next != NULL,FALSE);

    g_return_val_if_fail(atomic != NULL,FALSE);

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    retval=!razor_root_update(priv->root,next,atomic);

    if (retval)

    {

	razor_set_unref(priv->set);

	priv->set=razor_root_get_system_set(priv->root);

	if (priv->set)

	    razor_set_ref(priv->set);

    }

    return retval;

}

PloverPackageSet *plover_package_set_new_from_installed(const char *root,

  GError **err)

{

    PloverPackageSet *set;

    set=plover_package_set_new();

    if (!plover_package_set_open(set,root,FALSE,err))

    {

	g_object_unref(set);

	return NULL;

    }

    return set;

}

PloverPackageSet *plover_package_set_new_from_razor(struct razor_set *razor)

{

    PloverPackageSet *set;

    PloverPackageSetPrivate *priv;

    g_return_val_if_fail(razor != NULL,NULL);

    set=plover_package_set_new();

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    priv->set=razor;

    razor_set_ref(priv->set);

    return set;

}

static gboolean

  plover_package_set_import_package(PloverRepository *repository,

  struct razor_relocations *relocations,struct razor_importer *importer,

  PloverPackage *package,GError **error)

{

    int i;

    struct razor_property_iterator *prop_iter;

    struct razor_file_iterator *file_iter;

    struct razor_rpm *rpm;

    struct razor_property *prop;

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

    const char *install_prefix;

    const char *const *prefixes;

    uint32_t flags;

    rpm=plover_repository_open_rpm(repository,package,error);

    if (!rpm)

	return FALSE;

    razor_relocations_set_rpm(relocations,rpm);

    name=plover_package_get_name(package);

    version=plover_package_get_version(package);

    arch=plover_package_get_arch(package);

    razor_importer_begin_package(importer,name,version,arch);

    summary=plover_package_get_summary(package);

    desc=plover_package_get_description(package);

    url=plover_package_get_URL(package);

    license=plover_package_get_license(package);

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

    razor_rpm_get_details(rpm,RAZOR_DETAIL_PREFIXES,&prefixes,

      RAZOR_DETAIL_LAST);

    for(i=0;prefixes && prefixes[i];i++)

    {

	install_prefix=razor_relocations_apply(relocations,prefixes[i]);

	razor_importer_add_install_prefix(importer,install_prefix);

    }

    razor_rpm_close(rpm);

    prop_iter=plover_package_property_iterator_create(package);

    while (razor_property_iterator_next(prop_iter,&prop,&name,&flags,&version))

	razor_importer_add_property(importer,name,flags,version);

    razor_property_iterator_destroy(prop_iter);

    file_iter=plover_package_file_iterator_create(package,FALSE);

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

    return TRUE;

}

PloverPackageSet *

  plover_package_set_new_from_repository(PloverRepository *repository,

  struct razor_relocations *relocations,GError **error)

{

    struct razor_importer *importer;

    uint32_t header_version;

    GSList *packages,*lnk;

    PloverPackageSet *unrelocated,*set;

    PloverPackageSetPrivate *priv;

    PloverPackage *package;

    g_return_val_if_fail(PLOVER_IS_REPOSITORY(repository),NULL);

    unrelocated=plover_repository_get_package_set(repository);

    set=plover_package_set_new();

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    if (relocations)

    {

	importer=razor_importer_create();

	packages=plover_package_set_get_packages(unrelocated);

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

	{

	    package=lnk->data;

	    if (!plover_package_set_import_package(repository,relocations,

	      importer,package,error))

	    {

		razor_importer_destroy(importer);

		g_object_unref(set);

		return NULL;

	    }

	}

	priv->set=razor_importer_finish(importer);

	if (!priv->set)

	{

	    g_object_unref(set);

	    return NULL;

	}

	header_version=plover_package_set_get_header_version(unrelocated);

	if (header_version)

	    plover_package_set_set_header_version(set,header_version);

    }

    else

    {

	priv->set=plover_package_set_get_razor(unrelocated);

	razor_set_ref(priv->set);

    }

    return set;

}

PloverPackageSet *plover_package_set_new_from_yum(const char *base,

  struct razor_relocations *relocations,GError **error)

{

    PloverPackageSet *set;

    PloverRepository *repository;

    repository=plover_repository_new_from_yum(base,error);

    if (!repository)

	return NULL;

    set=plover_package_set_new_from_repository(repository,relocations,error);

    g_object_unref(repository);

    return set;

}

PloverPackageSet *plover_package_set_new_from_rpms(const char **filenames,

  GError **error)

{

    int i;

    PloverPackageSet *set;

    PloverPackageSetPrivate *priv;

    struct razor_importer *importer;

    struct razor_rpm *rpm;

    struct razor_error *tmp_error=NULL;

    importer=razor_importer_create();

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

    {

	rpm=razor_rpm_open(filenames[i],&tmp_error);

	if (!rpm)

	{

	    razor_importer_destroy(importer);

	    plover_propagate_razor_error(error,tmp_error);

	    return NULL;

	}

	if (razor_importer_add_rpm(importer,rpm))

	{

	    g_set_error(error,PLOVER_RAZOR_ERROR,RAZOR_GENERAL_ERROR_FAILED,

	      "%s: failed to import",filenames[i]);

	    razor_importer_destroy(importer);

	    return NULL;

	}

	razor_rpm_close(rpm);

    }

    set=plover_package_set_new();

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    priv->set=razor_importer_finish(importer);

    return set;

}

uint32_t plover_package_set_get_header_version(PloverPackageSet *set)

{

    PloverPackageSetPrivate *priv;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),0);

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    if (priv->set)

	return razor_set_get_header_version(priv->set);

    else

	return 0;

}

gboolean plover_package_set_set_header_version(PloverPackageSet *set,

  uint32_t header_version)

{

    PloverPackageSetPrivate *priv;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),FALSE);

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    if (priv->set)

	return !razor_set_set_header_version(priv->set,header_version);

    else

	return FALSE;

}

struct razor_set *plover_package_set_get_razor(PloverPackageSet *set)

{

    PloverPackageSetPrivate *priv;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),NULL);

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    return priv->set;

}

GSList *plover_package_set_get_packages(PloverPackageSet *set)

{

    struct razor_package_iterator *iter;

    struct razor_package *pkg;

    PloverPackageSetPrivate *priv;

    PloverPackage *package;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),NULL);

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    if (priv->set && !priv->packages)

    {

	iter=razor_package_iterator_create(priv->set);

	while(razor_package_iterator_next(iter,&pkg,RAZOR_DETAIL_LAST))

	{

	    package=plover_package_new(priv->set,pkg);

	    priv->packages=g_slist_prepend(priv->packages,package);

	}

	razor_package_iterator_destroy(iter);

	priv->packages=g_slist_reverse(priv->packages);

    }

    return priv->packages;

}

PloverPackage *plover_package_set_lookup(PloverPackageSet *set,

  struct razor_package *razor_package)

{

    GSList *packages,*lnk;

    PloverPackage *package;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),NULL);

    packages=plover_package_set_get_packages(set);

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

    {

	package=lnk->data;

	if (plover_package_get_razor_package(package)==razor_package)

	    return package;

    }

    return NULL;

}

PloverPackage *plover_package_set_find_custom(PloverPackageSet *set,

  gconstpointer data,GCompareFunc func)

{

    GSList *packages,*lnk;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),NULL);

    packages=plover_package_set_get_packages(set);

    lnk=g_slist_find_custom(packages,data,func);

    return lnk?lnk->data:NULL;

}

static gint plover_package_set_compare(gconstpointer a,gconstpointer b)

{

    PloverPackage *pa=(void *)a,*pb=(void *)b;

    const char *sa,*sb;

    sa=plover_package_get_name(pa);

    sb=plover_package_get_name(pb);

    if (g_strcmp0(sa,sb))

	return 1;

    sa=plover_package_get_arch(pa);

    sb=plover_package_get_arch(pb);

    if (g_strcmp0(sa,sb))

	return 1;

    sa=plover_package_get_version(pa);

    sb=plover_package_get_version(pb);

    return !!g_strcmp0(sa,sb);

}

PloverPackage *plover_package_set_find_matching(PloverPackageSet *set,

  PloverPackage *template)

{

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),NULL);

    return plover_package_set_find_custom(set,template,

      plover_package_set_compare);

}

/*

 * Some versions of razor have a bug which causes all detail strings

 * to be discarded. If such a version of razor is used to install or

 * update a package, then all the detail strings for the installed

 * set will be lost. This function tests for this condition and can

 * be used to present something more useful than blank details.

 */

gboolean plover_package_set_get_no_details(PloverPackageSet *set)

{

    PloverPackageSetPrivate *priv;

    PloverPackage *package;

    GSList *packages,*link;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),FALSE);

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    if (priv->no_details<0)

    {

	packages=plover_package_set_get_packages(set);

	if (packages)

	{

	    priv->no_details=0;

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

	    {

		package=link->data;

		priv->no_details+=2;

		if (*plover_package_get_summary(package))

		    priv->no_details--;

		if (*plover_package_get_license(package))

		    priv->no_details--;

		if (*plover_package_get_description(package))

		    priv->no_details--;

		if (*plover_package_get_URL(package))

		    priv->no_details--;

	    }

	    if (priv->no_details<0)	/* More than 50% of strings present */

		priv->no_details=0;

	}

    }

    return priv->no_details>0;

}

struct plover_package_set_prefix {

    gchar *path;

    guint count;

};

static GArray *plover_package_set_popchart_new(void)

{

    GArray *prefixes;

    prefixes=g_array_new(FALSE,FALSE,sizeof(struct plover_package_set_prefix));

    return prefixes;

}

static void plover_package_set_popchart_free(GArray *popchart)

{

    int i;

    struct plover_package_set_prefix *prefix;

    for(i=0;i<popchart->len;i++)

    {

	prefix=&g_array_index(popchart,struct plover_package_set_prefix,i);

	g_free(prefix->path);

    }

    g_array_free(popchart,TRUE);

}

static void plover_package_set_popchart_add(GArray *popchart,const char *path)

{

    int i;

    struct plover_package_set_prefix *prefix;

    for(i=popchart->len-1;i>=0;i--)

    {

	prefix=&g_array_index(popchart,struct plover_package_set_prefix,i);

	if (!strcmp(prefix->path,path))

	{

	    prefix->count++;

	    return;

	}

    }

    g_array_set_size(popchart,popchart->len+1);

    prefix=&g_array_index(popchart,struct plover_package_set_prefix,

      popchart->len-1);

    prefix->path=g_strdup(path);

    prefix->count=1;

}

static const char *plover_package_set_popchart_get_popular(GArray *popchart)

{

    int i;

    struct plover_package_set_prefix *prefix,*popular;

    if (!popchart->len)

	return NULL;

    popular=&g_array_index(popchart,struct plover_package_set_prefix,0);

    for(i=1;i<popchart->len;i++)

    {

	prefix=&g_array_index(popchart,struct plover_package_set_prefix,i);

	if (prefix->count>popular->count)

	    popular=prefix;

    }

    return popular->path;

}

static void plover_package_set_popchart_add_prefixes(PloverPackageSet *set,

  GArray *popchart)

{

    int i;

    PloverPackage *package;

    GSList *packages,*lnk;

    const char *const *prefixes;

    packages=plover_package_set_get_packages(set);

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

    {

	package=lnk->data;

	prefixes=plover_package_get_prefixes(package);

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

	    plover_package_set_popchart_add(popchart,prefixes[i]);

    }

}

static void plover_package_set_popchart_add_from_files(PloverPackageSet *set,

  GArray *popchart)

{

    int len;

    const char *name,*s;

    gchar *default_prefix,*path;

    struct razor_file_iterator *fi;

    GSList *packages,*lnk;

    PloverPackage *package;

    default_prefix=plover_default_prefix_for_vendor("");

    if (!default_prefix)

	return;

    len=strlen(default_prefix);

    packages=plover_package_set_get_packages(set);

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

    {

	package=lnk->data;

	fi=plover_package_file_iterator_create(package,FALSE);

	while (razor_file_iterator_next(fi,&name))

	{

	    if (g_str_has_prefix(name,default_prefix))

	    {

		for(s=name+len;*s;s++)

		    if (G_IS_DIR_SEPARATOR(*s))

			break;

		path=g_strndup(name,s-name);

		plover_package_set_popchart_add(popchart,path);

		g_free(path);

	    }

	}

	razor_file_iterator_destroy(fi);

    }

    g_free(default_prefix);

}

const char *plover_package_set_guess_prefix(PloverPackageSet *set,

  GError **error)

{

    GArray *popchart;

    const char *prefix;

    PloverPackageSetPrivate *priv;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),NULL);

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    if (!priv->guessed_prefix)

    {

	popchart=plover_package_set_popchart_new();

	plover_package_set_popchart_add_prefixes(set,popchart);

	prefix=plover_package_set_popchart_get_popular(popchart);

	if (prefix)

	    priv->guessed_prefix=g_strdup(prefix);

	else

	{

	    plover_package_set_popchart_add_from_files(set,popchart);

	    prefix=plover_package_set_popchart_get_popular(popchart);

	    if (prefix)

		priv->guessed_prefix=g_strdup(prefix);

	}

	plover_package_set_popchart_free(popchart);

    }

    if (!priv->guessed_prefix)

	priv->guessed_prefix=

	  plover_default_prefix_for_vendor("Acme Corporation");

    return priv->guessed_prefix;

}