#include "git-compat-util.h"
#include "dir.h"
#include "midx.h"
#include "odb.h"
#include "packfile.h"
#include "path.h"
#include "repack.h"
#include "repository.h"
#include "run-command.h"
#include "tempfile.h"

void prepare_pack_objects(struct child_process *cmd,
			  const struct pack_objects_args *args,
			  const char *out)
{
	strvec_push(&cmd->args, "pack-objects");
	if (args->window)
		strvec_pushf(&cmd->args, "--window=%s", args->window);
	if (args->window_memory)
		strvec_pushf(&cmd->args, "--window-memory=%s", args->window_memory);
	if (args->depth)
		strvec_pushf(&cmd->args, "--depth=%s", args->depth);
	if (args->threads)
		strvec_pushf(&cmd->args, "--threads=%s", args->threads);
	if (args->max_pack_size)
		strvec_pushf(&cmd->args, "--max-pack-size=%lu", args->max_pack_size);
	if (args->no_reuse_delta)
		strvec_pushf(&cmd->args, "--no-reuse-delta");
	if (args->no_reuse_object)
		strvec_pushf(&cmd->args, "--no-reuse-object");
	if (args->name_hash_version)
		strvec_pushf(&cmd->args, "--name-hash-version=%d", args->name_hash_version);
	if (args->path_walk)
		strvec_pushf(&cmd->args, "--path-walk");
	if (args->local)
		strvec_push(&cmd->args,  "--local");
	if (args->quiet)
		strvec_push(&cmd->args,  "--quiet");
	if (args->delta_base_offset)
		strvec_push(&cmd->args,  "--delta-base-offset");
	if (!args->pack_kept_objects)
		strvec_push(&cmd->args,  "--honor-pack-keep");
	strvec_push(&cmd->args, out);
	cmd->git_cmd = 1;
	cmd->out = -1;
}

void pack_objects_args_release(struct pack_objects_args *args)
{
	free(args->window);
	free(args->window_memory);
	free(args->depth);
	free(args->threads);
	list_objects_filter_release(&args->filter_options);
}

void repack_remove_redundant_pack(struct repository *repo, const char *dir_name,
				  const char *base_name,
				  bool wrote_incremental_midx)
{
	struct strbuf buf = STRBUF_INIT;
	struct odb_source_files *files = odb_source_files_downcast(repo->objects->source);
	struct multi_pack_index *m = get_multi_pack_index(files->dirs->packed);
	strbuf_addf(&buf, "%s.pack", base_name);
	if (m && files->base.local && midx_contains_pack(m, buf.buf)) {
		clear_midx_file(repo);
		if (!wrote_incremental_midx)
			clear_incremental_midx_files(repo, NULL);
	}
	strbuf_insertf(&buf, 0, "%s/", dir_name);
	unlink_pack_path(buf.buf, 1);
	strbuf_release(&buf);
}

const char *write_pack_opts_pack_prefix(const struct write_pack_opts *opts)
{
	const char *pack_prefix;
	if (!skip_prefix(opts->packtmp, opts->packdir, &pack_prefix))
		die(_("pack prefix %s does not begin with objdir %s"),
		    opts->packtmp, opts->packdir);
	if (*pack_prefix == '/')
		pack_prefix++;
	return pack_prefix;
}

bool write_pack_opts_is_local(const struct write_pack_opts *opts)
{
	return starts_with(opts->destination, opts->packdir);
}

int finish_pack_objects_cmd(const struct git_hash_algo *algop,
			    const struct write_pack_opts *opts,
			    struct child_process *cmd,
			    struct string_list *names)
{
	FILE *out;
	bool local = write_pack_opts_is_local(opts);
	struct strbuf line = STRBUF_INIT;

	out = xfdopen(cmd->out, "r");
	while (strbuf_getline_lf(&line, out) != EOF) {
		struct string_list_item *item;

		if (line.len != algop->hexsz)
			die(_("repack: Expecting full hex object ID lines only "
			      "from pack-objects."));
		/*
		 * Avoid putting packs written outside of the repository in the
		 * list of names.
		 */
		if (local) {
			item = string_list_append(names, line.buf);
			item->util = generated_pack_populate(line.buf,
							     opts->packtmp);
		}
	}
	fclose(out);

	strbuf_release(&line);

	return finish_command(cmd);
}

#define DELETE_PACK 1
#define RETAIN_PACK 2

void existing_packs_collect(struct existing_packs *existing,
			    const struct string_list *extra_keep)
{
	struct packed_git *p;
	struct strbuf buf = STRBUF_INIT;

	repo_for_each_pack(existing->repo, p) {
		size_t i;
		const char *base;

		if (p->multi_pack_index)
			string_list_append(&existing->midx_packs,
					    pack_basename(p));
		if (!p->pack_local)
			continue;

		base = pack_basename(p);

		for (i = 0; i < extra_keep->nr; i++)
			if (!fspathcmp(base, extra_keep->items[i].string))
				break;

		strbuf_reset(&buf);
		strbuf_addstr(&buf, base);
		strbuf_strip_suffix(&buf, ".pack");

		if ((extra_keep->nr > 0 && i < extra_keep->nr) || p->pack_keep)
			string_list_append(&existing->kept_packs, buf.buf);
		else if (p->is_cruft)
			string_list_append(&existing->cruft_packs, buf.buf);
		else
			string_list_append(&existing->non_kept_packs, buf.buf);
	}

	existing->source = existing->repo->objects->source;

	string_list_sort(&existing->kept_packs);
	string_list_sort(&existing->non_kept_packs);
	string_list_sort(&existing->cruft_packs);
	string_list_sort(&existing->midx_packs);
	strbuf_release(&buf);
}

int existing_packs_has_non_kept(const struct existing_packs *existing)
{
	return existing->non_kept_packs.nr || existing->cruft_packs.nr;
}

static void existing_pack_mark_for_deletion(struct string_list_item *item)
{
	item->util = (void*)((uintptr_t)item->util | DELETE_PACK);
}

static void existing_pack_unmark_for_deletion(struct string_list_item *item)
{
	item->util = (void*)((uintptr_t)item->util & ~DELETE_PACK);
}

int existing_pack_is_marked_for_deletion(struct string_list_item *item)
{
	return (uintptr_t)item->util & DELETE_PACK;
}

static void existing_packs_mark_retained(struct string_list_item *item)
{
	item->util = (void*)((uintptr_t)item->util | RETAIN_PACK);
}

static int existing_pack_is_retained(struct string_list_item *item)
{
	return (uintptr_t)item->util & RETAIN_PACK;
}

static void existing_packs_mark_for_deletion_1(const struct git_hash_algo *algop,
					       struct string_list *names,
					       struct string_list *list)
{
	struct string_list_item *item;
	const size_t hexsz = algop->hexsz;

	for_each_string_list_item(item, list) {
		char *sha1;
		size_t len = strlen(item->string);
		if (len < hexsz)
			continue;
		sha1 = item->string + len - hexsz;

		if (existing_pack_is_retained(item)) {
			existing_pack_unmark_for_deletion(item);
		} else if (!string_list_has_string(names, sha1)) {
			/*
			 * Mark this pack for deletion, which ensures
			 * that this pack won't be included in a MIDX
			 * (if `--write-midx` was given) and that we
			 * will actually delete this pack (if `-d` was
			 * given).
			 */
			existing_pack_mark_for_deletion(item);
		}
	}
}

void existing_packs_retain_cruft(struct existing_packs *existing,
				 struct packed_git *cruft)
{
	struct strbuf buf = STRBUF_INIT;
	struct string_list_item *item;

	strbuf_addstr(&buf, pack_basename(cruft));
	strbuf_strip_suffix(&buf, ".pack");

	item = string_list_lookup(&existing->cruft_packs, buf.buf);
	if (!item)
		BUG("could not find cruft pack '%s'", pack_basename(cruft));

	existing_packs_mark_retained(item);
	strbuf_release(&buf);
}

void existing_packs_mark_for_deletion(struct existing_packs *existing,
				      struct string_list *names)

{
	const struct git_hash_algo *algop = existing->repo->hash_algo;
	existing_packs_mark_for_deletion_1(algop, names,
					   &existing->non_kept_packs);
	existing_packs_mark_for_deletion_1(algop, names,
					   &existing->cruft_packs);
}

/*
 * Mark every pack that is referenced by the existing MIDX chain as
 * retained, so that a subsequent call to
 * existing_packs_mark_for_deletion() will not mark them for deletion.
 *
 * This is used when writing an incremental MIDX layer on top of an
 * existing chain: retained layers continue to reference the same
 * packs on disk, so those packs must not be unlinked even if the
 * freshly-written pack supersedes them.
 */
void existing_packs_retain_midx_packs(struct existing_packs *existing)
{
	struct string_list_item *item;
	struct strbuf buf = STRBUF_INIT;

	for_each_string_list_item(item, &existing->midx_packs) {
		struct string_list_item *found;

		strbuf_reset(&buf);
		strbuf_addstr(&buf, item->string);
		strbuf_strip_suffix(&buf, ".pack");
		strbuf_strip_suffix(&buf, ".idx");

		found = string_list_lookup(&existing->non_kept_packs, buf.buf);
		if (found)
			existing_packs_mark_retained(found);

		found = string_list_lookup(&existing->cruft_packs, buf.buf);
		if (found)
			existing_packs_mark_retained(found);
	}

	strbuf_release(&buf);
}

static void remove_redundant_packs_1(struct repository *repo,
				     struct string_list *packs,
				     const char *packdir,
				     bool wrote_incremental_midx)
{
	struct string_list_item *item;
	for_each_string_list_item(item, packs) {
		if (!existing_pack_is_marked_for_deletion(item))
			continue;
		repack_remove_redundant_pack(repo, packdir, item->string,
					     wrote_incremental_midx);
	}
}

void existing_packs_remove_redundant(struct existing_packs *existing,
				     const char *packdir,
				     bool wrote_incremental_midx)
{
	remove_redundant_packs_1(existing->repo, &existing->non_kept_packs,
				 packdir, wrote_incremental_midx);
	remove_redundant_packs_1(existing->repo, &existing->cruft_packs,
				 packdir, wrote_incremental_midx);
}

void existing_packs_release(struct existing_packs *existing)
{
	string_list_clear(&existing->kept_packs, 0);
	string_list_clear(&existing->non_kept_packs, 0);
	string_list_clear(&existing->cruft_packs, 0);
	string_list_clear(&existing->midx_packs, 0);
}

static struct {
	const char *name;
	unsigned optional:1;
} exts[] = {
	{".pack"},
	{".rev", 1},
	{".mtimes", 1},
	{".bitmap", 1},
	{".promisor", 1},
	{".idx"},
};

struct generated_pack {
	struct tempfile *tempfiles[ARRAY_SIZE(exts)];
};

struct generated_pack *generated_pack_populate(const char *name,
					       const char *packtmp)
{
	struct stat statbuf;
	struct strbuf path = STRBUF_INIT;
	struct generated_pack *pack = xcalloc(1, sizeof(*pack));
	size_t i;

	for (i = 0; i < ARRAY_SIZE(exts); i++) {
		strbuf_reset(&path);
		strbuf_addf(&path, "%s-%s%s", packtmp, name, exts[i].name);

		if (stat(path.buf, &statbuf))
			continue;

		pack->tempfiles[i] = register_tempfile(path.buf);
	}

	strbuf_release(&path);
	return pack;
}

int generated_pack_has_ext(const struct generated_pack *pack, const char *ext)
{
	size_t i;
	for (i = 0; i < ARRAY_SIZE(exts); i++) {
		if (strcmp(exts[i].name, ext))
			continue;
		return !!pack->tempfiles[i];
	}
	BUG("unknown pack extension: '%s'", ext);
}

void generated_pack_install(struct generated_pack *pack, const char *name,
			    const char *packdir, const char *packtmp)
{
	size_t ext;
	for (ext = 0; ext < ARRAY_SIZE(exts); ext++) {
		char *fname;

		fname = mkpathdup("%s/pack-%s%s", packdir, name,
				  exts[ext].name);

		if (pack->tempfiles[ext]) {
			const char *fname_old = get_tempfile_path(pack->tempfiles[ext]);
			struct stat statbuffer;

			if (!stat(fname_old, &statbuffer)) {
				statbuffer.st_mode &= ~(S_IWUSR | S_IWGRP | S_IWOTH);
				chmod(fname_old, statbuffer.st_mode);
			}

			if (rename_tempfile(&pack->tempfiles[ext], fname))
				die_errno(_("renaming pack to '%s' failed"),
					  fname);
		} else if (!exts[ext].optional)
			die(_("pack-objects did not write a '%s' file for pack %s-%s"),
			    exts[ext].name, packtmp, name);
		else if (unlink(fname) < 0 && errno != ENOENT)
			die_errno(_("could not unlink: %s"), fname);

		free(fname);
	}
}