/*

 * 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.

 */

#define _GNU_SOURCE

#include "config.h"

#include <stdlib.h>

#include <stddef.h>

#include <stdint.h>

#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include <ctype.h>

#include <assert.h>

#include "razor-internal.h"

#include "razor.h"

static int

provider_satisfies_requirement(struct razor_property *provider,

			       const char *provider_strings,

			       uint32_t flags,

			       const char *required)

{

	int cmp, len;

	const char *provided = &provider_strings[provider->version];

	if (!*required)

		return 1;

	if (!*provided) {

		if (flags & RAZOR_PROPERTY_LESS)

			return 0;

		else

			return 1;

	}

	cmp = razor_versioncmp(provided, required);

	switch (flags & RAZOR_PROPERTY_RELATION_MASK) {

	case RAZOR_PROPERTY_LESS:

		return cmp < 0;

	case RAZOR_PROPERTY_LESS | RAZOR_PROPERTY_EQUAL:

		if (cmp <= 0)

			return 1;

		/* fall through: FIXME, make sure this is correct */

	case RAZOR_PROPERTY_EQUAL:

		if (cmp == 0)

			return 1;

		/* "foo == 1.1" is satisfied by "foo 1.1-2" */

		len = strlen(required);

		if (!strncmp(required, provided, len) && provided[len] == '-')

			return 1;

		return 0;

	case RAZOR_PROPERTY_GREATER | RAZOR_PROPERTY_EQUAL:

		return cmp >= 0;

	case RAZOR_PROPERTY_GREATER:

		return cmp > 0;

	}

	/* shouldn't happen */

	return 0;

}

#define TRANS_PACKAGE_PRESENT		1

#define TRANS_PACKAGE_UPDATE		2

#define TRANS_PROPERTY_SATISFIED	0x80000000

struct transaction_set {

	struct razor_set *set;

	uint32_t *packages;

	uint32_t *properties;

};

struct razor_transaction {

	int package_count, errors;

	struct transaction_set system, upstream;

	int changes;

	struct razor_merger *merger;

};

static void

transaction_set_init(struct transaction_set *ts, struct razor_set *set)

{

	int count;

	ts->set = razor_set_ref(set);

	count = set->packages.size / sizeof (struct razor_package);

	ts->packages = zalloc(count * sizeof *ts->packages);

	count = set->properties.size / sizeof (struct razor_property);

	ts->properties = zalloc(count * sizeof *ts->properties);

}

static void

transaction_set_release(struct transaction_set *ts)

{

	razor_set_unref(ts->set);

	free(ts->packages);

	free(ts->properties);

}

static void

transaction_set_install_package(struct transaction_set *ts,

				struct razor_package *package)

{

	struct razor_package *pkgs;

	struct list *prop;

	int i;

	pkgs = ts->set->packages.data;

	i = package - pkgs;

	if (ts->packages[i] & TRANS_PACKAGE_PRESENT)

		return;

	ts->packages[i] |= TRANS_PACKAGE_PRESENT;

	prop = list_first(&package->properties, &ts->set->property_pool);

	while (prop) {

		ts->properties[prop->data]++;

		prop = list_next(prop);

	}

}

static void

transaction_set_remove_package(struct transaction_set *ts,

			       struct razor_package *package)

{

	struct razor_package *pkgs;

	struct list *prop;

	int i;

	pkgs = ts->set->packages.data;

	i = package - pkgs;

	if (!(ts->packages[i] & TRANS_PACKAGE_PRESENT))

		return;

	ts->packages[i] &= ~TRANS_PACKAGE_PRESENT;

	prop = list_first(&package->properties, &ts->set->property_pool);

	while (prop) {

		ts->properties[prop->data]--;

		prop = list_next(prop);

	}

}

RAZOR_EXPORT struct razor_transaction *

razor_transaction_create(struct razor_set *system, struct razor_set *upstream)

{

	struct razor_transaction *trans;

	struct razor_package *p, *spkgs, *pend;

	trans = zalloc(sizeof *trans);

	transaction_set_init(&trans->system, system);

	transaction_set_init(&trans->upstream, upstream);

	spkgs = trans->system.set->packages.data;

	pend = trans->system.set->packages.data +

		trans->system.set->packages.size;

	for (p = spkgs; p < pend; p++)

		transaction_set_install_package(&trans->system, p);

	return trans;

}

RAZOR_EXPORT void

razor_transaction_install_package(struct razor_transaction *trans,

				  struct razor_package *package)

{

	assert (trans != NULL);

	assert (package != NULL);

	transaction_set_install_package(&trans->upstream, package);

	trans->changes++;

}

RAZOR_EXPORT void

razor_transaction_remove_package(struct razor_transaction *trans,

				 struct razor_package *package)

{

	assert (trans != NULL);

	assert (package != NULL);

	transaction_set_remove_package(&trans->system, package);

	trans->changes++;

}

RAZOR_EXPORT void

razor_transaction_update_package(struct razor_transaction *trans,

				  struct razor_package *package)

{

	struct razor_package *spkgs, *upkgs, *end;

	assert (trans != NULL);

	assert (package != NULL);

	spkgs = trans->system.set->packages.data;

	upkgs = trans->upstream.set->packages.data;

	end = trans->system.set->packages.data +

		trans->system.set->packages.size;

	if (spkgs <= package && package < end)

		trans->system.packages[package - spkgs] |= TRANS_PACKAGE_UPDATE;

	else

		trans->upstream.packages[package - upkgs] |= TRANS_PACKAGE_UPDATE;

}

struct prop_iter {

	struct razor_property *p, *start, *end;

	const char *pool;

	uint32_t *present;

};

static void

prop_iter_init(struct prop_iter *pi, struct transaction_set *ts)

{

	pi->p = ts->set->properties.data;

	pi->start = ts->set->properties.data;

	pi->end = ts->set->properties.data + ts->set->properties.size;

	pi->pool = ts->set->string_pool.data;

	pi->present = ts->properties;

}

static int

prop_iter_next(struct prop_iter *pi, uint32_t flags, struct razor_property **p)

{

	while (pi->p < pi->end) {

		if ((pi->present[pi->p - pi->start] & ~TRANS_PROPERTY_SATISFIED) &&

		    (pi->p->flags & RAZOR_PROPERTY_TYPE_MASK) == flags) {

			*p = pi->p++;

			return 1;

		}

		pi->p++;

	}

	return 0;

}

static struct razor_property *

prop_iter_seek_to(struct prop_iter *pi,

		  uint32_t flags, const char *match)

{

	uint32_t name;

	while (pi->p < pi->end && strcmp(&pi->pool[pi->p->name], match) < 0)

		pi->p++;

	if (pi->p == pi->end || strcmp(&pi->pool[pi->p->name], match) > 0)

		return NULL;

	name = pi->p->name;

	while (pi->p < pi->end &&

	       pi->p->name == name &&

	       (pi->p->flags & RAZOR_PROPERTY_TYPE_MASK) != flags)

		pi->p++;

	if (pi->p == pi->end || pi->p->name != name)

		return NULL;

	return pi->p;

}

/* Remove packages from set that provide any of the matching (same

 * name and type) providers from ppi onwards that match the

 * requirement that rpi points to. */

static void

remove_matching_providers(struct razor_transaction *trans,

			  struct prop_iter *ppi,

			  uint32_t flags,

			  const char *version)

{

	struct razor_property *p;

	struct razor_package *pkg;

	struct razor_package_iterator pkg_iter;

	struct razor_set *set;

	const char *n, *v;

	uint32_t type;

	if (ppi->present == trans->system.properties)

		set = trans->system.set;

	else

		set = trans->upstream.set;

	type = ppi->p->flags & RAZOR_PROPERTY_TYPE_MASK;

	for (p = ppi->p;

	     p < ppi->end &&

	     p->name == ppi->p->name &&

	     (p->flags & RAZOR_PROPERTY_TYPE_MASK) == type;

	     p++) {

		if (!ppi->present[p - ppi->start])

			continue;

		if (!provider_satisfies_requirement(p, ppi->pool,

						    flags, version))

			continue;

		razor_package_iterator_init_for_property(&pkg_iter, set, p);

		while (razor_package_iterator_next(&pkg_iter, &pkg,

						   RAZOR_DETAIL_NAME, &n,

						   RAZOR_DETAIL_VERSION, &v,

						   RAZOR_DETAIL_LAST)) {

#if 0

			fprintf(stderr, "removing %s-%s\n", n, v);

#endif

			razor_transaction_remove_package(trans, pkg);

		}

	}

}

static void

flag_matching_providers(struct razor_transaction *trans,

			struct prop_iter *ppi,

			struct razor_property *r,

			struct prop_iter *rpi,

			unsigned int flag)

{

	struct razor_property *p;

	struct razor_package *pkg, *pkgs;

	struct razor_package_iterator pkg_iter;

	struct razor_set *set;

	const char *name, *version;

	uint32_t *flags, type;

	if (ppi->present == trans->system.properties) {

		set = trans->system.set;

		flags = trans->system.packages;

	} else {

		set = trans->upstream.set;

		flags = trans->upstream.packages;

	}

	pkgs = (struct razor_package *) set->packages.data;

	type = ppi->p->flags & RAZOR_PROPERTY_TYPE_MASK;

	for (p = ppi->p;

	     p < ppi->end &&

		     p->name == ppi->p->name &&

		     (p->flags & RAZOR_PROPERTY_TYPE_MASK) == type;

	     p++) {

		if (!ppi->present[p - ppi->start])

			continue;

		if (!provider_satisfies_requirement(p, ppi->pool,

						    r->flags,

						    &rpi->pool[r->version]))

			continue;

		razor_package_iterator_init_for_property(&pkg_iter, set, p);

		while (razor_package_iterator_next(&pkg_iter, &pkg,

						   RAZOR_DETAIL_NAME, &name,

						   RAZOR_DETAIL_VERSION, &version,

						   RAZOR_DETAIL_LAST)) {

#if 0

			fprintf(stderr, "flagging %s-%s for providing %s matching %s %s\n",

				name, version,

				ppi->pool + p->name,

				rpi->pool + r->name,

				rpi->pool + r->version);

#endif

			flags[pkg - pkgs] |= flag;

		}

	}

}

static struct razor_package *

pick_matching_provider(struct razor_set *set,

		       struct prop_iter *ppi,

		       uint32_t flags,

		       const char *version)

{

	struct razor_property *p;

	struct razor_package *pkgs;

	struct list *i;

	uint32_t type;

	/* This is where we decide which pkgs to pull in to satisfy a

	 * requirement.  There may be several different providers

	 * (different versions) and each version of a provider may

	 * come from a number of packages.  We pick the first package

	 * from the first provider that matches. */

	pkgs = set->packages.data;

	type = ppi->p->flags & RAZOR_PROPERTY_TYPE_MASK;

	for (p = ppi->p;

	     p < ppi->end &&

		     p->name == ppi->p->name &&

		     (p->flags & RAZOR_PROPERTY_TYPE_MASK) == type &&

		     ppi->present[p - ppi->start] == 0;

	     p++) {

		if (!provider_satisfies_requirement(p, ppi->pool,

						    flags, version))

			continue;

		i = list_first(&p->packages, &set->package_pool);

		return &pkgs[i->data];

	}

	return NULL;

}

static void

remove_obsoleted_packages(struct razor_transaction *trans)

{

	struct razor_property *up;

	struct prop_iter spi, upi;

	prop_iter_init(&spi, &trans->system);

	prop_iter_init(&upi, &trans->upstream);

	while (prop_iter_next(&upi, RAZOR_PROPERTY_OBSOLETES, &up)) {

		if (!prop_iter_seek_to(&spi, RAZOR_PROPERTY_PROVIDES,

				       &upi.pool[up->name]))

			continue;

		remove_matching_providers(trans, &spi, up->flags,

					  &upi.pool[up->version]);

	}

}

static int

any_provider_satisfies_requirement(struct prop_iter *ppi,

				   uint32_t flags,

				   const char *version)

{

	struct razor_property *p;

	uint32_t type;

	type = ppi->p->flags & RAZOR_PROPERTY_TYPE_MASK;

	for (p = ppi->p;

	     p < ppi->end &&

		     p->name == ppi->p->name &&

		     (p->flags & RAZOR_PROPERTY_TYPE_MASK) == type;

	     p++) {

		if (ppi->present[p - ppi->start] > 0 &&

		    provider_satisfies_requirement(p, ppi->pool,

						   flags, version))

			return 1;

	}

	return 0;

}

static void

clear_requires_flags(struct transaction_set *ts)

{

	struct razor_property *p;

	const char *pool;

	int i, count;

	char *sub;

	count = ts->set->properties.size / sizeof *p;

	p = ts->set->properties.data;

	pool = ts->set->string_pool.data;

	for (i = 0; i < count; i++) {

		ts->properties[i] &= ~TRANS_PROPERTY_SATISFIED;

		sub = strchr(&pool[p[i].name], '(');

		if (sub && sub[strlen(sub) - 1] == ')') {

			sub = strdup(sub + 1);

			sub[strlen(sub) - 1] = '\0';

			if (strncmp(&pool[p[i].name], "rpmlib(", 7) == 0)

				ts->properties[i] |= TRANS_PROPERTY_SATISFIED;

			if (strncmp(&pool[p[i].name], "lua(", 4) == 0 &&

			    razor_get_lua_loader(sub) &&

			    p[i].flags & RAZOR_PROPERTY_SCRIPT_MASK)

				ts->properties[i] |= TRANS_PROPERTY_SATISFIED;

			free(sub);

		}

	}

}

static void

mark_satisfied_requires(struct razor_transaction *trans,

			struct transaction_set *rts,

			struct transaction_set *pts)

{

	struct prop_iter rpi, ppi;

	struct razor_property *rp;

	prop_iter_init(&rpi, rts);

	prop_iter_init(&ppi, pts);

	while (prop_iter_next(&rpi, RAZOR_PROPERTY_REQUIRES, &rp)) {

		if (!prop_iter_seek_to(&ppi, RAZOR_PROPERTY_PROVIDES,

				       &rpi.pool[rp->name]))

			continue;

		if (any_provider_satisfies_requirement(&ppi, rp->flags,

						       &rpi.pool[rp->version]))

			rpi.present[rp - rpi.start] |= TRANS_PROPERTY_SATISFIED;

	}

}

static void

mark_all_satisfied_requires(struct razor_transaction *trans)

{

	clear_requires_flags(&trans->system);

	clear_requires_flags(&trans->upstream);

	mark_satisfied_requires(trans, &trans->system, &trans->system);

	mark_satisfied_requires(trans, &trans->system, &trans->upstream);

	mark_satisfied_requires(trans, &trans->upstream, &trans->system);

	mark_satisfied_requires(trans, &trans->upstream, &trans->upstream);

}

static void

update_unsatisfied_packages(struct razor_transaction *trans)

{

	struct razor_package *spkgs, *pkg;

	struct razor_property *sp;

	struct prop_iter spi;

	struct razor_package_iterator pkg_iter;

	const char *name;

	spkgs = trans->system.set->packages.data;

	prop_iter_init(&spi, &trans->system);

	while (prop_iter_next(&spi, RAZOR_PROPERTY_REQUIRES, &sp)) {

		if (spi.present[sp - spi.start] & TRANS_PROPERTY_SATISFIED)

			continue;

		razor_package_iterator_init_for_property(&pkg_iter,

							 trans->system.set,

							 sp);

		while (razor_package_iterator_next(&pkg_iter, &pkg,

						   RAZOR_DETAIL_NAME, &name,

						   RAZOR_DETAIL_LAST)) {

			if (!(trans->system.packages[pkg - spkgs] & TRANS_PACKAGE_PRESENT))

				continue;

#if 0

			fprintf(stderr, "updating %s because %s %s %s "

				"isn't satisfied\n",

				name, spi.pool + sp->name,

				razor_property_relation_to_string(sp),

				spi.pool + sp->version);

#endif

			trans->system.packages[pkg - spkgs] |=

				TRANS_PACKAGE_UPDATE;

		}

	}

}

RAZOR_EXPORT void

razor_transaction_update_all(struct razor_transaction *trans)

{

	struct razor_package *p;

	int i, count;

	assert (trans != NULL);

	count = trans->system.set->packages.size / sizeof *p;

	for (i = 0; i < count; i++)

		trans->system.packages[i] |= TRANS_PACKAGE_UPDATE;

}

static void

update_conflicted_packages(struct razor_transaction *trans)

{

	struct razor_package *pkg, *spkgs;

	struct razor_property *up, *sp;

	struct prop_iter spi, upi;

	struct razor_package_iterator pkg_iter;

	const char *name, *version;

	spkgs = trans->system.set->packages.data;

	prop_iter_init(&spi, &trans->system);

	prop_iter_init(&upi, &trans->upstream);

	while (prop_iter_next(&spi, RAZOR_PROPERTY_CONFLICTS, &sp)) {

		if (!prop_iter_seek_to(&upi, RAZOR_PROPERTY_PROVIDES,

				       &spi.pool[sp->name]))

			continue;

		if (!any_provider_satisfies_requirement(&upi, sp->flags,

							&spi.pool[sp->version]))

			continue;

		razor_package_iterator_init_for_property(&pkg_iter,

							 trans->system.set,

							 sp);

		while (razor_package_iterator_next(&pkg_iter, &pkg,

						   RAZOR_DETAIL_NAME, &name,

						   RAZOR_DETAIL_VERSION, &version,

						   RAZOR_DETAIL_LAST)) {

#if 0

			fprintf(stderr, "updating %s %s because it "

				"conflicts with %s\n",

				name, version, spi.pool + sp->name);

#endif

			trans->system.packages[pkg - spkgs] |=

				TRANS_PACKAGE_UPDATE;

		}

	}

	prop_iter_init(&spi, &trans->system);

	prop_iter_init(&upi, &trans->upstream);

	while (prop_iter_next(&upi, RAZOR_PROPERTY_CONFLICTS, &up)) {

		sp = prop_iter_seek_to(&spi, RAZOR_PROPERTY_PROVIDES,

				       &upi.pool[upi.p->name]);

		if (sp)

			flag_matching_providers(trans, &spi, up, &upi,

						TRANS_PACKAGE_UPDATE);

	}

}

static void

pull_in_requirements(struct razor_transaction *trans,

		     struct prop_iter *rpi, struct prop_iter *ppi)

{

	struct razor_property *rp, *pp;

	struct razor_package *pkg, *upkgs;

	upkgs = trans->upstream.set->packages.data;

	while (prop_iter_next(rpi, RAZOR_PROPERTY_REQUIRES, &rp)) {

		if (rpi->present[rp - rpi->start] & TRANS_PROPERTY_SATISFIED)

			continue;

		pp = prop_iter_seek_to(ppi, RAZOR_PROPERTY_PROVIDES,

				       &rpi->pool[rp->name]);

		if (pp == NULL)

			continue;

		pkg = pick_matching_provider(trans->upstream.set,

					     ppi, rp->flags,

					     &rpi->pool[rp->version]);

		if (pkg == NULL)

			continue;

		rpi->present[rp - rpi->start] |= TRANS_PROPERTY_SATISFIED;

#if 0

		fprintf(stderr, "pulling in %s-%s.%s which provides %s %s %s "

			"to satisfy %s %s %s\n",

			ppi->pool + pkg->name,

			ppi->pool + pkg->version,

			ppi->pool + pkg->arch,

			ppi->pool + pp->name,

			razor_property_relation_to_string(pp),

			ppi->pool + pp->version,

			&rpi->pool[rp->name],

			razor_property_relation_to_string(rp),

			&rpi->pool[rp->version]);

#endif

		trans->upstream.packages[pkg - upkgs] |= TRANS_PACKAGE_UPDATE;

	}

}

static void

pull_in_all_requirements(struct razor_transaction *trans)

{

	struct prop_iter rpi, ppi;

	prop_iter_init(&rpi, &trans->system);

	prop_iter_init(&ppi, &trans->upstream);

	pull_in_requirements(trans, &rpi, &ppi);

	prop_iter_init(&rpi, &trans->upstream);

	prop_iter_init(&ppi, &trans->upstream);

	pull_in_requirements(trans, &rpi, &ppi);

}

static void

flush_scheduled_system_updates(struct razor_transaction *trans)

{

 	struct razor_package_iterator *pi;

 	struct razor_package *p, *pkg, *spkgs;

	struct prop_iter ppi;

	const char *name, *version;

	spkgs = trans->system.set->packages.data;

	pi = razor_package_iterator_create(trans->system.set);

	prop_iter_init(&ppi, &trans->upstream);

	while (razor_package_iterator_next(pi, &p,

					   RAZOR_DETAIL_NAME, &name,

					   RAZOR_DETAIL_VERSION, &version,

					   RAZOR_DETAIL_LAST)) {

		if (!(trans->system.packages[p - spkgs] & TRANS_PACKAGE_UPDATE))

			continue;

		trans->system.packages[p - spkgs] &= ~TRANS_PACKAGE_UPDATE;

		if (!prop_iter_seek_to(&ppi, RAZOR_PROPERTY_PROVIDES, name))

			continue;

		if (any_provider_satisfies_requirement(&ppi,

						       RAZOR_PROPERTY_GREATER,

						       version)) {

			razor_transaction_remove_package(trans, p);

			continue;

		}

		pkg = pick_matching_provider(trans->upstream.set, &ppi,

					     RAZOR_PROPERTY_GREATER, version);

		if (pkg == NULL)

			continue;

		razor_transaction_remove_package(trans, p);

		razor_transaction_install_package(trans, pkg);

	}

	razor_package_iterator_destroy(pi);

}

static void

flush_scheduled_upstream_updates(struct razor_transaction *trans)

{

 	struct razor_package_iterator *pi;

 	struct razor_package *p, *upkgs;

	struct prop_iter spi;

	const char *name, *version;

	upkgs = trans->upstream.set->packages.data;

	pi = razor_package_iterator_create(trans->upstream.set);

	prop_iter_init(&spi, &trans->system);

	while (razor_package_iterator_next(pi, &p,

					   RAZOR_DETAIL_NAME, &name,

					   RAZOR_DETAIL_VERSION, &version,

					   RAZOR_DETAIL_LAST)) {

		if (!(trans->upstream.packages[p - upkgs] & TRANS_PACKAGE_UPDATE))

			continue;

		trans->upstream.packages[p - upkgs] &= ~TRANS_PACKAGE_UPDATE;

		if (prop_iter_seek_to(&spi, RAZOR_PROPERTY_PROVIDES, name))

			remove_matching_providers(trans,

						  &spi,

						  RAZOR_PROPERTY_LESS,

						  version);

		razor_transaction_install_package(trans, p);

#if 0

		fprintf(stderr, "installing %s-%s\n", name, version);

#endif

	}

	razor_package_iterator_destroy(pi);

}

RAZOR_EXPORT int

razor_transaction_resolve(struct razor_transaction *trans)

{

	int last = 0;

	flush_scheduled_system_updates(trans);

	flush_scheduled_upstream_updates(trans);

	while (last < trans->changes) {

		last = trans->changes;

		remove_obsoleted_packages(trans);

		mark_all_satisfied_requires(trans);

		update_unsatisfied_packages(trans);

		update_conflicted_packages(trans);

		pull_in_all_requirements(trans);

		flush_scheduled_system_updates(trans);

		flush_scheduled_upstream_updates(trans);

	}

	return trans->changes;

}

static void

describe_unsatisfied(struct razor_set *set, struct razor_property *rp,

		     razor_unsatisfied_callback_t callback, void *data)

{

	struct razor_package_iterator pi;

	struct razor_package *pkg;

	const char *name, *version, *arch, *pool;

	const char *requirement;

	char *s = NULL;

	pool = set->string_pool.data;

	if (pool[rp->version] == '\0')

		requirement = &pool[rp->name];

	else {

		s = razor_concat(&pool[rp->name], " ",

				 razor_property_relation_to_string(rp), " ",

				 &pool[rp->version], NULL);

		requirement = s;

	}

	razor_package_iterator_init_for_property(&pi, set, rp);

	while (razor_package_iterator_next(&pi, &pkg,

					   RAZOR_DETAIL_NAME, &name,

					   RAZOR_DETAIL_VERSION, &version,

					   RAZOR_DETAIL_ARCH, &arch,

					   RAZOR_DETAIL_LAST))

		callback(requirement, pkg, name, version, arch, data);

	if (s)

		free(s);

}

RAZOR_EXPORT int

razor_transaction_unsatisfied(struct razor_transaction *trans,

			      razor_unsatisfied_callback_t callback, void *data)

{

	struct prop_iter rpi;

	struct razor_property *rp;

	int unsatisfied;

	flush_scheduled_system_updates(trans);

	flush_scheduled_upstream_updates(trans);

	mark_all_satisfied_requires(trans);

	unsatisfied = 0;

	prop_iter_init(&rpi, &trans->system);

	while (prop_iter_next(&rpi, RAZOR_PROPERTY_REQUIRES, &rp)) {

		if (!(rpi.present[rp - rpi.start] & TRANS_PROPERTY_SATISFIED)) {

			if (callback)

				describe_unsatisfied(trans->system.set, rp,

						     callback, data);

		        unsatisfied++;

		}

	}

	prop_iter_init(&rpi, &trans->upstream);

	while (prop_iter_next(&rpi, RAZOR_PROPERTY_REQUIRES, &rp)) {

		if (!(rpi.present[rp - rpi.start] & TRANS_PROPERTY_SATISFIED)) {

			if (callback)

				describe_unsatisfied(trans->upstream.set, rp,

						     callback, data);

			unsatisfied++;

		}

	}

	return unsatisfied;

}

static void

describe_unsatisfied_callback(const char *requirement,

			      struct razor_package *package, const char *name,

			      const char *version, const char *arch, void *data)

{

	FILE *fp = data;

	fprintf(fp, "%s is needed by %s-%s.%s\n", requirement,

		name, version, arch);

}

RAZOR_EXPORT int

razor_transaction_describe(struct razor_transaction *trans)

{

	return razor_transaction_unsatisfied(trans,

					     describe_unsatisfied_callback,

					     stderr);

}

RAZOR_EXPORT int

razor_transaction_unsatisfied_property(struct razor_transaction *trans,

				       const char *name,

				       uint32_t flags,

				       const char *version)

{

	struct prop_iter pi;

	struct razor_property *p;

	prop_iter_init(&pi, &trans->system);

	while (prop_iter_next(&pi, flags & RAZOR_PROPERTY_TYPE_MASK, &p)) {

		if (!(trans->system.properties[p - pi.start] & TRANS_PROPERTY_SATISFIED) &&

		    p->flags == flags &&

		    strcmp(&pi.pool[p->name], name) == 0 &&

		    strcmp(&pi.pool[p->version], version) == 0)

			return 1;

	}

	prop_iter_init(&pi, &trans->upstream);

	while (prop_iter_next(&pi, flags & RAZOR_PROPERTY_TYPE_MASK, &p)) {

		if (!(trans->upstream.properties[p - pi.start] & TRANS_PROPERTY_SATISFIED) &&

		    p->flags == flags &&

		    strcmp(&pi.pool[p->name], name) == 0 &&

		    strcmp(&pi.pool[p->version], version) == 0)

			return 1;

	}

	return 0;

}

RAZOR_EXPORT struct razor_set *

razor_transaction_commit(struct razor_transaction *trans)

{

	struct razor_package *u, *uend, *upkgs, *s, *send, *spkgs;

	char *upool, *spool;

	int cmp;

	s = trans->system.set->packages.data;

	spkgs = trans->system.set->packages.data;

	send = trans->system.set->packages.data +

		trans->system.set->packages.size;

	spool = trans->system.set->string_pool.data;

	u = trans->upstream.set->packages.data;

	upkgs = trans->upstream.set->packages.data;

	uend = trans->upstream.set->packages.data +

		trans->upstream.set->packages.size;

	upool = trans->upstream.set->string_pool.data;

	trans->merger = razor_merger_create(trans->system.set,

					    trans->upstream.set);

	while (s < send || u < uend) {

		if (s < send && u < uend)

			cmp = strcmp(&spool[s->name], &upool[u->name]);

		else if (s < send)

			cmp = -1;

		else

			cmp = 1;

		if (cmp < 0) {

			if (trans->system.packages[s - spkgs] & TRANS_PACKAGE_PRESENT)

				razor_merger_add_package(trans->merger, s);

			s++;

		} else if (cmp == 0) {

			if (trans->system.packages[s - spkgs] & TRANS_PACKAGE_PRESENT)

				razor_merger_add_package(trans->merger, s);

			if (trans->upstream.packages[u - upkgs] & TRANS_PACKAGE_PRESENT)

				razor_merger_add_package(trans->merger, u);

			s++;

			u++;

		} else {

			if (trans->upstream.packages[u - upkgs] & TRANS_PACKAGE_PRESENT)

				razor_merger_add_package(trans->merger, u);

			u++;

		}

	}

	return razor_merger_commit(trans->merger);

}

RAZOR_EXPORT void

razor_transaction_fixup_package(struct razor_transaction *trans,

				struct razor_package *package,

				struct razor_rpm *rpm)

{

	const char *preunprog, *preun, *postunprog, *postun;

	razor_rpm_get_details(rpm,

			      RAZOR_DETAIL_PREUNPROG, &preunprog,

			      RAZOR_DETAIL_PREUN, &preun,

			      RAZOR_DETAIL_POSTUNPROG, &postunprog,

			      RAZOR_DETAIL_POSTUN, &postun,

			      RAZOR_DETAIL_LAST);

	razor_merger_package_add_script(trans->merger, package,

					RAZOR_PROPERTY_PREUN,

					preunprog, preun);

	razor_merger_package_add_script(trans->merger, package,

					RAZOR_PROPERTY_POSTUN,

					postunprog, postun);

}

RAZOR_EXPORT void

razor_transaction_destroy(struct razor_transaction *trans)

{

	assert (trans != NULL);

	if (trans->merger)

		razor_merger_destroy(trans->merger);

	transaction_set_release(&trans->system);

	transaction_set_release(&trans->upstream);

	free(trans);

}