[pakfire.git] / src / libpakfire / package.c

/*#############################################################################
#                                                                             #
# Pakfire - The IPFire package management system                              #
# Copyright (C) 2013 Pakfire development team                                 #
#                                                                             #
# 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 3 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, see <http://www.gnu.org/licenses/>.       #
#                                                                             #
#############################################################################*/

#include <errno.h>
#include <linux/limits.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <uuid/uuid.h>

#include <solv/evr.h>
#include <solv/pool.h>
#include <solv/repo.h>
#include <solv/solvable.h>

#include <pakfire/archive.h>
#include <pakfire/constants.h>
#include <pakfire/file.h>
#include <pakfire/filelist.h>
#include <pakfire/i18n.h>
#include <pakfire/logging.h>
#include <pakfire/package.h>
#include <pakfire/pakfire.h>
#include <pakfire/private.h>
#include <pakfire/repo.h>
#include <pakfire/util.h>

struct pakfire_package {
	struct pakfire* pakfire;
	int nrefs;

	// Reference to this package in the SOLV pool
	Id id;
	struct pakfire_repo* repo;

	char nevra[NAME_MAX];

	char filename[NAME_MAX];
	char path[PATH_MAX];
};

static void pakfire_package_add_self_provides(struct pakfire* pakfire, struct pakfire_package* pkg, const char* name, const char* evr) {
	char buffer[1024];
	pakfire_string_format(buffer, "%s = %s", name, evr);

	pakfire_package_add_provides(pkg, buffer);
}

struct pakfire_package* pakfire_package_create_from_solvable(struct pakfire* pakfire, Id id) {
	struct pakfire_package* pkg = calloc(1, sizeof(*pkg));
	if (!pkg)
		return NULL;

	pkg->pakfire = pakfire_ref(pakfire);
	pkg->id = id;

	// Initialize reference counter
	pkg->nrefs = 1;

	return pkg;
}

PAKFIRE_EXPORT struct pakfire_package* pakfire_package_create(struct pakfire* pakfire, struct pakfire_repo* repo, const char* name, const char* evr, const char* arch) {
	Id id = pakfire_repo_add_solvable(repo);
	if (!id)
		return NULL;

	struct pakfire_package* pkg = pakfire_package_create_from_solvable(pakfire, id);
	if (!pkg)
		return NULL;

	pkg->repo = pakfire_repo_ref(repo);

	// Set the given attributes
	pakfire_package_set_name(pkg, name);
	pakfire_package_set_evr(pkg, evr);
	pakfire_package_set_arch(pkg, arch);

	// Add self-provides
	pakfire_package_add_self_provides(pakfire, pkg, name, evr);

	return pkg;
}

static void pakfire_package_free(struct pakfire_package* pkg) {
	if (pkg->repo)
		pakfire_repo_unref(pkg->repo);

	pakfire_unref(pkg->pakfire);
	free(pkg);
}

PAKFIRE_EXPORT struct pakfire_package* pakfire_package_ref(struct pakfire_package* pkg) {
	pkg->nrefs++;

	return pkg;
}

PAKFIRE_EXPORT struct pakfire_package* pakfire_package_unref(struct pakfire_package* pkg) {
	if (--pkg->nrefs > 0)
		return pkg;

	pakfire_package_free(pkg);
	return NULL;
}

PAKFIRE_EXPORT struct pakfire* pakfire_package_get_pakfire(struct pakfire_package* pkg) {
	return pakfire_ref(pkg->pakfire);
}

static Solvable* get_solvable(struct pakfire_package* pkg) {
	Pool* pool = pakfire_get_solv_pool(pkg->pakfire);

	return pool_id2solvable(pool, pkg->id);
}

PAKFIRE_EXPORT int pakfire_package_eq(struct pakfire_package* pkg1, struct pakfire_package* pkg2) {
	return pkg1->id == pkg2->id;
}

PAKFIRE_EXPORT int pakfire_package_cmp(struct pakfire_package* pkg1, struct pakfire_package* pkg2) {
	Pool* pool = pakfire_get_solv_pool(pkg1->pakfire);

	Solvable* s1 = get_solvable(pkg1);
	Solvable* s2 = get_solvable(pkg2);

	// Check names
	const char* str1 = pool_id2str(pool, s1->name);
	const char* str2 = pool_id2str(pool, s2->name);

	int ret = strcmp(str1, str2);
	if (ret)
		return ret;

	// Check the version string
	ret = pakfire_package_evr_cmp(pkg1, pkg2);
	if (ret)
		return ret;

	// Check repositories
	struct pakfire_repo* repo1 = pakfire_package_get_repo(pkg1);
	struct pakfire_repo* repo2 = pakfire_package_get_repo(pkg2);

	if (repo1 && repo2) {
		ret = pakfire_repo_cmp(repo1, repo2);
	}

	pakfire_repo_unref(repo1);
	pakfire_repo_unref(repo2);

	if (ret)
		return ret;

	// Check package architectures
	str1 = pool_id2str(pool, s1->arch);
	str2 = pool_id2str(pool, s2->arch);

	return strcmp(str1, str2);
}

PAKFIRE_EXPORT int pakfire_package_evr_cmp(struct pakfire_package* pkg1, struct pakfire_package* pkg2) {
	Pool* pool = pakfire_get_solv_pool(pkg1->pakfire);

	Solvable* s1 = get_solvable(pkg1);
	Solvable* s2 = get_solvable(pkg2);

	return pool_evrcmp(pool, s1->evr, s2->evr, EVRCMP_COMPARE);
}

Id pakfire_package_id(struct pakfire_package* pkg) {
	return pkg->id;
}

PAKFIRE_EXPORT const char* pakfire_package_get_nevra(struct pakfire_package* pkg) {
	if (!*pkg->nevra) {
		Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
		Solvable* s = get_solvable(pkg);

		pakfire_string_set(pkg->nevra, pool_solvable2str(pool, s));
	}

	return pkg->nevra;
}

PAKFIRE_EXPORT const char* pakfire_package_get_name(struct pakfire_package* pkg) {
	Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
	Solvable* s = get_solvable(pkg);

	return pool_id2str(pool, s->name);
}

PAKFIRE_EXPORT void pakfire_package_set_name(struct pakfire_package* pkg, const char* name) {
	Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
	Solvable* s = get_solvable(pkg);

	s->name = pool_str2id(pool, name, 1);
}

PAKFIRE_EXPORT const char* pakfire_package_get_evr(struct pakfire_package* pkg) {
	Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
	Solvable* s = get_solvable(pkg);

	return pool_id2str(pool, s->evr);
}

PAKFIRE_EXPORT void pakfire_package_set_evr(struct pakfire_package* pkg, const char* evr) {
	Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
	Solvable* s = get_solvable(pkg);

	s->evr = pool_str2id(pool, evr, 1);
}

char* pakfire_package_join_evr(const char* e, const char* v, const char* r) {
	char* buffer = NULL;

	// Check for valid input
	if (!e || !v || !r) {
		errno = EINVAL;
		return NULL;
	}

	// Skip any zeroes in epoch
	while (*e && *e == '0')
		e++;

	// Format string with epoch
	if (*e) {
		if (asprintf(&buffer, "%s:%s-%s", e, v, r) < 0)
			return NULL;

	// Or format it without epoch
	} else {
		if (asprintf(&buffer, "%s-%s", v, r) < 0)
			return NULL;
	}

	return buffer;
}

PAKFIRE_EXPORT const char* pakfire_package_get_arch(struct pakfire_package* pkg) {
	Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
	Solvable* s = get_solvable(pkg);

	return pool_id2str(pool, s->arch);
}

PAKFIRE_EXPORT void pakfire_package_set_arch(struct pakfire_package* pkg, const char* arch) {
	Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
	Solvable* s = get_solvable(pkg);

	s->arch = pool_str2id(pool, arch, 1);
}

int pakfire_package_is_source(struct pakfire_package* pkg) {
	const char* arch = pakfire_package_get_arch(pkg);
	if (!arch)
		return 1;

	return (strcmp(arch, "src") == 0);
}

static void pakfire_package_internalize_repo(struct pakfire_package* pkg) {
	struct pakfire_repo* repo = pakfire_package_get_repo(pkg);
	if (repo) {
		pakfire_repo_internalize(repo);
		pakfire_repo_unref(repo);
	}
}

static unsigned long long pakfire_package_get_num(struct pakfire_package* pkg, Id type) {
	pakfire_package_internalize_repo(pkg);

	Solvable* s = get_solvable(pkg);
	return solvable_lookup_num(s, type, 0);
}

static void pakfire_package_set_num(struct pakfire_package* pkg, Id type, unsigned long long value) {
	Solvable* s = get_solvable(pkg);

	solvable_set_num(s, type, value);
}

static const char* pakfire_package_get_string(struct pakfire_package* pkg, int key) {
	pakfire_package_internalize_repo(pkg);

	Solvable* s = get_solvable(pkg);
	const char* str = solvable_lookup_str(s, key);

	if (!str)
		return NULL;

	if (strlen(str) == 0)
		return NULL;

	return str;
}

static void pakfire_package_set_string(struct pakfire_package* pkg, int key, const char* value) {
	Solvable* s = get_solvable(pkg);

	if (!value)
		value = "";

	solvable_set_poolstr(s, key, value);
}

static char** pakfire_package_get_string_array(struct pakfire_package* pkg, Id key) {
	char** strings = NULL;

	Queue ids;
	queue_init(&ids);

	Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
	Solvable* s = get_solvable(pkg);
	solvable_lookup_idarray(s, key, &ids);

	if (ids.count > 0) {
		strings = calloc(ids.count + 1, sizeof(*strings));
		if (!strings) {
			queue_free(&ids);
			return NULL;
		}

		for (int i = 0; i < ids.count; i++) {
			const char* value = pool_id2str(pool, ids.elements[i]);
			strings[i] = strdup(value);
		}

		strings[ids.count] = NULL;
	}

	queue_free(&ids);

	return strings;
}

static void pakfire_package_add_string_array(struct pakfire_package* pkg, Id key, const char* value) {
	if (!value)
		return;

	Solvable* s = get_solvable(pkg);
	solvable_add_poolstr_array(s, key, value);
}

uint64_t pakfire_package_get_dbid(struct pakfire_package* pkg) {
	return pakfire_package_get_num(pkg, RPM_RPMDBID);
}

void pakfire_package_set_dbid(struct pakfire_package* pkg, uint64_t id) {
	pakfire_package_set_num(pkg, RPM_RPMDBID, id);
}

PAKFIRE_EXPORT const char* pakfire_package_get_uuid(struct pakfire_package* pkg) {
	return pakfire_package_get_string(pkg, SOLVABLE_PKGID);
}

PAKFIRE_EXPORT void pakfire_package_set_uuid(struct pakfire_package* pkg, const char* uuid) {
	pakfire_package_set_string(pkg, SOLVABLE_PKGID, uuid);
}

PAKFIRE_EXPORT const char* pakfire_package_get_checksum(struct pakfire_package* pkg) {
	return pakfire_package_get_string(pkg, SOLVABLE_CHECKSUM);
}

PAKFIRE_EXPORT void pakfire_package_set_checksum(struct pakfire_package* pkg, const char* checksum) {
	pakfire_package_set_string(pkg, SOLVABLE_CHECKSUM, checksum);
}

PAKFIRE_EXPORT const char* pakfire_package_get_summary(struct pakfire_package* pkg) {
	return pakfire_package_get_string(pkg, SOLVABLE_SUMMARY);
}

PAKFIRE_EXPORT void pakfire_package_set_summary(struct pakfire_package* pkg, const char* summary) {
	pakfire_package_set_string(pkg, SOLVABLE_SUMMARY, summary);
}

PAKFIRE_EXPORT const char* pakfire_package_get_description(struct pakfire_package* pkg) {
	return pakfire_package_get_string(pkg, SOLVABLE_DESCRIPTION);
}

PAKFIRE_EXPORT void pakfire_package_set_description(struct pakfire_package* pkg, const char* description) {
	pakfire_package_set_string(pkg, SOLVABLE_DESCRIPTION, description);
}

PAKFIRE_EXPORT const char* pakfire_package_get_license(struct pakfire_package* pkg) {
	return pakfire_package_get_string(pkg, SOLVABLE_LICENSE);
}

PAKFIRE_EXPORT void pakfire_package_set_license(struct pakfire_package* pkg, const char* license) {
	pakfire_package_set_string(pkg, SOLVABLE_LICENSE, license);
}

PAKFIRE_EXPORT const char* pakfire_package_get_url(struct pakfire_package* pkg) {
	return pakfire_package_get_string(pkg, SOLVABLE_URL);
}

PAKFIRE_EXPORT void pakfire_package_set_url(struct pakfire_package* pkg, const char* url) {
	pakfire_package_set_string(pkg, SOLVABLE_URL, url);
}

PAKFIRE_EXPORT char* pakfire_package_get_groups(struct pakfire_package* pkg) {
	char** groups = pakfire_package_get_string_array(pkg, SOLVABLE_GROUP);
	if (!groups)
		return NULL;

	char* string = pakfire_string_join(groups, " ");

	// Free array
	for (char** group = groups; *group; group++)
		free(*group);
	free(groups);

	return string;
}

PAKFIRE_EXPORT void pakfire_package_set_groups(struct pakfire_package* pkg, const char* groups) {
	char** list = pakfire_split_string(groups, ' ');
	if (!list)
		return;

	for (char** group = list; *group; group++) {
		pakfire_package_add_string_array(pkg, SOLVABLE_GROUP, *group);
		free(*group);
	}

	free(list);
}

PAKFIRE_EXPORT const char* pakfire_package_get_vendor(struct pakfire_package* pkg) {
	return pakfire_package_get_string(pkg, SOLVABLE_VENDOR);
}

PAKFIRE_EXPORT void pakfire_package_set_vendor(struct pakfire_package* pkg, const char* vendor) {
	pakfire_package_set_string(pkg, SOLVABLE_VENDOR, vendor);
}

PAKFIRE_EXPORT const char* pakfire_package_get_maintainer(struct pakfire_package* pkg) {
	return pakfire_package_get_string(pkg, SOLVABLE_PACKAGER);
}

PAKFIRE_EXPORT void pakfire_package_set_maintainer(struct pakfire_package* pkg, const char* maintainer) {
	pakfire_package_set_string(pkg, SOLVABLE_PACKAGER, maintainer);
}

static int pakfire_package_make_cache_path(struct pakfire_package* pkg) {
	const char* filename = pakfire_package_get_filename(pkg);
	const char* checksum = pakfire_package_get_checksum(pkg);

	if (strlen(checksum) < 3)
		return 1;

	return pakfire_make_cache_path(pkg->pakfire, pkg->path,
		"%c%c/%s/%s", checksum[0], checksum[1], checksum + 2, filename);
}

PAKFIRE_EXPORT const char* pakfire_package_get_path(struct pakfire_package* pkg) {
	int r;

	if (!*pkg->path) {
		const char* base = pakfire_package_get_string(pkg, SOLVABLE_MEDIABASE);
		if (base) {
			const char* filename = pakfire_package_get_filename(pkg);
			if (!filename)
				return NULL;

			pakfire_string_format(pkg->path, "%s/%s", base, filename);
		} else {
			r = pakfire_package_make_cache_path(pkg);
			if (r)
				return NULL;
		}
	}

	return pkg->path;
}

PAKFIRE_EXPORT void pakfire_package_set_path(struct pakfire_package* pkg, const char* path) {
	char* basename = pakfire_basename(path);
	char* dirname  = pakfire_dirname(path);

	if (basename) {
		pakfire_package_set_string(pkg, SOLVABLE_MEDIAFILE, basename);
		free(basename);
	}

	if (dirname) {
		pakfire_package_set_string(pkg, SOLVABLE_MEDIABASE, dirname);
		free(dirname);
	}

	pakfire_string_set(pkg->path, path);
}

// Removes epoch
static const char* evr2vr(const char* evr) {
	const char* p = evr;

	// Skip any leading digits
	for (; *p >= '0' && *p <= '9'; p++);

	// If after the leading digits, we found :, we return the rest of the string
	if (p != evr && *p == ':')
		return ++p;

	return evr;
}

static const char* pakfire_package_make_filename(struct pakfire_package* pkg) {
	if (!*pkg->filename) {
		const char* name = pakfire_package_get_name(pkg);
		const char* evr  = pakfire_package_get_evr(pkg);
		const char* arch = pakfire_package_get_arch(pkg);

		if (!name || !evr || !arch)
			return NULL;

		const char* vr = evr2vr(evr);

		pakfire_string_format(pkg->filename, "%s-%s.%s.pfm", name, vr, arch);
	}

	return pkg->filename;
}

PAKFIRE_EXPORT const char* pakfire_package_get_filename(struct pakfire_package* pkg) {
	const char* filename = pakfire_package_get_string(pkg, SOLVABLE_MEDIAFILE);

	// Generate the filename if not set
	if (!filename)
		filename = pakfire_package_make_filename(pkg);

	return filename;
}

PAKFIRE_EXPORT void pakfire_package_set_filename(struct pakfire_package* pkg, const char* filename) {
	pakfire_package_set_string(pkg, SOLVABLE_MEDIAFILE, filename);
}

PAKFIRE_EXPORT int pakfire_package_is_installed(struct pakfire_package* pkg) {
	Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
	Solvable* s = get_solvable(pkg);

	return pool->installed == s->repo;
}

PAKFIRE_EXPORT unsigned long long pakfire_package_get_downloadsize(struct pakfire_package* pkg) {
	return pakfire_package_get_num(pkg, SOLVABLE_DOWNLOADSIZE);
}

PAKFIRE_EXPORT void pakfire_package_set_downloadsize(struct pakfire_package* pkg, unsigned long long downloadsize) {
	return pakfire_package_set_num(pkg, SOLVABLE_DOWNLOADSIZE, downloadsize);
}

PAKFIRE_EXPORT unsigned long long pakfire_package_get_installsize(struct pakfire_package* pkg) {
	return pakfire_package_get_num(pkg, SOLVABLE_INSTALLSIZE);
}

PAKFIRE_EXPORT void pakfire_package_set_installsize(struct pakfire_package* pkg, unsigned long long installsize) {
	return pakfire_package_set_num(pkg, SOLVABLE_INSTALLSIZE, installsize);
}

PAKFIRE_EXPORT unsigned long long pakfire_package_get_size(struct pakfire_package* pkg) {
	if (pakfire_package_is_installed(pkg))
		return pakfire_package_get_installsize(pkg);

	return pakfire_package_get_downloadsize(pkg);
}

PAKFIRE_EXPORT const char* pakfire_package_get_build_host(struct pakfire_package* pkg) {
	return pakfire_package_get_string(pkg, SOLVABLE_BUILDHOST);
}

PAKFIRE_EXPORT void pakfire_package_set_build_host(struct pakfire_package* pkg, const char* build_host) {
	pakfire_package_set_string(pkg, SOLVABLE_BUILDHOST, build_host);
}

PAKFIRE_EXPORT const char* pakfire_package_get_build_id(struct pakfire_package* pkg) {
	return pakfire_package_get_string(pkg, SOLVABLE_BUILDVERSION);
}

PAKFIRE_EXPORT void pakfire_package_set_build_id(struct pakfire_package* pkg, const char* build_id) {
	pakfire_package_set_string(pkg, SOLVABLE_BUILDVERSION, build_id);
}

void pakfire_package_set_build_id_from_uuid(struct pakfire_package* pkg, uuid_t* build_id) {
	char buffer[UUID_STR_LEN];

	// Convert the UUID to string
	uuid_unparse_lower(*build_id, buffer);

	pakfire_package_set_build_id(pkg, buffer);
}

PAKFIRE_EXPORT time_t pakfire_package_get_build_time(struct pakfire_package* pkg) {
	return pakfire_package_get_num(pkg, SOLVABLE_BUILDTIME);
}

PAKFIRE_EXPORT void pakfire_package_set_build_time(struct pakfire_package* pkg, time_t build_time) {
	pakfire_package_set_num(pkg, SOLVABLE_BUILDTIME, build_time);
}

PAKFIRE_EXPORT time_t pakfire_package_get_install_time(struct pakfire_package* pkg) {
	return pakfire_package_get_num(pkg, SOLVABLE_INSTALLTIME);
}

PAKFIRE_EXPORT void pakfire_package_set_install_time(struct pakfire_package* pkg, time_t install_time) {
	pakfire_package_set_num(pkg, SOLVABLE_INSTALLTIME, install_time);
}

static char** pakfire_package_get_relationlist(
		struct pakfire_package* pkg, Id type, Id marker) {
	char** array = NULL;

	Queue q;
	queue_init(&q);

	Solvable* s = get_solvable(pkg);

	// Fetch all deps
	solvable_lookup_deparray(s, type, &q, marker);

	// Nothing to do if the array was empty
	if (!q.count)
		goto ERROR;

	Pool* pool = pakfire_get_solv_pool(pkg->pakfire);

	// Allocate array
	array = calloc(q.count + 1, sizeof(*array));
	if (!array)
		goto ERROR;

	for (int i = 0; i < q.count; i++) {
		const char* dep = pool_dep2str(pool, q.elements[i]);

		array[i] = strdup(dep);
	}

ERROR:
	queue_free(&q);

	return array;
}

static void pakfire_package_add_dep(struct pakfire_package* pkg, Id type,
		const char* dep, Id marker) {
	Solvable* s = get_solvable(pkg);

	// Parse the dependency
	Id id = pakfire_parse_dep(pkg->pakfire, dep);
	if (!id)
		return;

	solvable_add_deparray(s, type, id, marker);
}

PAKFIRE_EXPORT char** pakfire_package_get_provides(struct pakfire_package* pkg) {
	return pakfire_package_get_relationlist(pkg, SOLVABLE_PROVIDES, -SOLVABLE_FILEMARKER);
}

void pakfire_package_add_provides(struct pakfire_package* pkg, const char* dep) {
	pakfire_package_add_dep(pkg, SOLVABLE_PROVIDES, dep, -SOLVABLE_FILEMARKER);
}

PAKFIRE_EXPORT char** pakfire_package_get_prerequires(struct pakfire_package* pkg) {
	return pakfire_package_get_relationlist(pkg, SOLVABLE_REQUIRES, SOLVABLE_PREREQMARKER);
}

void pakfire_package_add_prerequires(struct pakfire_package* pkg, const char* dep) {
	pakfire_package_add_dep(pkg, SOLVABLE_REQUIRES, dep, SOLVABLE_PREREQMARKER);
}

PAKFIRE_EXPORT char** pakfire_package_get_requires(struct pakfire_package* pkg) {
	return pakfire_package_get_relationlist(pkg, SOLVABLE_REQUIRES, -SOLVABLE_PREREQMARKER);
}

void pakfire_package_add_requires(struct pakfire_package* pkg, const char* dep) {
	pakfire_package_add_dep(pkg, SOLVABLE_REQUIRES, dep, -SOLVABLE_PREREQMARKER);
}

PAKFIRE_EXPORT char** pakfire_package_get_conflicts(struct pakfire_package* pkg) {
	return pakfire_package_get_relationlist(pkg, SOLVABLE_CONFLICTS, 0);
}

void pakfire_package_add_conflicts(struct pakfire_package* pkg, const char* dep) {
	pakfire_package_add_dep(pkg, SOLVABLE_CONFLICTS, dep, 0);
}

PAKFIRE_EXPORT char** pakfire_package_get_obsoletes(struct pakfire_package* pkg) {
	return pakfire_package_get_relationlist(pkg, SOLVABLE_OBSOLETES, 0);
}

void pakfire_package_add_obsoletes(struct pakfire_package* pkg, const char* dep) {
	pakfire_package_add_dep(pkg, SOLVABLE_OBSOLETES, dep, 0);
}

PAKFIRE_EXPORT char** pakfire_package_get_recommends(struct pakfire_package* pkg) {
	return pakfire_package_get_relationlist(pkg, SOLVABLE_RECOMMENDS, 0);
}

void pakfire_package_add_recommends(struct pakfire_package* pkg, const char* dep) {
	pakfire_package_add_dep(pkg, SOLVABLE_RECOMMENDS, dep, 0);
}

PAKFIRE_EXPORT char** pakfire_package_get_suggests(struct pakfire_package* pkg) {
	return pakfire_package_get_relationlist(pkg, SOLVABLE_SUGGESTS, 0);
}

void pakfire_package_add_suggests(struct pakfire_package* pkg, const char* dep) {
	pakfire_package_add_dep(pkg, SOLVABLE_SUGGESTS, dep, 0);
}

PAKFIRE_EXPORT char** pakfire_package_get_supplements(struct pakfire_package* pkg) {
	return pakfire_package_get_relationlist(pkg, SOLVABLE_SUPPLEMENTS, 0);
}

void pakfire_package_add_supplements(struct pakfire_package* pkg, const char* dep) {
	pakfire_package_add_dep(pkg, SOLVABLE_SUPPLEMENTS, dep, 0);
}

PAKFIRE_EXPORT char** pakfire_package_get_enhances(struct pakfire_package* pkg) {
	return pakfire_package_get_relationlist(pkg, SOLVABLE_ENHANCES, 0);
}

void pakfire_package_add_enhances(struct pakfire_package* pkg, const char* dep) {
	pakfire_package_add_dep(pkg, SOLVABLE_ENHANCES, dep, 0);
}

PAKFIRE_EXPORT int pakfire_package_get_reverse_requires(struct pakfire_package* pkg,
		struct pakfire_packagelist** list) {
	Queue matches;
	queue_init(&matches);

	// Reset pointer
	*list = NULL;

	Pool* pool = pakfire_get_solv_pool(pkg->pakfire);

	// Search for any matches
	pool_whatmatchessolvable(pool, SOLVABLE_REQUIRES, pkg->id, &matches, 0);

	// Create a new package list
	int r = pakfire_packagelist_create_from_queue(list, pkg->pakfire, &matches);
	if (r)
		goto ERROR;

ERROR:
	queue_free(&matches);

	return r;
}

PAKFIRE_EXPORT struct pakfire_repo* pakfire_package_get_repo(struct pakfire_package* pkg) {
	if (!pkg->repo) {
		Solvable* s = get_solvable(pkg);

		pkg->repo = pakfire_repo_create_from_repo(pkg->pakfire, s->repo);
	}

	return pakfire_repo_ref(pkg->repo);
}

static void pakfire_package_dump_add_line(char** str, const char* key, const char* val) {
	if (val)
		asprintf(str, "%s%-15s: %s\n", *str, key ? key : "", val);
}

static void pakfire_package_dump_add_lines(char** str, const char* key, const char* val) {
	char** lines = pakfire_split_string(val, '\n');
	if (!lines)
		return;

	while (*lines) {
		pakfire_package_dump_add_line(str, key, *lines);
		lines++;
	}
}

static void pakfire_package_dump_add_line_date(char** str, const char* key, unsigned long long date) {
	// Convert from integer to tm struct.
	struct tm* timer = gmtime((time_t *)&date);

	char val[128];
	strftime(val, sizeof(val) - 1, "%a, %d %b %Y %T %z", timer);

	pakfire_package_dump_add_line(str, key, val);
}

static void pakfire_package_dump_add_line_size(char** str, const char* key, unsigned long long size) {
	char buffer[128];
	pakfire_format_size(buffer, sizeof(buffer) - 1, size);

	pakfire_package_dump_add_line(str, key, buffer);
}

static int pakfire_sort_dependencies(const void* p1, const void* p2) {
	const char* dep1 = *(const char**)p1;
	const char* dep2 = *(const char**)p2;

	return strcmp(dep1, dep2);
}

PAKFIRE_EXPORT char* pakfire_package_dump(struct pakfire_package* pkg, int flags) {
	char* string = "";

	// Name
	const char* name = pakfire_package_get_name(pkg);
	pakfire_package_dump_add_line(&string, _("Name"), name);

	// EVR
	const char* evr = pakfire_package_get_evr(pkg);
	pakfire_package_dump_add_line(&string, _("Version"), evr);

	// Arch
	const char* arch = pakfire_package_get_arch(pkg);
	pakfire_package_dump_add_line(&string, _("Arch"), arch);

	// Size
	unsigned long long size = pakfire_package_get_size(pkg);
	pakfire_package_dump_add_line_size(&string, _("Size"), size);

	// Installed size
	if (pakfire_package_is_installed(pkg)) {
		unsigned long long installsize = pakfire_package_get_installsize(pkg);
		pakfire_package_dump_add_line_size(&string, _("Installed size"), installsize);

	// Downloadsize
	} else {
		unsigned long long downloadsize = pakfire_package_get_downloadsize(pkg);
		pakfire_package_dump_add_line_size(&string, _("Download size"), downloadsize);
	}

	struct pakfire_repo* repo = pakfire_package_get_repo(pkg);
	if (repo) {
		const char* repo_name = pakfire_repo_get_name(repo);
		pakfire_package_dump_add_line(&string, _("Repo"), repo_name);

		pakfire_repo_unref(repo);
	}

	// Summary
	const char* summary = pakfire_package_get_summary(pkg);
	pakfire_package_dump_add_line(&string, _("Summary"), summary);

	// Description
	const char* description = pakfire_package_get_description(pkg);
	if (description)
		pakfire_package_dump_add_lines(&string, _("Description"), description);

	// Groups
	const char* groups = pakfire_package_get_groups(pkg);
	if (groups) {
		pakfire_package_dump_add_lines(&string, _("Groups"), groups);
	}

	// URL
	const char* url = pakfire_package_get_url(pkg);
	pakfire_package_dump_add_line(&string, _("URL"), url);

	// License
	const char* license = pakfire_package_get_license(pkg);
	pakfire_package_dump_add_line(&string, _("License"), license);

	if (flags & PAKFIRE_PKG_DUMP_LONG) {
		// Install Time
		time_t install_time = pakfire_package_get_install_time(pkg);
		if (install_time) {
			pakfire_package_dump_add_line_date(&string, _("Install Time"), install_time);
		}

		// Maintainer
		const char* maintainer = pakfire_package_get_maintainer(pkg);
		pakfire_package_dump_add_line(&string, _("Maintainer"), maintainer);

		// Vendor
		const char* vendor = pakfire_package_get_vendor(pkg);
		pakfire_package_dump_add_line(&string, _("Vendor"), vendor);

		// UUID
		const char* uuid = pakfire_package_get_uuid(pkg);
		pakfire_package_dump_add_line(&string, _("UUID"), uuid);

		// Build ID
		const char* build_id = pakfire_package_get_build_id(pkg);
		if (build_id)
			pakfire_package_dump_add_line(&string, _("Build ID"), build_id);

		// Build time
		time_t build_time = pakfire_package_get_build_time(pkg);
		pakfire_package_dump_add_line_date(&string, _("Build Time"), build_time);

		// Build host
		const char* build_host = pakfire_package_get_build_host(pkg);
		pakfire_package_dump_add_line(&string, _("Build Host"), build_host);

		// Dependencies

		const struct relation {
			const char* name;
			char** (*get)(struct pakfire_package* pkg);
		} relations[] = {
			{ _("Provides"),     pakfire_package_get_provides, },
			{ _("Pre-Requires"), pakfire_package_get_prerequires, },
			{ _("Requires"),     pakfire_package_get_requires, },
			{ _("Conflicts"),    pakfire_package_get_conflicts, },
			{ _("Obsoletes"),    pakfire_package_get_obsoletes, },
			{ _("Recommends"),   pakfire_package_get_recommends, },
			{ _("Suggests"),     pakfire_package_get_suggests, },
			{ _("Supplements"),  pakfire_package_get_supplements, },
			{ _("Enhances"),     pakfire_package_get_enhances, },
			{ NULL, NULL},
		};

		for (const struct relation* relation = relations; relation->name; relation++) {
			char** deps = relation->get(pkg);
			if (deps) {
				const char* name = relation->name;
				size_t count = 0;

				// Count elements in the list
				for (char** dep = deps; *dep; dep++)
					count++;

				// Sort the list
				qsort(deps, count, sizeof(*deps), pakfire_sort_dependencies);

				// Write it to the console
				for (char** dep = deps; *dep; dep++) {
					pakfire_package_dump_add_line(&string, name, *dep);
					free(*dep);

					// Clear name after first line
					name = NULL;
				}
				free(deps);
			}
		}
	}

	if (flags & PAKFIRE_PKG_DUMP_FILELIST) {
		struct pakfire_filelist* filelist = pakfire_package_get_filelist(pkg);

		const char* prefix = _("Filelist");

		for (unsigned int i = 0; i < pakfire_filelist_size(filelist); i++) {
			struct pakfire_file* file = pakfire_filelist_get(filelist, i);

			const char* path = pakfire_file_get_path(file);
			pakfire_package_dump_add_line(&string, prefix, path);

			pakfire_file_unref(file);

			// Only prefix the first line
			prefix = NULL;
		}

		pakfire_filelist_unref(filelist);
	}

	return string;
}

PAKFIRE_EXPORT struct pakfire_archive* pakfire_package_get_archive(struct pakfire_package* pkg) {
	struct pakfire_archive* archive;

	// Otherwise open the archive from the cache
	const char* path = pakfire_package_get_path(pkg);
	if (!path)
		return NULL;

	// Open archive
	int r = pakfire_archive_open(&archive, pkg->pakfire, path);

	if (r == 0)
		return archive;

	return NULL;
}

static int pakfire_package_fetch_legacy_filelist(struct pakfire_package* pkg, struct pakfire_filelist* filelist) {
	pakfire_package_internalize_repo(pkg);

	struct pakfire_repo* repo = pakfire_package_get_repo(pkg);
	Solvable* s = get_solvable(pkg);
	Pool* p = pakfire_get_solv_pool(pkg->pakfire);
	Repo* r = pakfire_repo_get_repo(repo);
	pakfire_repo_unref(repo);

	int found_marker = 0;

	Id id, *ids;
	ids = r->idarraydata + s->provides;
	while((id = *ids++) != 0) {
		const char* path = pool_dep2str(p, id);

		if (found_marker) {
			struct pakfire_file* file;

			int r = pakfire_file_create(&file, pkg->pakfire);
			if (r)
				return r;

			// Set path
			pakfire_file_set_path(file, path);

			r = pakfire_filelist_append(filelist, file);
			if (r)
				return r;

			pakfire_file_unref(file);
			continue;
		}

		if (strcmp(path, "solvable:filemarker") == 0)
			++found_marker;
	}

	return 0;
}

static int pakfire_package_fetch_filelist(struct pakfire_package* pkg, struct pakfire_filelist* filelist) {
	int r;

	pakfire_package_internalize_repo(pkg);

	Solvable* s = get_solvable(pkg);

	Dataiterator di;
	dataiterator_init(&di, s->repo->pool, s->repo, pkg->id,
		SOLVABLE_FILELIST, NULL, SEARCH_FILES | SEARCH_COMPLETE_FILELIST);

	while (dataiterator_step(&di)) {
		struct pakfire_file* file;

		r = pakfire_file_create(&file, pkg->pakfire);
		if (r)
			return r;

		pakfire_file_set_path(file, di.kv.str);

		// Append to filelist
		pakfire_filelist_append(filelist, file);
		pakfire_file_unref(file);
	}
	dataiterator_free(&di);

	// If the file list is empty, we fall back to read files
	// in the older format.
	if (pakfire_filelist_is_empty(filelist)) {
		r = pakfire_package_fetch_legacy_filelist(pkg, filelist);
		if (r)
			return r;
	}

	// Sort the list
	pakfire_filelist_sort(filelist);

	return 0;
}

PAKFIRE_EXPORT struct pakfire_filelist* pakfire_package_get_filelist(struct pakfire_package* pkg) {
	struct pakfire_filelist* filelist;

	int r = pakfire_filelist_create(&filelist, pkg->pakfire);
	if (r)
		return NULL;

	r = pakfire_package_fetch_filelist(pkg, filelist);
	if (r) {
		pakfire_filelist_unref(filelist);
		return NULL;
	}

	return filelist;
}

static int pakfire_package_append_file(struct pakfire_package* pkg, const char* path) {
	// Fetch repodata
	struct pakfire_repo* repo = pakfire_package_get_repo(pkg);
	Repodata* repodata = pakfire_repo_get_repodata(repo);
	pakfire_repo_unref(repo);

	char* basename = pakfire_basename(path);
	char* dirname  = pakfire_dirname(path);

	// Convert directory into ID
	Id did = repodata_str2dir(repodata, dirname, 1);
	if (!did)
		did = repodata_str2dir(repodata, "/", 1);

	// Add data to list
	repodata_add_dirstr(repodata, pkg->id,
		SOLVABLE_FILELIST, did, basename);

	free(basename);
	free(dirname);

	return 0;
}

PAKFIRE_EXPORT int pakfire_package_set_filelist(struct pakfire_package* pkg, struct pakfire_filelist* filelist) {
	int r;

	for (unsigned int i = 0; i < pakfire_filelist_size(filelist); i++) {
		struct pakfire_file* file = pakfire_filelist_get(filelist, i);

		const char* path = pakfire_file_get_path(file);
		if (path) {
			r = pakfire_package_append_file(pkg, path);
			if (r) {
				pakfire_file_unref(file);
				return r;
			}
		}

		pakfire_file_unref(file);
	}

	return 0;
}

int pakfire_package_set_filelist_from_string(struct pakfire_package* pkg, const char* files) {
	// Total length of the input string
	size_t size = strlen(files);

	// Copy files to the stack to be able to modify it
	char* buffer = alloca(size + 1);

	// Copy the content
	memcpy(buffer, files, size);

	// Replace all line breaks with NUL
	for (unsigned int i = 0; i < size; i++) {
		if (buffer[i] == '\n')
			buffer[i] = '\0';
	}

	size_t p = 0;
	while (p < size) {
		const char* name = &buffer[p];

		int r = pakfire_package_append_file(pkg, name);
		if (r)
			return r;

		p += strlen(name) + 1;
	}

	return 0;
}