#include "git-compat-util.h"
#include "cache-tree.h"
#include "gettext.h"
#include "hex.h"
#include "lockfile.h"
#include "object-name.h"
#include "refs.h"
#include "reset.h"
#include "tree-walk.h"
#include "tree.h"
#include "unpack-trees.h"
#include "hook.h"

static int update_refs(struct repository *repo,
		       const struct reset_working_tree_options *opts,
		       const struct object_id *oid,
		       const struct object_id *head)
{
	unsigned detach_head = opts->flags & RESET_WORKING_TREE_DETACH;
	unsigned run_hook = opts->flags & RESET_WORKING_TREE_RUN_POST_CHECKOUT_HOOK;
	unsigned update_orig_head = opts->flags & RESET_WORKING_TREE_UPDATE_ORIG_HEAD;
	const struct object_id *orig_head = opts->orig_head;
	const char *switch_to_branch = opts->branch;
	const char *reflog_branch = opts->branch_msg;
	const char *reflog_head = opts->head_msg;
	const char *reflog_orig_head = opts->orig_head_msg;
	const char *default_reflog_action = opts->default_reflog_action;
	struct object_id *old_orig = NULL, oid_old_orig;
	struct strbuf msg = STRBUF_INIT;
	const char *reflog_action;
	size_t prefix_len;
	int ret;

	if ((update_orig_head && !reflog_orig_head) || !reflog_head) {
		if (!default_reflog_action)
			BUG("default_reflog_action must be given when reflog messages are omitted");
		reflog_action = getenv(GIT_REFLOG_ACTION_ENVIRONMENT);
		strbuf_addf(&msg, "%s: ", reflog_action ? reflog_action :
							  default_reflog_action);
	}
	prefix_len = msg.len;

	if (update_orig_head) {
		if (!repo_get_oid(repo, "ORIG_HEAD", &oid_old_orig))
			old_orig = &oid_old_orig;
		if (head) {
			if (!reflog_orig_head) {
				strbuf_addstr(&msg, "updating ORIG_HEAD");
				reflog_orig_head = msg.buf;
			}
			refs_update_ref(get_main_ref_store(repo),
					reflog_orig_head, "ORIG_HEAD",
					orig_head ? orig_head : head,
					old_orig, 0, UPDATE_REFS_MSG_ON_ERR);
		} else if (old_orig)
			refs_delete_ref(get_main_ref_store(repo),
					NULL, "ORIG_HEAD", old_orig, 0);
	}

	if (!reflog_head) {
		strbuf_setlen(&msg, prefix_len);
		strbuf_addstr(&msg, "updating HEAD");
		reflog_head = msg.buf;
	}
	if (!switch_to_branch)
		ret = refs_update_ref(get_main_ref_store(repo),
				      reflog_head, "HEAD", oid, head,
				      detach_head ? REF_NO_DEREF : 0,
				      UPDATE_REFS_MSG_ON_ERR);
	else {
		ret = refs_update_ref(get_main_ref_store(repo),
				      reflog_branch ? reflog_branch : reflog_head,
				      switch_to_branch, oid, NULL, 0,
				      UPDATE_REFS_MSG_ON_ERR);
		if (!ret)
			ret = refs_update_symref(get_main_ref_store(repo),
						 "HEAD", switch_to_branch,
						 reflog_head);
	}
	if (!ret && run_hook)
		run_hooks_l(repo, "post-checkout",
			    oid_to_hex(head ? head : null_oid(repo->hash_algo)),
			    oid_to_hex(oid), "1", NULL);
	strbuf_release(&msg);
	return ret;
}

int reset_working_tree(struct repository *r,
		       const struct reset_working_tree_options *opts)
{
	const struct object_id *oid = opts->oid;
	const char *switch_to_branch = opts->branch;
	unsigned reset_hard = opts->flags & RESET_WORKING_TREE_HARD;
	unsigned refs_only = opts->flags & RESET_WORKING_TREE_REFS_ONLY;
	unsigned update_head = opts->flags & RESET_WORKING_TREE_UPDATE_HEAD;
	unsigned update_orig_head = opts->flags & RESET_WORKING_TREE_UPDATE_ORIG_HEAD;
	unsigned dry_run = opts->flags & RESET_WORKING_TREE_DRY_RUN;
	struct object_id *head = NULL, head_oid;
	struct tree_desc desc[2] = { { NULL }, { NULL } };
	struct lock_file lock = LOCK_INIT;
	struct unpack_trees_options unpack_tree_opts = { 0 };
	struct tree *tree;
	struct index_state scratch_index = INDEX_STATE_INIT(r);
	struct index_state *istate;
	const char *action;
	int ret = 0, nr = 0;

	if (switch_to_branch && !starts_with(switch_to_branch, "refs/"))
		BUG("Not a fully qualified branch: '%s'", switch_to_branch);

	if (opts->orig_head_msg && !update_orig_head)
		BUG("ORIG_HEAD reflog message given without updating ORIG_HEAD");

	if (opts->branch_msg && !opts->branch)
		BUG("branch reflog message given without a branch");

	if (update_orig_head && !update_head)
		BUG("cannot update ORIG_HEAD without updating HEAD");

	if (!refs_only && !dry_run && repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0) {
		ret = -1;
		goto leave_reset_head;
	}

	if (opts->oid_from) {
		oidcpy(&head_oid, opts->oid_from);
		head = &head_oid;
	} else if (!repo_get_oid(r, "HEAD", &head_oid)) {
		head = &head_oid;
	} else if (!oid || !reset_hard) {
		ret = error(_("could not determine HEAD revision"));
		goto leave_reset_head;
	}

	if (!oid)
		oid = &head_oid;

	if (refs_only) {
		if (!dry_run && update_head)
			return update_refs(r, opts, oid, head);
		return 0;
	}

	if (dry_run) {
		if (read_index_from(&scratch_index, r->index_file, r->gitdir) < 0 ||
		    index_state_unmerged_to_stage0(&scratch_index) < 0) {
			ret = error(_("could not read index"));
			goto leave_reset_head;
		}

		istate = &scratch_index;
	} else {
		if (repo_read_index_unmerged(r) < 0) {
			ret = error(_("could not read index"));
			goto leave_reset_head;
		}
		istate = r->index;
	}

	action = reset_hard ? "reset" : "checkout";
	setup_unpack_trees_porcelain(&unpack_tree_opts, action);
	unpack_tree_opts.head_idx = 1;
	unpack_tree_opts.src_index = istate;
	unpack_tree_opts.dst_index = istate;
	unpack_tree_opts.fn = reset_hard ? oneway_merge : twoway_merge;
	unpack_tree_opts.update = !dry_run;
	unpack_tree_opts.dry_run = dry_run;
	unpack_tree_opts.merge = 1;
	unpack_tree_opts.preserve_ignored = 0; /* FIXME: !overwrite_ignore */
	init_checkout_metadata(&unpack_tree_opts.meta, switch_to_branch, oid, NULL);
	if (reset_hard) {
		unpack_tree_opts.skip_cache_tree_update = 1;
		unpack_tree_opts.reset = UNPACK_RESET_PROTECT_UNTRACKED;
	}

	if (!reset_hard && !fill_tree_descriptor(r, &desc[nr++], &head_oid)) {
		ret = error(_("failed to find tree of %s"),
			    oid_to_hex(&head_oid));
		goto leave_reset_head;
	}

	if (!fill_tree_descriptor(r, &desc[nr++], oid)) {
		ret = error(_("failed to find tree of %s"), oid_to_hex(oid));
		goto leave_reset_head;
	}

	if (unpack_trees(nr, desc, &unpack_tree_opts)) {
		ret = -1;
		goto leave_reset_head;
	}

	if (dry_run)
		goto leave_reset_head;

	tree = repo_parse_tree_indirect(r, oid);
	if (!tree) {
		ret = error(_("unable to read tree (%s)"), oid_to_hex(oid));
		goto leave_reset_head;
	}

	if (reset_hard)
		prime_cache_tree(r, r->index, tree);

	if (write_locked_index(r->index, &lock, COMMIT_LOCK) < 0) {
		ret = error(_("could not write index"));
		goto leave_reset_head;
	}

	if (update_head &&
	    (oid != &head_oid || update_orig_head || switch_to_branch))
		ret = update_refs(r, opts, oid, head);

leave_reset_head:
	rollback_lock_file(&lock);
	clear_unpack_trees_porcelain(&unpack_tree_opts);
	release_index(&scratch_index);
	while (nr)
		free((void *)desc[--nr].buffer);
	return ret;

}