/*

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

 * Copyright (C) 2008  Red Hat, Inc

 *

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

#include <string.h>

#include <assert.h>

#include "razor-internal.h"

#include "razor.h"

static struct razor_package_iterator *

razor_package_iterator_create_with_index(struct razor_set *set,

					 struct list *index)

{

	struct razor_package_iterator *pi;

	pi = zalloc(sizeof *pi);

	pi->set = set;

	pi->index = index;

	return pi;

}

static struct razor_package_iterator *

razor_package_iterator_create_empty(struct razor_set *set)

{

	struct razor_package_iterator *pi;

	return zalloc(sizeof *pi);

}

RAZOR_EXPORT struct razor_package_iterator *

razor_package_iterator_create(struct razor_set *set)

{

	struct razor_package_iterator *pi;

	assert (set != NULL);

	pi = zalloc(sizeof *pi);

	pi->set = set;

	pi->end = set->packages.data + set->packages.size;

	pi->package = set->packages.data;

	return pi;

}

RAZOR_EXPORT void

razor_package_iterator_init_for_property(struct razor_package_iterator *pi,

					 struct razor_set *set,

					 struct razor_property *property)

{

	assert (pi != NULL);

	assert (set != NULL);

	assert (property != NULL);

	memset(pi, 0, sizeof *pi);

	pi->set = set;

	pi->index = list_first(&property->packages, &set->package_pool);

}

RAZOR_EXPORT struct razor_package_iterator *

razor_package_iterator_create_for_property(struct razor_set *set,

					   struct razor_property *property)

{

	struct list *index;

	assert (set != NULL);

	assert (property != NULL);

	index = list_first(&property->packages, &set->package_pool);

	return razor_package_iterator_create_with_index(set, index);

}

RAZOR_EXPORT struct razor_package_iterator *

razor_package_iterator_create_for_file(struct razor_set *set,

				       const char *filename)

{

	struct razor_entry *entry;

	struct list *index;

	assert (set != NULL);

	assert (filename != NULL);

	entry = razor_set_find_entry(set, set->files.data, filename);

	if (entry == NULL)

		return razor_package_iterator_create_empty(set);

	index = list_first(&entry->packages, &set->package_pool);

	return razor_package_iterator_create_with_index(set, index);

}

/**

 * razor_package_iterator_next:

 * @pi: a %razor_package_iterator

 * @package: a %razor_package

 *

 * Gets the next iteratr along with any vararg data.

 * The vararg must be terminated with %RAZOR_DETAIL_LAST.

 *

 * Example: razor_package_iterator_next (pi, package,

 *					 RAZOR_DETAIL_NAME, &name,

 *					 RAZOR_DETAIL_LAST);

 **/

RAZOR_EXPORT int

razor_package_iterator_next(struct razor_package_iterator *pi,

			    struct razor_package **package, ...)

{

	va_list args;

	int valid;

	struct razor_package *p, *packages;

	assert (pi != NULL);

	if (pi->package) {

		p = pi->package++;

		valid = p < pi->end;

	} else if (pi->index) {

		packages = pi->set->packages.data;

		p = &packages[pi->index->data];

		pi->index = list_next(pi->index);

		valid = 1;

	} else

		valid = 0;

	if (valid == 0) {

		*package = NULL;

		goto out;

	}

	*package = p;

	va_start(args, NULL);

	razor_package_get_details_varg (pi->set, p, args);

	va_end (args);

out:

	return valid;

}

RAZOR_EXPORT void

razor_package_iterator_destroy(struct razor_package_iterator *pi)

{

	assert (pi != NULL);

	if (pi->free_index)

		free(pi->index);

	free(pi);

}

RAZOR_EXPORT struct razor_property_iterator *

razor_property_iterator_create(struct razor_set *set,

			       struct razor_package *package)

{

	struct razor_property_iterator *pi;

	assert (set != NULL);

	pi = zalloc(sizeof *pi);

	pi->set = set;

	if (package) {

		pi->index = list_first(&package->properties,

				       &set->property_pool);

	} else {

		pi->property = set->properties.data;

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

	}

	return pi;

}

RAZOR_EXPORT int

razor_property_iterator_next(struct razor_property_iterator *pi,

			     struct razor_property **property,

			     const char **name,

			     uint32_t *flags,

			     const char **version)

{

	char *pool;

	int valid;

	struct razor_property *p, *properties;

	assert (pi != NULL);

	if (pi->property) {

		p = pi->property++;

		valid = p < pi->end;

	} else if (pi->index) {

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

		p = &properties[pi->index->data];

		pi->index = list_next(pi->index);

		valid = 1;

	} else

		valid = 0;

	if (valid) {

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

		*property = p;

		*name = &pool[p->name];

		*flags = p->flags;

		*version = &pool[p->version];

	} else {

		*property = NULL;

	}

	return valid;

}

RAZOR_EXPORT void

razor_property_iterator_destroy(struct razor_property_iterator *pi)

{

	free(pi);

}

struct razor_package_query {

	struct razor_set *set;

	char *vector;

	int count;

};

RAZOR_EXPORT struct razor_package_query *

razor_package_query_create(struct razor_set *set)

{

	struct razor_package_query *pq;

	int count;

	assert (set != NULL);

	pq = zalloc(sizeof *pq);

	pq->set = set;

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

	pq->vector = zalloc(count * sizeof(char));

	return pq;

}

RAZOR_EXPORT void

razor_package_query_add_package(struct razor_package_query *pq,

				struct razor_package *p)

{

	struct razor_package *packages;

	assert (pq != NULL);

	assert (p != NULL);

	packages = pq->set->packages.data;

	pq->count += pq->vector[p - packages] ^ 1;

	pq->vector[p - packages] = 1;

}

RAZOR_EXPORT void

razor_package_query_add_iterator(struct razor_package_query *pq,

				 struct razor_package_iterator *pi)

{

	struct razor_package *packages, *p;

	assert (pq != NULL);

	assert (pi != NULL);

	packages = pq->set->packages.data;

	while (razor_package_iterator_next(pi, &p, RAZOR_DETAIL_LAST)) {

		pq->count += pq->vector[p - packages] ^ 1;

		pq->vector[p - packages] = 1;

	}

}

RAZOR_EXPORT struct razor_package_iterator *

razor_package_query_finish(struct razor_package_query *pq)

{

	struct razor_package_iterator *pi;

	struct razor_set *set;

	struct list *index;

	int i, j;

	assert (pq != NULL);

	set = pq->set;

	if (pq->count > 0)

		index = zalloc(pq->count * sizeof *index);

	else

		index = NULL;

	for (i = 0, j = 0; j < pq->count; i++) {

		if (!pq->vector[i])

			continue;

		index[j].data = i;

		if (j == pq->count - 1)

			index[j].flags = 0x80;

		j++;

	}

	free(pq->vector);

	free(pq);

	pi = razor_package_iterator_create_with_index(set, index);

	pi->free_index = 1;

	return pi;

}