/*

 * Copyright (C) the libgit2 contributors. All rights reserved.

 *

 * This file is part of libgit2, distributed under the GNU GPL v2 with

 * a Linking Exception. For full terms see the included COPYING file.

 */

#include "common.h"

#include "repository.h"

#include "posix.h"

#include "fileops.h"

#include "index.h"

#include "diff_xdiff.h"

#include "merge.h"

#include "git2/repository.h"

#include "git2/object.h"

#include "git2/index.h"

#include "git2/merge.h"

#include "xdiff/xdiff.h"

/* only examine the first 8000 bytes for binaryness.

 * https://github.com/git/git/blob/77bd3ea9f54f1584147b594abc04c26ca516d987/xdiff-interface.c#L197

 */

#define GIT_MERGE_FILE_BINARY_SIZE 8000

#define GIT_MERGE_FILE_SIDE_EXISTS(X)	((X)->mode != 0)

int git_merge_file__input_from_index(

	git_merge_file_input *input_out,

	git_odb_object **odb_object_out,

	git_odb *odb,

	const git_index_entry *entry)

{

	int error = 0;

	assert(input_out && odb_object_out && odb && entry);

	if ((error = git_odb_read(odb_object_out, odb, &entry->id)) < 0)

		goto done;

	input_out->path = entry->path;

	input_out->mode = entry->mode;

	input_out->ptr = (char *)git_odb_object_data(*odb_object_out);

	input_out->size = git_odb_object_size(*odb_object_out);

done:

	return error;

}

static void merge_file_normalize_opts(

	git_merge_file_options *out,

	const git_merge_file_options *given_opts)

{

	if (given_opts)

		memcpy(out, given_opts, sizeof(git_merge_file_options));

	else {

		git_merge_file_options default_opts = GIT_MERGE_FILE_OPTIONS_INIT;

		memcpy(out, &default_opts, sizeof(git_merge_file_options));

	}

}

static int merge_file__xdiff(

	git_merge_file_result *out,

	const git_merge_file_input *ancestor,

	const git_merge_file_input *ours,

	const git_merge_file_input *theirs,

	const git_merge_file_options *given_opts)

{

	xmparam_t xmparam;

	mmfile_t ancestor_mmfile = {0}, our_mmfile = {0}, their_mmfile = {0};

	mmbuffer_t mmbuffer;

	git_merge_file_options options = GIT_MERGE_FILE_OPTIONS_INIT;

	const char *path;

	int xdl_result;

	int error = 0;

	memset(out, 0x0, sizeof(git_merge_file_result));

	merge_file_normalize_opts(&options, given_opts);

	memset(&xmparam, 0x0, sizeof(xmparam_t));

	if (ancestor) {

		xmparam.ancestor = (options.ancestor_label) ?

			options.ancestor_label : ancestor->path;

		ancestor_mmfile.ptr = (char *)ancestor->ptr;

		ancestor_mmfile.size = ancestor->size;

	}

	xmparam.file1 = (options.our_label) ?

		options.our_label : ours->path;

	our_mmfile.ptr = (char *)ours->ptr;

	our_mmfile.size = ours->size;

	xmparam.file2 = (options.their_label) ?

		options.their_label : theirs->path;

	their_mmfile.ptr = (char *)theirs->ptr;

	their_mmfile.size = theirs->size;

	if (options.favor == GIT_MERGE_FILE_FAVOR_OURS)

		xmparam.favor = XDL_MERGE_FAVOR_OURS;

	else if (options.favor == GIT_MERGE_FILE_FAVOR_THEIRS)

		xmparam.favor = XDL_MERGE_FAVOR_THEIRS;

	else if (options.favor == GIT_MERGE_FILE_FAVOR_UNION)

		xmparam.favor = XDL_MERGE_FAVOR_UNION;

	xmparam.level = (options.flags & GIT_MERGE_FILE_SIMPLIFY_ALNUM) ?

		XDL_MERGE_ZEALOUS_ALNUM : XDL_MERGE_ZEALOUS;

	if (options.flags & GIT_MERGE_FILE_STYLE_DIFF3)

		xmparam.style = XDL_MERGE_DIFF3;

	if (options.flags & GIT_MERGE_FILE_IGNORE_WHITESPACE)

		xmparam.xpp.flags |= XDF_IGNORE_WHITESPACE;

	if (options.flags & GIT_MERGE_FILE_IGNORE_WHITESPACE_CHANGE)

		xmparam.xpp.flags |= XDF_IGNORE_WHITESPACE_CHANGE;

	if (options.flags & GIT_MERGE_FILE_IGNORE_WHITESPACE_EOL)

		xmparam.xpp.flags |= XDF_IGNORE_WHITESPACE_AT_EOL;

	if (options.flags & GIT_MERGE_FILE_DIFF_PATIENCE)

		xmparam.xpp.flags |= XDF_PATIENCE_DIFF;

	if (options.flags & GIT_MERGE_FILE_DIFF_MINIMAL)

		xmparam.xpp.flags |= XDF_NEED_MINIMAL;

	if ((xdl_result = xdl_merge(&ancestor_mmfile, &our_mmfile,

		&their_mmfile, &xmparam, &mmbuffer)) < 0) {

		giterr_set(GITERR_MERGE, "failed to merge files");

		error = -1;

		goto done;

	}

	path = git_merge_file__best_path(

		ancestor ? ancestor->path : NULL,

		ours->path,

		theirs->path);

	if (path != NULL && (out->path = git__strdup(path)) == NULL) {

		error = -1;

		goto done;

	}

	out->automergeable = (xdl_result == 0);

	out->ptr = (const char *)mmbuffer.ptr;

	out->len = mmbuffer.size;

	out->mode = git_merge_file__best_mode(

		ancestor ? ancestor->mode : 0,

		ours->mode,

		theirs->mode);

done:

	if (error < 0)

		git_merge_file_result_free(out);

	return error;

}

static bool merge_file__is_binary(const git_merge_file_input *file)

{

	size_t len = file ? file->size : 0;

	if (len > GIT_XDIFF_MAX_SIZE)

		return true;

	if (len > GIT_MERGE_FILE_BINARY_SIZE)

		len = GIT_MERGE_FILE_BINARY_SIZE;

	return len ? (memchr(file->ptr, 0, len) != NULL) : false;

}

static int merge_file__binary(

	git_merge_file_result *out,

	const git_merge_file_input *ours,

	const git_merge_file_input *theirs,

	const git_merge_file_options *given_opts)

{

	const git_merge_file_input *favored = NULL;

	memset(out, 0x0, sizeof(git_merge_file_result));

	if (given_opts && given_opts->favor == GIT_MERGE_FILE_FAVOR_OURS)

		favored = ours;

	else if (given_opts && given_opts->favor == GIT_MERGE_FILE_FAVOR_THEIRS)

		favored = theirs;

	else

		goto done;

	if ((out->path = git__strdup(favored->path)) == NULL ||

		(out->ptr = git__malloc(favored->size)) == NULL)

		goto done;

	memcpy((char *)out->ptr, favored->ptr, favored->size);

	out->len = favored->size;

	out->mode = favored->mode;

	out->automergeable = 1;

done:

	return 0;

}

static int merge_file__from_inputs(

	git_merge_file_result *out,

	const git_merge_file_input *ancestor,

	const git_merge_file_input *ours,

	const git_merge_file_input *theirs,

	const git_merge_file_options *given_opts)

{

	if (merge_file__is_binary(ancestor) ||

		merge_file__is_binary(ours) ||

		merge_file__is_binary(theirs))

		return merge_file__binary(out, ours, theirs, given_opts);

	return merge_file__xdiff(out, ancestor, ours, theirs, given_opts);

}

static git_merge_file_input *git_merge_file__normalize_inputs(

	git_merge_file_input *out,

	const git_merge_file_input *given)

{

	memcpy(out, given, sizeof(git_merge_file_input));

	if (!out->path)

		out->path = "file.txt";

	if (!out->mode)

		out->mode = 0100644;

	return out;

}

int git_merge_file(

	git_merge_file_result *out,

	const git_merge_file_input *ancestor,

	const git_merge_file_input *ours,

	const git_merge_file_input *theirs,

	const git_merge_file_options *options)

{

	git_merge_file_input inputs[3] = { {0} };

	assert(out && ours && theirs);

	memset(out, 0x0, sizeof(git_merge_file_result));

	if (ancestor)

		ancestor = git_merge_file__normalize_inputs(&inputs[0], ancestor);

	ours = git_merge_file__normalize_inputs(&inputs[1], ours);

	theirs = git_merge_file__normalize_inputs(&inputs[2], theirs);

	return merge_file__from_inputs(out, ancestor, ours, theirs, options);

}

int git_merge_file_from_index(

	git_merge_file_result *out,

	git_repository *repo,

	const git_index_entry *ancestor,

	const git_index_entry *ours,

	const git_index_entry *theirs,

	const git_merge_file_options *options)

{

	git_merge_file_input *ancestor_ptr = NULL,

		ancestor_input = {0}, our_input = {0}, their_input = {0};

	git_odb *odb = NULL;

	git_odb_object *odb_object[3] = { 0 };

	int error = 0;

	assert(out && repo && ours && theirs);

	memset(out, 0x0, sizeof(git_merge_file_result));

	if ((error = git_repository_odb(&odb, repo)) < 0)

		goto done;

	if (ancestor) {

		if ((error = git_merge_file__input_from_index(

			&ancestor_input, &odb_object[0], odb, ancestor)) < 0)

			goto done;

		ancestor_ptr = &ancestor_input;

	}

	if ((error = git_merge_file__input_from_index(

			&our_input, &odb_object[1], odb, ours)) < 0 ||

		(error = git_merge_file__input_from_index(

			&their_input, &odb_object[2], odb, theirs)) < 0)

		goto done;

	error = merge_file__from_inputs(out,

		ancestor_ptr, &our_input, &their_input, options);

done:

	git_odb_object_free(odb_object[0]);

	git_odb_object_free(odb_object[1]);

	git_odb_object_free(odb_object[2]);

	git_odb_free(odb);

	return error;

}

void git_merge_file_result_free(git_merge_file_result *result)

{

	if (result == NULL)

		return;

	git__free((char *)result->path);

	git__free((char *)result->ptr);

}