/*
    * Copyright (C) 2010, Christian Halstrick <christian.halstrick@sap.com>,
    * Copyright (C) 2010-2012, Matthias Sohn <matthias.sohn@sap.com>
    * Copyright (C) 2012, Research In Motion Limited
    * Copyright (C) 2017, Obeo (mathieu.cartaud@obeo.fr)
    * Copyright (C) 2018, 2022 Thomas Wolf <twolf@apache.org>
    * Copyright (C) 2022, Google Inc. and others
    *
    * This program and the accompanying materials are made available under the
   * terms of the Eclipse Distribution License v. 1.0 which is available at
   * https://www.eclipse.org/org/documents/edl-v10.php.
   *
   * SPDX-License-Identifier: BSD-3-Clause
   */
  package org.eclipse.jgit.merge;
  
  import static java.nio.charset.StandardCharsets.UTF_8;
  import static java.time.Instant.EPOCH;
  import static org.eclipse.jgit.diff.DiffAlgorithm.SupportedAlgorithm.HISTOGRAM;
  import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_DIFF_SECTION;
  import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_ALGORITHM;
  import static org.eclipse.jgit.lib.Constants.OBJ_BLOB;
  
  import java.io.Closeable;
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.time.Instant;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Objects;
  import java.util.TreeMap;
  
  import org.eclipse.jgit.annotations.NonNull;
  import org.eclipse.jgit.annotations.Nullable;
  import org.eclipse.jgit.attributes.Attribute;
  import org.eclipse.jgit.attributes.Attributes;
  import org.eclipse.jgit.diff.DiffAlgorithm;
  import org.eclipse.jgit.diff.DiffAlgorithm.SupportedAlgorithm;
  import org.eclipse.jgit.diff.RawText;
  import org.eclipse.jgit.diff.RawTextComparator;
  import org.eclipse.jgit.diff.Sequence;
  import org.eclipse.jgit.dircache.DirCache;
  import org.eclipse.jgit.dircache.DirCacheBuildIterator;
  import org.eclipse.jgit.dircache.DirCacheBuilder;
  import org.eclipse.jgit.dircache.DirCacheCheckout;
  import org.eclipse.jgit.dircache.DirCacheCheckout.CheckoutMetadata;
  import org.eclipse.jgit.dircache.DirCacheCheckout.StreamSupplier;
  import org.eclipse.jgit.dircache.DirCacheEntry;
  import org.eclipse.jgit.errors.BinaryBlobException;
  import org.eclipse.jgit.errors.IndexWriteException;
  import org.eclipse.jgit.errors.NoWorkTreeException;
  import org.eclipse.jgit.internal.JGitText;
  import org.eclipse.jgit.lib.Config;
  import org.eclipse.jgit.lib.ConfigConstants;
  import org.eclipse.jgit.lib.Constants;
  import org.eclipse.jgit.lib.CoreConfig.EolStreamType;
  import org.eclipse.jgit.lib.FileMode;
  import org.eclipse.jgit.lib.ObjectId;
  import org.eclipse.jgit.lib.ObjectInserter;
  import org.eclipse.jgit.lib.ObjectLoader;
  import org.eclipse.jgit.lib.ObjectReader;
  import org.eclipse.jgit.lib.Repository;
  import org.eclipse.jgit.revwalk.RevTree;
  import org.eclipse.jgit.storage.pack.PackConfig;
  import org.eclipse.jgit.submodule.SubmoduleConflict;
  import org.eclipse.jgit.treewalk.AbstractTreeIterator;
  import org.eclipse.jgit.treewalk.CanonicalTreeParser;
  import org.eclipse.jgit.treewalk.NameConflictTreeWalk;
  import org.eclipse.jgit.treewalk.TreeWalk;
  import org.eclipse.jgit.treewalk.TreeWalk.OperationType;
  import org.eclipse.jgit.treewalk.WorkingTreeIterator;
  import org.eclipse.jgit.treewalk.WorkingTreeOptions;
  import org.eclipse.jgit.treewalk.filter.TreeFilter;
  import org.eclipse.jgit.util.FS;
  import org.eclipse.jgit.util.LfsFactory;
  import org.eclipse.jgit.util.LfsFactory.LfsInputStream;
  import org.eclipse.jgit.util.TemporaryBuffer;
  import org.eclipse.jgit.util.io.EolStreamTypeUtil;
  
  /**
   * A three-way merger performing a content-merge if necessary
   */
  public class ResolveMerger extends ThreeWayMerger {
  
  	/**
  	 * Handles work tree updates on both the checkout and the index.
  	 * <p>
  	 * You should use a single instance for all of your file changes. In case of
  	 * an error, make sure your instance is released, and initiate a new one if
  	 * necessary.
  	 *
 	 * @since 6.3.1
 	 */
 	protected static class WorkTreeUpdater implements Closeable {
 
 		/**
 		 * The result of writing the index changes.
 		 */
 		public static class Result {
 
 			private final List<String> modifiedFiles = new LinkedList<>();
 
 			private final List<String> failedToDelete = new LinkedList<>();
 
 			private ObjectId treeId = null;
 
 			/**
 			 * @return Modified tree ID if any, or null otherwise.
 			 */
 			public ObjectId getTreeId() {
 				return treeId;
 			}
 
 			/**
 			 * @return Files that couldn't be deleted.
 			 */
 			public List<String> getFailedToDelete() {
 				return failedToDelete;
 			}
 
 			/**
 			 * @return Files modified during this operation.
 			 */
 			public List<String> getModifiedFiles() {
 				return modifiedFiles;
 			}
 		}
 
 		Result result = new Result();
 
 		/**
 		 * The repository this handler operates on.
 		 */
 		@Nullable
 		private final Repository repo;
 
 		/**
 		 * Set to true if this operation should work in-memory. The repo's
 		 * dircache and workingtree are not touched by this method. Eventually
 		 * needed files are created as temporary files and a new empty,
 		 * in-memory dircache will be used instead the repo's one. Often used
 		 * for bare repos where the repo doesn't even have a workingtree and
 		 * dircache.
 		 */
 		private final boolean inCore;
 
 		private final ObjectInserter inserter;
 
 		private final ObjectReader reader;
 
 		private DirCache dirCache;
 
 		private boolean implicitDirCache = false;
 
 		/**
 		 * Builder to update the dir cache during this operation.
 		 */
 		private DirCacheBuilder builder;
 
 		/**
 		 * The {@link WorkingTreeOptions} are needed to determine line endings
 		 * for affected files.
 		 */
 		private WorkingTreeOptions workingTreeOptions;
 
 		/**
 		 * The size limit (bytes) which controls a file to be stored in
 		 * {@code Heap} or {@code LocalFile} during the operation.
 		 */
 		private int inCoreFileSizeLimit;
 
 		/**
 		 * If the operation has nothing to do for a file but check it out at the
 		 * end of the operation, it can be added here.
 		 */
 		private final Map<String, DirCacheEntry> toBeCheckedOut = new HashMap<>();
 
 		/**
 		 * Files in this list will be deleted from the local copy at the end of
 		 * the operation.
 		 */
 		private final TreeMap<String, File> toBeDeleted = new TreeMap<>();
 
 		/**
 		 * Keeps {@link CheckoutMetadata} for {@link #checkout()}.
 		 */
 		private Map<String, CheckoutMetadata> checkoutMetadataByPath;
 
 		/**
 		 * Keeps {@link CheckoutMetadata} for {@link #revertModifiedFiles()}.
 		 */
 		private Map<String, CheckoutMetadata> cleanupMetadataByPath;
 
 		/**
 		 * Whether the changes were successfully written.
 		 */
 		private boolean indexChangesWritten;
 
 		/**
 		 * @param repo
 		 *            the {@link Repository}.
 		 * @param dirCache
 		 *            if set, use the provided dir cache. Otherwise, use the
 		 *            default repository one
 		 */
 		private WorkTreeUpdater(Repository repo, DirCache dirCache) {
 			this.repo = repo;
 			this.dirCache = dirCache;
 
 			this.inCore = false;
 			this.inserter = repo.newObjectInserter();
 			this.reader = inserter.newReader();
 			Config config = repo.getConfig();
 			this.workingTreeOptions = config.get(WorkingTreeOptions.KEY);
 			this.inCoreFileSizeLimit = getInCoreFileSizeLimit(config);
 			this.checkoutMetadataByPath = new HashMap<>();
 			this.cleanupMetadataByPath = new HashMap<>();
 		}
 
 		/**
 		 * Creates a new {@link WorkTreeUpdater} for the given repository.
 		 *
 		 * @param repo
 		 *            the {@link Repository}.
 		 * @param dirCache
 		 *            if set, use the provided dir cache. Otherwise, use the
 		 *            default repository one
 		 * @return the {@link WorkTreeUpdater}.
 		 */
 		public static WorkTreeUpdater createWorkTreeUpdater(Repository repo,
 				DirCache dirCache) {
 			return new WorkTreeUpdater(repo, dirCache);
 		}
 
 		/**
 		 * @param repo
 		 *            the {@link Repository}.
 		 * @param dirCache
 		 *            if set, use the provided dir cache. Otherwise, creates a
 		 *            new one
 		 * @param oi
 		 *            to use for writing the modified objects with.
 		 */
 		private WorkTreeUpdater(Repository repo, DirCache dirCache,
 				ObjectInserter oi) {
 			this.repo = repo;
 			this.dirCache = dirCache;
 			this.inserter = oi;
 
 			this.inCore = true;
 			this.reader = oi.newReader();
 			if (repo != null) {
 				this.inCoreFileSizeLimit = getInCoreFileSizeLimit(
 						repo.getConfig());
 			}
 		}
 
 		/**
 		 * Creates a new {@link WorkTreeUpdater} that works in memory only.
 		 *
 		 * @param repo
 		 *            the {@link Repository}.
 		 * @param dirCache
 		 *            if set, use the provided dir cache. Otherwise, creates a
 		 *            new one
 		 * @param oi
 		 *            to use for writing the modified objects with.
 		 * @return the {@link WorkTreeUpdater}
 		 */
 		public static WorkTreeUpdater createInCoreWorkTreeUpdater(
 				Repository repo, DirCache dirCache, ObjectInserter oi) {
 			return new WorkTreeUpdater(repo, dirCache, oi);
 		}
 
 		private static int getInCoreFileSizeLimit(Config config) {
 			return config.getInt(ConfigConstants.CONFIG_MERGE_SECTION,
 					ConfigConstants.CONFIG_KEY_IN_CORE_LIMIT, 10 << 20);
 		}
 
 		/**
 		 * Gets the size limit for in-core files in this config.
 		 *
 		 * @return the size
 		 */
 		public int getInCoreFileSizeLimit() {
 			return inCoreFileSizeLimit;
 		}
 
 		/**
 		 * Gets dir cache for the repo. Locked if not inCore.
 		 *
 		 * @return the result dir cache
 		 * @throws IOException
 		 *             is case the dir cache cannot be read
 		 */
 		public DirCache getLockedDirCache() throws IOException {
 			if (dirCache == null) {
 				implicitDirCache = true;
 				if (inCore) {
 					dirCache = DirCache.newInCore();
 				} else {
 					dirCache = nonNullRepo().lockDirCache();
 				}
 			}
 			if (builder == null) {
 				builder = dirCache.builder();
 			}
 			return dirCache;
 		}
 
 		/**
 		 * Creates a {@link DirCacheBuildIterator} for the builder of this
 		 * {@link WorkTreeUpdater}.
 		 *
 		 * @return the {@link DirCacheBuildIterator}
 		 */
 		public DirCacheBuildIterator createDirCacheBuildIterator() {
 			return new DirCacheBuildIterator(builder);
 		}
 
 		/**
 		 * Writes the changes to the working tree (but not to the index).
 		 *
 		 * @param shouldCheckoutTheirs
 		 *            before committing the changes
 		 * @throws IOException
 		 *             if any of the writes fail
 		 */
 		public void writeWorkTreeChanges(boolean shouldCheckoutTheirs)
 				throws IOException {
 			handleDeletedFiles();
 
 			if (inCore) {
 				builder.finish();
 				return;
 			}
 			if (shouldCheckoutTheirs) {
 				// No problem found. The only thing left to be done is to
 				// check out all files from "theirs" which have been selected to
 				// go into the new index.
 				checkout();
 			}
 
 			// All content operations are successfully done. If we can now write
 			// the
 			// new index we are on quite safe ground. Even if the checkout of
 			// files coming from "theirs" fails the user can work around such
 			// failures by checking out the index again.
 			if (!builder.commit()) {
 				revertModifiedFiles();
 				throw new IndexWriteException();
 			}
 		}
 
 		/**
 		 * Writes the changes to the index.
 		 *
 		 * @return the {@link Result} of the operation.
 		 * @throws IOException
 		 *             if any of the writes fail
 		 */
 		public Result writeIndexChanges() throws IOException {
 			result.treeId = getLockedDirCache().writeTree(inserter);
 			indexChangesWritten = true;
 			return result;
 		}
 
 		/**
 		 * Adds a {@link DirCacheEntry} for direct checkout and remembers its
 		 * {@link CheckoutMetadata}.
 		 *
 		 * @param path
 		 *            of the entry
 		 * @param entry
 		 *            to add
 		 * @param cleanupStreamType
 		 *            to use for the cleanup metadata
 		 * @param cleanupSmudgeCommand
 		 *            to use for the cleanup metadata
 		 * @param checkoutStreamType
 		 *            to use for the checkout metadata
 		 * @param checkoutSmudgeCommand
 		 *            to use for the checkout metadata
 		 */
 		public void addToCheckout(String path, DirCacheEntry entry,
 				EolStreamType cleanupStreamType, String cleanupSmudgeCommand,
 				EolStreamType checkoutStreamType,
 				String checkoutSmudgeCommand) {
 			if (entry != null) {
 				// In some cases, we just want to add the metadata.
 				toBeCheckedOut.put(path, entry);
 			}
 			addCheckoutMetadata(cleanupMetadataByPath, path, cleanupStreamType,
 					cleanupSmudgeCommand);
 			addCheckoutMetadata(checkoutMetadataByPath, path,
 					checkoutStreamType, checkoutSmudgeCommand);
 		}
 
 		/**
 		 * Gets a map which maps the paths of files which have to be checked out
 		 * because the operation created new fully-merged content for this file
 		 * into the index.
 		 * <p>
 		 * This means: the operation wrote a new stage 0 entry for this path.
 		 * </p>
 		 *
 		 * @return the map
 		 */
 		public Map<String, DirCacheEntry> getToBeCheckedOut() {
 			return toBeCheckedOut;
 		}
 
 		/**
 		 * Remembers the given file to be deleted.
 		 * <p>
 		 * Note the actual deletion is only done in
 		 * {@link #writeWorkTreeChanges}.
 		 *
 		 * @param path
 		 *            of the file to be deleted
 		 * @param file
 		 *            to be deleted
 		 * @param streamType
 		 *            to use for cleanup metadata
 		 * @param smudgeCommand
 		 *            to use for cleanup metadata
 		 */
 		public void deleteFile(String path, File file, EolStreamType streamType,
 				String smudgeCommand) {
 			toBeDeleted.put(path, file);
 			if (file != null && file.isFile()) {
 				addCheckoutMetadata(cleanupMetadataByPath, path, streamType,
 						smudgeCommand);
 			}
 		}
 
 		/**
 		 * Remembers the {@link CheckoutMetadata} for the given path; it may be
 		 * needed in {@link #checkout()} or in {@link #revertModifiedFiles()}.
 		 *
 		 * @param map
 		 *            to add the metadata to
 		 * @param path
 		 *            of the current node
 		 * @param streamType
 		 *            to use for the metadata
 		 * @param smudgeCommand
 		 *            to use for the metadata
 		 */
 		private void addCheckoutMetadata(Map<String, CheckoutMetadata> map,
 				String path, EolStreamType streamType, String smudgeCommand) {
 			if (inCore || map == null) {
 				return;
 			}
 			map.put(path, new CheckoutMetadata(streamType, smudgeCommand));
 		}
 
 		/**
 		 * Detects if CRLF conversion has been configured.
 		 * <p>
 		 * </p>
 		 * See {@link EolStreamTypeUtil#detectStreamType} for more info.
 		 *
 		 * @param attributes
 		 *            of the file for which the type is to be detected
 		 * @return the detected type
 		 */
 		public EolStreamType detectCheckoutStreamType(Attributes attributes) {
 			if (inCore) {
 				return null;
 			}
 			return EolStreamTypeUtil.detectStreamType(OperationType.CHECKOUT_OP,
 					workingTreeOptions, attributes);
 		}
 
 		private void handleDeletedFiles() {
 			// Iterate in reverse so that "folder/file" is deleted before
 			// "folder". Otherwise, this could result in a failing path because
 			// of a non-empty directory, for which delete() would fail.
 			for (String path : toBeDeleted.descendingKeySet()) {
 				File file = inCore ? null : toBeDeleted.get(path);
 				if (file != null && !file.delete()) {
 					if (!file.isDirectory()) {
 						result.failedToDelete.add(path);
 					}
 				}
 			}
 		}
 
 		/**
 		 * Marks the given path as modified in the operation.
 		 *
 		 * @param path
 		 *            to mark as modified
 		 */
 		public void markAsModified(String path) {
 			result.modifiedFiles.add(path);
 		}
 
 		/**
 		 * Gets the list of files which were modified in this operation.
 		 *
 		 * @return the list
 		 */
 		public List<String> getModifiedFiles() {
 			return result.modifiedFiles;
 		}
 
 		private void checkout() throws NoWorkTreeException, IOException {
 			for (Map.Entry<String, DirCacheEntry> entry : toBeCheckedOut
 					.entrySet()) {
 				DirCacheEntry dirCacheEntry = entry.getValue();
 				if (dirCacheEntry.getFileMode() == FileMode.GITLINK) {
 					new File(nonNullRepo().getWorkTree(), entry.getKey())
 							.mkdirs();
 				} else {
 					DirCacheCheckout.checkoutEntry(repo, dirCacheEntry, reader,
 							false, checkoutMetadataByPath.get(entry.getKey()),
 							workingTreeOptions);
 					result.modifiedFiles.add(entry.getKey());
 				}
 			}
 		}
 
 		/**
 		 * Reverts any uncommitted changes in the worktree. We know that for all
 		 * modified files the old content was in the old index and the index
 		 * contained only stage 0. In case of inCore operation just clear the
 		 * history of modified files.
 		 *
 		 * @throws IOException
 		 *             in case the cleaning up failed
 		 */
 		public void revertModifiedFiles() throws IOException {
 			if (inCore) {
 				result.modifiedFiles.clear();
 				return;
 			}
 			if (indexChangesWritten) {
 				return;
 			}
 			for (String path : result.modifiedFiles) {
 				DirCacheEntry entry = dirCache.getEntry(path);
 				if (entry != null) {
 					DirCacheCheckout.checkoutEntry(repo, entry, reader, false,
 							cleanupMetadataByPath.get(path),
 							workingTreeOptions);
 				}
 			}
 		}
 
 		@Override
 		public void close() throws IOException {
 			if (implicitDirCache) {
 				dirCache.unlock();
 			}
 		}
 
 		/**
 		 * Updates the file in the checkout with the given content.
 		 *
 		 * @param inputStream
 		 *            the content to be updated
 		 * @param streamType
 		 *            for parsing the content
 		 * @param smudgeCommand
 		 *            for formatting the content
 		 * @param path
 		 *            of the file to be updated
 		 * @param file
 		 *            to be updated
 		 * @throws IOException
 		 *             if the file cannot be updated
 		 */
 		public void updateFileWithContent(StreamSupplier inputStream,
 				EolStreamType streamType, String smudgeCommand, String path,
 				File file) throws IOException {
 			if (inCore) {
 				return;
 			}
 			CheckoutMetadata metadata = new CheckoutMetadata(streamType,
 					smudgeCommand);
 
 			try (OutputStream outputStream = new FileOutputStream(file)) {
 				DirCacheCheckout.getContent(repo, path, metadata, inputStream,
 						workingTreeOptions, outputStream);
 			}
 		}
 
 		/**
 		 * Creates a path with the given content, and adds it to the specified
 		 * stage to the index builder.
 		 *
 		 * @param input
 		 *            the content to be updated
 		 * @param path
 		 *            of the file to be updated
 		 * @param fileMode
 		 *            of the modified file
 		 * @param entryStage
 		 *            of the new entry
 		 * @param lastModified
 		 *            instant of the modified file
 		 * @param len
 		 *            of the content
 		 * @param lfsAttribute
 		 *            for checking for LFS enablement
 		 * @return the entry which was added to the index
 		 * @throws IOException
 		 *             if inserting the content fails
 		 */
 		public DirCacheEntry insertToIndex(InputStream input, byte[] path,
 				FileMode fileMode, int entryStage, Instant lastModified,
 				int len, Attribute lfsAttribute) throws IOException {
 			return addExistingToIndex(insertResult(input, lfsAttribute, len),
 					path, fileMode, entryStage, lastModified, len);
 		}
 
 		/**
 		 * Adds a path with the specified stage to the index builder.
 		 *
 		 * @param objectId
 		 *            of the existing object to add
 		 * @param path
 		 *            of the modified file
 		 * @param fileMode
 		 *            of the modified file
 		 * @param entryStage
 		 *            of the new entry
 		 * @param lastModified
 		 *            instant of the modified file
 		 * @param len
 		 *            of the modified file content
 		 * @return the entry which was added to the index
 		 */
 		public DirCacheEntry addExistingToIndex(ObjectId objectId, byte[] path,
 				FileMode fileMode, int entryStage, Instant lastModified,
 				int len) {
 			DirCacheEntry dce = new DirCacheEntry(path, entryStage);
 			dce.setFileMode(fileMode);
 			if (lastModified != null) {
 				dce.setLastModified(lastModified);
 			}
 			dce.setLength(inCore ? 0 : len);
 			dce.setObjectId(objectId);
 			builder.add(dce);
 			return dce;
 		}
 
 		private ObjectId insertResult(InputStream input, Attribute lfsAttribute,
 				long length) throws IOException {
 			try (LfsInputStream is = LfsFactory.getInstance()
 					.applyCleanFilter(repo, input, length, lfsAttribute)) {
 				return inserter.insert(OBJ_BLOB, is.getLength(), is);
 			}
 		}
 
 		/**
 		 * Gets the non-null repository instance of this
 		 * {@link WorkTreeUpdater}.
 		 *
 		 * @return non-null repository instance
 		 * @throws NullPointerException
 		 *             if the handler was constructed without a repository.
 		 */
 		@NonNull
 		private Repository nonNullRepo() throws NullPointerException {
 			return Objects.requireNonNull(repo,
 					() -> JGitText.get().repositoryIsRequired);
 		}
 	}
 
 	/**
 	 * If the merge fails (means: not stopped because of unresolved conflicts)
 	 * this enum is used to explain why it failed
 	 */
 	public enum MergeFailureReason {
 		/** the merge failed because of a dirty index */
 		DIRTY_INDEX,
 		/** the merge failed because of a dirty workingtree */
 		DIRTY_WORKTREE,
 		/** the merge failed because of a file could not be deleted */
 		COULD_NOT_DELETE
 	}
 
 	/**
 	 * The tree walk which we'll iterate over to merge entries.
 	 *
 	 * @since 3.4
 	 */
 	protected NameConflictTreeWalk tw;
 
 	/**
 	 * string versions of a list of commit SHA1s
 	 *
 	 * @since 3.0
 	 */
 	protected String[] commitNames;
 
 	/**
 	 * Index of the base tree within the {@link #tw tree walk}.
 	 *
 	 * @since 3.4
 	 */
 	protected static final int T_BASE = 0;
 
 	/**
 	 * Index of our tree in withthe {@link #tw tree walk}.
 	 *
 	 * @since 3.4
 	 */
 	protected static final int T_OURS = 1;
 
 	/**
 	 * Index of their tree within the {@link #tw tree walk}.
 	 *
 	 * @since 3.4
 	 */
 	protected static final int T_THEIRS = 2;
 
 	/**
 	 * Index of the index tree within the {@link #tw tree walk}.
 	 *
 	 * @since 3.4
 	 */
 	protected static final int T_INDEX = 3;
 
 	/**
 	 * Index of the working directory tree within the {@link #tw tree walk}.
 	 *
 	 * @since 3.4
 	 */
 	protected static final int T_FILE = 4;
 
 	/**
 	 * Handler for repository I/O actions.
 	 *
 	 * @since 6.3
 	 */
 	protected WorkTreeUpdater workTreeUpdater;
 
 	/**
 	 * merge result as tree
 	 *
 	 * @since 3.0
 	 */
 	protected ObjectId resultTree;
 
 	/**
 	 * Files modified during this operation. Note this list is only updated after a successful write.
 	 */
 	protected List<String> modifiedFiles = new ArrayList<>();
 
 	/**
 	 * Paths that could not be merged by this merger because of an unsolvable
 	 * conflict.
 	 *
 	 * @since 3.4
 	 */
 	protected List<String> unmergedPaths = new ArrayList<>();
 
 	/**
 	 * Low-level textual merge results. Will be passed on to the callers in case
 	 * of conflicts.
 	 *
 	 * @since 3.4
 	 */
 	protected Map<String, MergeResult<? extends Sequence>> mergeResults = new HashMap<>();
 
 	/**
 	 * Paths for which the merge failed altogether.
 	 *
 	 * @since 3.4
 	 */
 	protected Map<String, MergeFailureReason> failingPaths = new HashMap<>();
 
 	/**
 	 * Updated as we merge entries of the tree walk. Tells us whether we should
 	 * recurse into the entry if it is a subtree.
 	 *
 	 * @since 3.4
 	 */
 	protected boolean enterSubtree;
 
 	/**
 	 * Set to true if this merge should work in-memory. The repos dircache and
 	 * workingtree are not touched by this method. Eventually needed files are
 	 * created as temporary files and a new empty, in-memory dircache will be
 	 * used instead the repo's one. Often used for bare repos where the repo
 	 * doesn't even have a workingtree and dircache.
 	 * @since 3.0
 	 */
 	protected boolean inCore;
 
 	/**
 	 * Directory cache
 	 * @since 3.0
 	 */
 	protected DirCache dircache;
 
 	/**
 	 * The iterator to access the working tree. If set to <code>null</code> this
 	 * merger will not touch the working tree.
 	 * @since 3.0
 	 */
 	protected WorkingTreeIterator workingTreeIterator;
 
 	/**
 	 * our merge algorithm
 	 * @since 3.0
 	 */
 	protected MergeAlgorithm mergeAlgorithm;
 
 	/**
 	 * The {@link ContentMergeStrategy} to use for "resolve" and "recursive"
 	 * merges.
 	 */
 	@NonNull
 	private ContentMergeStrategy contentStrategy = ContentMergeStrategy.CONFLICT;
 
 	private static MergeAlgorithm getMergeAlgorithm(Config config) {
 		SupportedAlgorithm diffAlg = config.getEnum(
 				CONFIG_DIFF_SECTION, null, CONFIG_KEY_ALGORITHM,
 				HISTOGRAM);
 		return new MergeAlgorithm(DiffAlgorithm.getAlgorithm(diffAlg));
 	}
 
 	private static String[] defaultCommitNames() {
 		return new String[]{"BASE", "OURS", "THEIRS"}; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
 	}
 
 	private static final Attributes NO_ATTRIBUTES = new Attributes();
 
 	/**
 	 * Constructor for ResolveMerger.
 	 *
 	 * @param local
 	 *            the {@link org.eclipse.jgit.lib.Repository}.
 	 * @param inCore
 	 *            a boolean.
 	 */
 	protected ResolveMerger(Repository local, boolean inCore) {
 		super(local);
 		Config config = local.getConfig();
 		mergeAlgorithm = getMergeAlgorithm(config);
 		commitNames = defaultCommitNames();
 		this.inCore = inCore;
 	}
 
 	/**
 	 * Constructor for ResolveMerger.
 	 *
 	 * @param local
 	 *            the {@link org.eclipse.jgit.lib.Repository}.
 	 */
 	protected ResolveMerger(Repository local) {
 		this(local, false);
 	}
 
 	/**
 	 * Constructor for ResolveMerger.
 	 *
 	 * @param inserter
 	 *            an {@link org.eclipse.jgit.lib.ObjectInserter} object.
 	 * @param config
 	 *            the repository configuration
 	 * @since 4.8
 	 */
 	protected ResolveMerger(ObjectInserter inserter, Config config) {
 		super(inserter);
 		mergeAlgorithm = getMergeAlgorithm(config);
 		commitNames = defaultCommitNames();
 		inCore = true;
 	}
 
 	/**
 	 * Retrieves the content merge strategy for content conflicts.
 	 *
 	 * @return the {@link ContentMergeStrategy} in effect
 	 * @since 5.12
 	 */
 	@NonNull
 	public ContentMergeStrategy getContentMergeStrategy() {
 		return contentStrategy;
 	}
 
 	/**
 	 * Sets the content merge strategy for content conflicts.
 	 *
 	 * @param strategy
 	 *            {@link ContentMergeStrategy} to use
 	 * @since 5.12
 	 */
 	public void setContentMergeStrategy(ContentMergeStrategy strategy) {
 		contentStrategy = strategy == null ? ContentMergeStrategy.CONFLICT
 				: strategy;
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	protected boolean mergeImpl() throws IOException {
 		return mergeTrees(mergeBase(), sourceTrees[0], sourceTrees[1],
 				false);
 	}
 
 	/**
 	 * adds a new path with the specified stage to the index builder
 	 *
 	 * @param path
 	 * @param p
 	 * @param stage
 	 * @param lastMod
 	 * @param len
 	 * @return the entry which was added to the index
 	 */
 	private DirCacheEntry add(byte[] path, CanonicalTreeParser p, int stage,
 			Instant lastMod, long len) {
 		if (p != null && !p.getEntryFileMode().equals(FileMode.TREE)) {
 			return workTreeUpdater.addExistingToIndex(p.getEntryObjectId(), path,
 					p.getEntryFileMode(), stage,
 					lastMod, (int) len);
 		}
 		return null;
 	}
 
 	/**
 	 * Adds the conflict stages for the current path of {@link #tw} to the index
 	 * builder and returns the "theirs" stage; if present.
 	 *
 	 * @param base
 	 *            of the conflict
 	 * @param ours
 	 *            of the conflict
 	 * @param theirs
 	 *            of the conflict
 	 * @return the {@link DirCacheEntry} for the "theirs" stage, or {@code null}
 	 */
 	private DirCacheEntry addConflict(CanonicalTreeParser base,
 			CanonicalTreeParser ours, CanonicalTreeParser theirs) {
 		add(tw.getRawPath(), base, DirCacheEntry.STAGE_1, EPOCH, 0);
 		add(tw.getRawPath(), ours, DirCacheEntry.STAGE_2, EPOCH, 0);
 		return add(tw.getRawPath(), theirs, DirCacheEntry.STAGE_3, EPOCH, 0);
 	}
 
 	/**
 	 * adds a entry to the index builder which is a copy of the specified
 	 * DirCacheEntry
 	 *
 	 * @param e
 	 *            the entry which should be copied
 	 *
 	 * @return the entry which was added to the index
 	 */
 	private DirCacheEntry keep(DirCacheEntry e) {
 		return workTreeUpdater.addExistingToIndex(e.getObjectId(), e.getRawPath(), e.getFileMode(),
 				e.getStage(), e.getLastModifiedInstant(), e.getLength());
 	}
 
 	/**
 	 * Adds a {@link DirCacheEntry} for direct checkout and remembers its
 	 * {@link CheckoutMetadata}.
 	 *
 	 * @param path
 	 *            of the entry
 	 * @param entry
 	 *            to add
 	 * @param attributes
 	 *            the {@link Attributes} of the trees
 	 * @throws IOException
 	 *             if the {@link CheckoutMetadata} cannot be determined
 	 * @since 6.1
 	 */
 	protected void addToCheckout(String path, DirCacheEntry entry,
 			Attributes[] attributes)
 			throws IOException {
 		EolStreamType cleanupStreamType = workTreeUpdater.detectCheckoutStreamType(attributes[T_OURS]);
 		String cleanupSmudgeCommand = tw.getSmudgeCommand(attributes[T_OURS]);
 		EolStreamType checkoutStreamType = workTreeUpdater.detectCheckoutStreamType(attributes[T_THEIRS]);
 		String checkoutSmudgeCommand = tw.getSmudgeCommand(attributes[T_THEIRS]);
 		workTreeUpdater.addToCheckout(path, entry, cleanupStreamType, cleanupSmudgeCommand,
 				checkoutStreamType, checkoutSmudgeCommand);
 	}
 
 	/**
 	 * Remember a path for deletion, and remember its {@link CheckoutMetadata}
 	 * in case it has to be restored in the cleanUp.
 	 *
 	 * @param path
 	 *            of the entry
 	 * @param isFile
 	 *            whether it is a file
 	 * @param attributes
 	 *            to use for determining the {@link CheckoutMetadata}
 	 * @throws IOException
 	 *             if the {@link CheckoutMetadata} cannot be determined
 	 * @since 5.1
 	 */
 	protected void addDeletion(String path, boolean isFile,
 			Attributes attributes) throws IOException {
 		if (db == null || nonNullRepo().isBare() || !isFile)
 			return;
 
 		File file = new File(nonNullRepo().getWorkTree(), path);
 		EolStreamType streamType = workTreeUpdater.detectCheckoutStreamType(attributes);
 		String smudgeCommand = tw.getSmudgeCommand(attributes);
 		workTreeUpdater.deleteFile(path, file, streamType, smudgeCommand);
 	}
 
 	/**
 	 * Processes one path and tries to merge taking git attributes in account.
 	 * This method will do all trivial (not content) merges and will also detect
 	 * if a merge will fail. The merge will fail when one of the following is
 	 * true
 	 * <ul>
 	 * <li>the index entry does not match the entry in ours. When merging one
 	 * branch into the current HEAD, ours will point to HEAD and theirs will
 	 * point to the other branch. It is assumed that the index matches the HEAD
 	 * because it will only not match HEAD if it was populated before the merge
 	 * operation. But the merge commit should not accidentally contain
 	 * modifications done before the merge. Check the <a href=
 	 * "http://www.kernel.org/pub/software/scm/git/docs/git-read-tree.html#_3_way_merge"
 	 * >git read-tree</a> documentation for further explanations.</li>
 	 * <li>A conflict was detected and the working-tree file is dirty. When a
 	 * conflict is detected the content-merge algorithm will try to write a
 	 * merged version into the working-tree. If the file is dirty we would
 	 * override unsaved data.</li>
 	 * </ul>
 	 *
 	 * @param base
 	 *            the common base for ours and theirs
 	 * @param ours
 	 *            the ours side of the merge. When merging a branch into the
 	 *            HEAD ours will point to HEAD
 	 * @param theirs
 	 *            the theirs side of the merge. When merging a branch into the
 	 *            current HEAD theirs will point to the branch which is merged
 	 *            into HEAD.
 	 * @param index
 	 *            the index entry
 	 * @param work
 	 *            the file in the working tree
 	 * @param ignoreConflicts
 	 *            see
 	 *            {@link org.eclipse.jgit.merge.ResolveMerger#mergeTrees(AbstractTreeIterator, RevTree, RevTree, boolean)}
 	 * @param attributes
 	 *            the {@link Attributes} for the three trees
 	 * @return <code>false</code> if the merge will fail because the index entry
 	 *         didn't match ours or the working-dir file was dirty and a
 	 *         conflict occurred
 	 * @throws java.io.IOException
 	 * @since 6.1
 	 */
 	protected boolean processEntry(CanonicalTreeParser base,
 			CanonicalTreeParser ours, CanonicalTreeParser theirs,
 			DirCacheBuildIterator index, WorkingTreeIterator work,
 			boolean ignoreConflicts, Attributes[] attributes)
 			throws IOException {
 		enterSubtree = true;
 		final int modeO = tw.getRawMode(T_OURS);
 		final int modeT = tw.getRawMode(T_THEIRS);
 		final int modeB = tw.getRawMode(T_BASE);
 		boolean gitLinkMerging = isGitLink(modeO) || isGitLink(modeT)
 				|| isGitLink(modeB);
 		if (modeO == 0 && modeT == 0 && modeB == 0) {
 			// File is either untracked or new, staged but uncommitted
 			return true;
 		}
 
 		if (isIndexDirty()) {
 			return false;
 		}
 
 		DirCacheEntry ourDce = null;
 
 		if (index == null || index.getDirCacheEntry() == null) {
 			// create a fake DCE, but only if ours is valid. ours is kept only
 			// in case it is valid, so a null ourDce is ok in all other cases.
 			if (nonTree(modeO)) {
 				ourDce = new DirCacheEntry(tw.getRawPath());
 				ourDce.setObjectId(tw.getObjectId(T_OURS));
 				ourDce.setFileMode(tw.getFileMode(T_OURS));
 			}
 		} else {
 			ourDce = index.getDirCacheEntry();
 		}
 
 		if (nonTree(modeO) && nonTree(modeT) && tw.idEqual(T_OURS, T_THEIRS)) {
 			// OURS and THEIRS have equal content. Check the file mode
 			if (modeO == modeT) {
 				// content and mode of OURS and THEIRS are equal: it doesn't
 				// matter which one we choose. OURS is chosen. Since the index
 				// is clean (the index matches already OURS) we can keep the existing one
 				keep(ourDce);
 				// no checkout needed!
 				return true;
 			}
 			// same content but different mode on OURS and THEIRS.
 			// Try to merge the mode and report an error if this is
 			// not possible.
 			int newMode = mergeFileModes(modeB, modeO, modeT);
 			if (newMode != FileMode.MISSING.getBits()) {
 				if (newMode == modeO) {
 					// ours version is preferred
 					keep(ourDce);
 				} else {
 					// the preferred version THEIRS has a different mode
 					// than ours. Check it out!
 					if (isWorktreeDirty(work, ourDce)) {
 						return false;
 					}
 					// we know about length and lastMod only after we have
 					// written the new content.
 					// This will happen later. Set these values to 0 for know.
 					DirCacheEntry e = add(tw.getRawPath(), theirs,
 							DirCacheEntry.STAGE_0, EPOCH, 0);
 					addToCheckout(tw.getPathString(), e, attributes);
 				}
 				return true;
 			}
 			if (!ignoreConflicts) {
 				// FileModes are not mergeable. We found a conflict on modes.
 				// For conflicting entries we don't know lastModified and
 				// length.
 				// This path can be skipped on ignoreConflicts, so the caller
 				// could use virtual commit.
 				addConflict(base, ours, theirs);
 				unmergedPaths.add(tw.getPathString());
 				mergeResults.put(tw.getPathString(),
 						new MergeResult<>(Collections.emptyList()));
 			}
 			return true;
 		}
 
 		if (modeB == modeT && tw.idEqual(T_BASE, T_THEIRS)) {
 			// THEIRS was not changed compared to BASE. All changes must be in
 			// OURS. OURS is chosen. We can keep the existing entry.
 			if (ourDce != null) {
 				keep(ourDce);
 			}
 			// no checkout needed!
 			return true;
 		}
 
 		if (modeB == modeO && tw.idEqual(T_BASE, T_OURS)) {
 			// OURS was not changed compared to BASE. All changes must be in
 			// THEIRS. THEIRS is chosen.
 
 			// Check worktree before checking out THEIRS
 			if (isWorktreeDirty(work, ourDce)) {
 				return false;
 			}
 			if (nonTree(modeT)) {
 				// we know about length and lastMod only after we have written
 				// the new content.
 				// This will happen later. Set these values to 0 for know.
 				DirCacheEntry e = add(tw.getRawPath(), theirs,
 						DirCacheEntry.STAGE_0, EPOCH, 0);
 				if (e != null) {
 					addToCheckout(tw.getPathString(), e, attributes);
 				}
 				return true;
 			}
 			// we want THEIRS ... but THEIRS contains a folder or the
 			// deletion of the path. Delete what's in the working tree,
 			// which we know to be clean.
 			if (tw.getTreeCount() > T_FILE && tw.getRawMode(T_FILE) == 0) {
 				// Not present in working tree, so nothing to delete
 				return true;
 			}
 			if (modeT != 0 && modeT == modeB) {
 				// Base, ours, and theirs all contain a folder: don't delete
 				return true;
 			}
 			addDeletion(tw.getPathString(), nonTree(modeO), attributes[T_OURS]);
 			return true;
 		}
 
 		if (tw.isSubtree()) {
 			// file/folder conflicts: here I want to detect only file/folder
 			// conflict between ours and theirs. file/folder conflicts between
 			// base/index/workingTree and something else are not relevant or
 			// detected later
 			if (nonTree(modeO) != nonTree(modeT)) {
 				if (ignoreConflicts) {
 					// In case of merge failures, ignore this path instead of reporting unmerged, so
 					// a caller can use virtual commit. This will not result in files with conflict
 					// markers in the index/working tree. The actual diff on the path will be
 					// computed directly on children.
 					enterSubtree = false;
 					return true;
 				}
 				if (nonTree(modeB)) {
 					add(tw.getRawPath(), base, DirCacheEntry.STAGE_1, EPOCH, 0);
 				}
 				if (nonTree(modeO)) {
 					add(tw.getRawPath(), ours, DirCacheEntry.STAGE_2, EPOCH, 0);
 				}
 				if (nonTree(modeT)) {
 					add(tw.getRawPath(), theirs, DirCacheEntry.STAGE_3, EPOCH, 0);
 				}
 				unmergedPaths.add(tw.getPathString());
 				enterSubtree = false;
 				return true;
 			}
 
 			// ours and theirs are both folders or both files (and treewalk
 			// tells us we are in a subtree because of index or working-dir).
 			// If they are both folders no content-merge is required - we can
 			// return here.
 			if (!nonTree(modeO)) {
 				return true;
 			}
 
 			// ours and theirs are both files, just fall out of the if block
 			// and do the content merge
 		}
 
 		if (nonTree(modeO) && nonTree(modeT)) {
 			// Check worktree before modifying files
 			boolean worktreeDirty = isWorktreeDirty(work, ourDce);
 			if (!attributes[T_OURS].canBeContentMerged() && worktreeDirty) {
 				return false;
 			}
 
 			if (gitLinkMerging && ignoreConflicts) {
 				// Always select 'ours' in case of GITLINK merge failures so
 				// a caller can use virtual commit.
 				add(tw.getRawPath(), ours, DirCacheEntry.STAGE_0, EPOCH, 0);
 				return true;
 			} else if (gitLinkMerging) {
 				addConflict(base, ours, theirs);
 				MergeResult<SubmoduleConflict> result = createGitLinksMergeResult(
 						base, ours, theirs);
 				result.setContainsConflicts(true);
 				mergeResults.put(tw.getPathString(), result);
 				unmergedPaths.add(tw.getPathString());
 				return true;
 			} else if (!attributes[T_OURS].canBeContentMerged()) {
 				// File marked as binary
 				switch (getContentMergeStrategy()) {
 					case OURS:
 						keep(ourDce);
 						return true;
 					case THEIRS:
 						DirCacheEntry theirEntry = add(tw.getRawPath(), theirs,
 								DirCacheEntry.STAGE_0, EPOCH, 0);
 						addToCheckout(tw.getPathString(), theirEntry, attributes);
 						return true;
 					default:
 						break;
 				}
 				addConflict(base, ours, theirs);
 
 				// attribute merge issues are conflicts but not failures
 				unmergedPaths.add(tw.getPathString());
 				return true;
 			}
 
 			// Check worktree before modifying files
 			if (worktreeDirty) {
 				return false;
 			}
 
 			MergeResult<RawText> result = null;
 			boolean hasSymlink = FileMode.SYMLINK.equals(modeO)
 					|| FileMode.SYMLINK.equals(modeT);
 			if (!hasSymlink) {
 				try {
 					result = contentMerge(base, ours, theirs, attributes,
 							getContentMergeStrategy());
 				} catch (BinaryBlobException e) {
 					// result == null
 				}
 			}
 			if (result == null) {
 				switch (getContentMergeStrategy()) {
 				case OURS:
 					keep(ourDce);
 					return true;
 				case THEIRS:
 					DirCacheEntry e = add(tw.getRawPath(), theirs,
 							DirCacheEntry.STAGE_0, EPOCH, 0);
 					if (e != null) {
 						addToCheckout(tw.getPathString(), e, attributes);
 					}
 					return true;
 				default:
 					result = new MergeResult<>(Collections.emptyList());
 					result.setContainsConflicts(true);
 					break;
 				}
 			}
 			if (ignoreConflicts) {
 				result.setContainsConflicts(false);
 			}
 			String currentPath = tw.getPathString();
 			if (hasSymlink) {
 				if (ignoreConflicts) {
 					if (((modeT & FileMode.TYPE_MASK) == FileMode.TYPE_FILE)) {
 						DirCacheEntry e = add(tw.getRawPath(), theirs,
 								DirCacheEntry.STAGE_0, EPOCH, 0);
 						addToCheckout(currentPath, e, attributes);
 					} else {
 						keep(ourDce);
 					}
 				} else {
 					// Record the conflict
 					DirCacheEntry e = addConflict(base, ours, theirs);
 					mergeResults.put(currentPath, result);
 					// If theirs is a file, check it out. In link/file
 					// conflicts, C git prefers the file.
 					if (((modeT & FileMode.TYPE_MASK) == FileMode.TYPE_FILE)
 							&& e != null) {
 						addToCheckout(currentPath, e, attributes);
 					}
 				}
 			} else {
 				updateIndex(base, ours, theirs, result, attributes[T_OURS]);
 			}
 			if (result.containsConflicts() && !ignoreConflicts) {
 				unmergedPaths.add(currentPath);
 			}
 			workTreeUpdater.markAsModified(currentPath);
 			// Entry is null - only adds the metadata.
 			addToCheckout(currentPath, null, attributes);
 		} else if (modeO != modeT) {
 			// OURS or THEIRS has been deleted
 			if (((modeO != 0 && !tw.idEqual(T_BASE, T_OURS)) || (modeT != 0 && !tw
 					.idEqual(T_BASE, T_THEIRS)))) {
 				if (gitLinkMerging && ignoreConflicts) {
 					add(tw.getRawPath(), ours, DirCacheEntry.STAGE_0, EPOCH, 0);
 				} else if (gitLinkMerging) {
 					addConflict(base, ours, theirs);
 					MergeResult<SubmoduleConflict> result = createGitLinksMergeResult(
 							base, ours, theirs);
 					result.setContainsConflicts(true);
 					mergeResults.put(tw.getPathString(), result);
 					unmergedPaths.add(tw.getPathString());
 				} else {
 					boolean isSymLink = ((modeO | modeT)
 							& FileMode.TYPE_MASK) == FileMode.TYPE_SYMLINK;
 					// Content merge strategy does not apply to delete-modify
 					// conflicts!
 					MergeResult<RawText> result;
 					if (isSymLink) {
 						// No need to do a content merge
 						result = new MergeResult<>(Collections.emptyList());
 						result.setContainsConflicts(true);
 					} else {
 						try {
 							result = contentMerge(base, ours, theirs,
 									attributes, ContentMergeStrategy.CONFLICT);
 						} catch (BinaryBlobException e) {
 							result = new MergeResult<>(Collections.emptyList());
 							result.setContainsConflicts(true);
 						}
 					}
 					if (ignoreConflicts) {
 						result.setContainsConflicts(false);
 						if (isSymLink) {
 							if (modeO != 0) {
 								keep(ourDce);
 							} else {
 								// Check out theirs
 								if (isWorktreeDirty(work, ourDce)) {
 									return false;
 								}
 								DirCacheEntry e = add(tw.getRawPath(), theirs,
 										DirCacheEntry.STAGE_0, EPOCH, 0);
 								if (e != null) {
 									addToCheckout(tw.getPathString(), e,
 											attributes);
 								}
 							}
 						} else {
 							// In case a conflict is detected the working tree
 							// file is again filled with new content (containing
 							// conflict markers). But also stage 0 of the index
 							// is filled with that content.
 							updateIndex(base, ours, theirs, result,
 									attributes[T_OURS]);
 						}
 					} else {
 						DirCacheEntry e = addConflict(base, ours, theirs);
 
 						// OURS was deleted checkout THEIRS
 						if (modeO == 0) {
 							// Check worktree before checking out THEIRS
 							if (isWorktreeDirty(work, ourDce)) {
 								return false;
 							}
 							if (nonTree(modeT) && e != null) {
 								addToCheckout(tw.getPathString(), e,
 										attributes);
 							}
 						}
 
 						unmergedPaths.add(tw.getPathString());
 
 						// generate a MergeResult for the deleted file
 						mergeResults.put(tw.getPathString(), result);
 					}
 				}
 			}
 		}
 		return true;
 	}
 
 	private static MergeResult<SubmoduleConflict> createGitLinksMergeResult(
 			CanonicalTreeParser base, CanonicalTreeParser ours,
 			CanonicalTreeParser theirs) {
 		return new MergeResult<>(Arrays.asList(
 				new SubmoduleConflict(
 						base == null ? null : base.getEntryObjectId()),
 				new SubmoduleConflict(
 						ours == null ? null : ours.getEntryObjectId()),
 				new SubmoduleConflict(
 						theirs == null ? null : theirs.getEntryObjectId())));
 	}
 
 	/**
 	 * Does the content merge. The three texts base, ours and theirs are
 	 * specified with {@link CanonicalTreeParser}. If any of the parsers is
 	 * specified as <code>null</code> then an empty text will be used instead.
 	 *
 	 * @param base
 	 * @param ours
 	 * @param theirs
 	 * @param attributes
 	 * @param strategy
 	 *
 	 * @return the result of the content merge
 	 * @throws BinaryBlobException
 	 *             if any of the blobs looks like a binary blob
 	 * @throws IOException
 	 */
 	private MergeResult<RawText> contentMerge(CanonicalTreeParser base,
 			CanonicalTreeParser ours, CanonicalTreeParser theirs,
 			Attributes[] attributes, ContentMergeStrategy strategy)
 			throws BinaryBlobException, IOException {
 		// TW: The attributes here are used to determine the LFS smudge filter.
 		// Is doing a content merge on LFS items really a good idea??
 		RawText baseText = base == null ? RawText.EMPTY_TEXT
 				: getRawText(base.getEntryObjectId(), attributes[T_BASE]);
 		RawText ourText = ours == null ? RawText.EMPTY_TEXT
 				: getRawText(ours.getEntryObjectId(), attributes[T_OURS]);
 		RawText theirsText = theirs == null ? RawText.EMPTY_TEXT
 				: getRawText(theirs.getEntryObjectId(), attributes[T_THEIRS]);
 		mergeAlgorithm.setContentMergeStrategy(strategy);
 		return mergeAlgorithm.merge(RawTextComparator.DEFAULT, baseText,
 				ourText, theirsText);
 	}
 
 	private boolean isIndexDirty() {
 		if (inCore) {
 			return false;
 		}
 
 		final int modeI = tw.getRawMode(T_INDEX);
 		final int modeO = tw.getRawMode(T_OURS);
 
 		// Index entry has to match ours to be considered clean
 		final boolean isDirty = nonTree(modeI)
 				&& !(modeO == modeI && tw.idEqual(T_INDEX, T_OURS));
 		if (isDirty) {
 			failingPaths
 					.put(tw.getPathString(), MergeFailureReason.DIRTY_INDEX);
 		}
 		return isDirty;
 	}
 
 	private boolean isWorktreeDirty(WorkingTreeIterator work,
 			DirCacheEntry ourDce) throws IOException {
 		if (work == null) {
 			return false;
 		}
 
 		final int modeF = tw.getRawMode(T_FILE);
 		final int modeO = tw.getRawMode(T_OURS);
 
 		// Worktree entry has to match ours to be considered clean
 		boolean isDirty;
 		if (ourDce != null) {
 			isDirty = work.isModified(ourDce, true, reader);
 		} else {
 			isDirty = work.isModeDifferent(modeO);
 			if (!isDirty && nonTree(modeF)) {
 				isDirty = !tw.idEqual(T_FILE, T_OURS);
 			}
 		}
 
 		// Ignore existing empty directories
 		if (isDirty && modeF == FileMode.TYPE_TREE
 				&& modeO == FileMode.TYPE_MISSING) {
 			isDirty = false;
 		}
 		if (isDirty) {
 			failingPaths.put(tw.getPathString(),
 					MergeFailureReason.DIRTY_WORKTREE);
 		}
 		return isDirty;
 	}
 
 	/**
 	 * Updates the index after a content merge has happened. If no conflict has
 	 * occurred this includes persisting the merged content to the object
 	 * database. In case of conflicts this method takes care to write the
 	 * correct stages to the index.
 	 *
 	 * @param base
 	 * @param ours
 	 * @param theirs
 	 * @param result
 	 * @param attributes
 	 * @throws IOException
 	 */
 	private void updateIndex(CanonicalTreeParser base,
 			CanonicalTreeParser ours, CanonicalTreeParser theirs,
 			MergeResult<RawText> result, Attributes attributes)
 			throws IOException {
 		TemporaryBuffer rawMerged = null;
 		try {
 			rawMerged = doMerge(result);
 			File mergedFile = inCore ? null
 					: writeMergedFile(rawMerged, attributes);
 			if (result.containsConflicts()) {
 				// A conflict occurred, the file will contain conflict markers
 				// the index will be populated with the three stages and the
 				// workdir (if used) contains the halfway merged content.
 				addConflict(base, ours, theirs);
 				mergeResults.put(tw.getPathString(), result);
 				return;
 			}
 
 			// No conflict occurred, the file will contain fully merged content.
 			// The index will be populated with the new merged version.
 			Instant lastModified = mergedFile == null ? null
 					: nonNullRepo().getFS().lastModifiedInstant(mergedFile);
 			// Set the mode for the new content. Fall back to REGULAR_FILE if
 			// we can't merge modes of OURS and THEIRS.
 			int newMode = mergeFileModes(tw.getRawMode(0), tw.getRawMode(1),
 					tw.getRawMode(2));
 			FileMode mode = newMode == FileMode.MISSING.getBits()
 					? FileMode.REGULAR_FILE : FileMode.fromBits(newMode);
 			workTreeUpdater.insertToIndex(rawMerged.openInputStream(),
 					tw.getPathString().getBytes(UTF_8), mode,
 					DirCacheEntry.STAGE_0, lastModified,
 					(int) rawMerged.length(),
 					attributes.get(Constants.ATTR_MERGE));
 		} finally {
 			if (rawMerged != null) {
 				rawMerged.destroy();
 			}
 		}
 	}
 
 	/**
 	 * Writes merged file content to the working tree.
 	 *
 	 * @param rawMerged
 	 *            the raw merged content
 	 * @param attributes
 	 *            the files .gitattributes entries
 	 * @return the working tree file to which the merged content was written.
 	 * @throws IOException
 	 */
 	private File writeMergedFile(TemporaryBuffer rawMerged,
 			Attributes attributes)
 			throws IOException {
 		File workTree = nonNullRepo().getWorkTree();
 		FS fs = nonNullRepo().getFS();
 		File of = new File(workTree, tw.getPathString());
 		File parentFolder = of.getParentFile();
 		EolStreamType eol = workTreeUpdater.detectCheckoutStreamType(attributes);
 		if (!fs.exists(parentFolder)) {
 			parentFolder.mkdirs();
 		}
 		workTreeUpdater.updateFileWithContent(rawMerged::openInputStream,
 				eol, tw.getSmudgeCommand(attributes), of.getPath(), of);
 		return of;
 	}
 
 	private TemporaryBuffer doMerge(MergeResult<RawText> result)
 			throws IOException {
 		TemporaryBuffer.LocalFile buf = new TemporaryBuffer.LocalFile(
 				db != null ? nonNullRepo().getDirectory() : null, workTreeUpdater.getInCoreFileSizeLimit());
 		boolean success = false;
 		try {
 			new MergeFormatter().formatMerge(buf, result,
 					Arrays.asList(commitNames), UTF_8);
 			buf.close();
 			success = true;
 		} finally {
 			if (!success) {
 				buf.destroy();
 			}
 		}
 		return buf;
 	}
 
 	/**
 	 * Try to merge filemodes. If only ours or theirs have changed the mode
 	 * (compared to base) we choose that one. If ours and theirs have equal
 	 * modes return that one. If also that is not the case the modes are not
 	 * mergeable. Return {@link FileMode#MISSING} int that case.
 	 *
 	 * @param modeB
 	 *            filemode found in BASE
 	 * @param modeO
 	 *            filemode found in OURS
 	 * @param modeT
 	 *            filemode found in THEIRS
 	 *
 	 * @return the merged filemode or {@link FileMode#MISSING} in case of a
 	 *         conflict
 	 */
 	private int mergeFileModes(int modeB, int modeO, int modeT) {
 		if (modeO == modeT) {
 			return modeO;
 		}
 		if (modeB == modeO) {
 			// Base equal to Ours -> chooses Theirs if that is not missing
 			return (modeT == FileMode.MISSING.getBits()) ? modeO : modeT;
 		}
 		if (modeB == modeT) {
 			// Base equal to Theirs -> chooses Ours if that is not missing
 			return (modeO == FileMode.MISSING.getBits()) ? modeT : modeO;
 		}
 		return FileMode.MISSING.getBits();
 	}
 
 	private RawText getRawText(ObjectId id,
 			Attributes attributes)
 			throws IOException, BinaryBlobException {
 		if (id.equals(ObjectId.zeroId())) {
 			return new RawText(new byte[]{});
 		}
 
 		ObjectLoader loader = LfsFactory.getInstance().applySmudgeFilter(
 				getRepository(), reader.open(id, OBJ_BLOB),
 				attributes.get(Constants.ATTR_MERGE));
 		int threshold = PackConfig.DEFAULT_BIG_FILE_THRESHOLD;
 		return RawText.load(loader, threshold);
 	}
 
 	private static boolean nonTree(int mode) {
 		return mode != 0 && !FileMode.TREE.equals(mode);
 	}
 
 	private static boolean isGitLink(int mode) {
 		return FileMode.GITLINK.equals(mode);
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public ObjectId getResultTreeId() {
 		return (resultTree == null) ? null : resultTree.toObjectId();
 	}
 
 	/**
 	 * Set the names of the commits as they would appear in conflict markers
 	 *
 	 * @param commitNames
 	 *            the names of the commits as they would appear in conflict
 	 *            markers
 	 */
 	public void setCommitNames(String[] commitNames) {
 		this.commitNames = commitNames;
 	}
 
 	/**
 	 * Get the names of the commits as they would appear in conflict markers.
 	 *
 	 * @return the names of the commits as they would appear in conflict
 	 *         markers.
 	 */
 	public String[] getCommitNames() {
 		return commitNames;
 	}
 
 	/**
 	 * Get the paths with conflicts. This is a subset of the files listed by
 	 * {@link #getModifiedFiles()}
 	 *
 	 * @return the paths with conflicts. This is a subset of the files listed by
 	 *         {@link #getModifiedFiles()}
 	 */
 	public List<String> getUnmergedPaths() {
 		return unmergedPaths;
 	}
 
 	/**
 	 * Get the paths of files which have been modified by this merge.
 	 *
 	 * @return the paths of files which have been modified by this merge. A file
 	 *         will be modified if a content-merge works on this path or if the
 	 *         merge algorithm decides to take the theirs-version. This is a
 	 *         superset of the files listed by {@link #getUnmergedPaths()}.
 	 */
 	public List<String> getModifiedFiles() {
 		return workTreeUpdater != null ? workTreeUpdater.getModifiedFiles() : modifiedFiles;
 	}
 
 	/**
 	 * Get a map which maps the paths of files which have to be checked out
 	 * because the merge created new fully-merged content for this file into the
 	 * index.
 	 *
 	 * @return a map which maps the paths of files which have to be checked out
 	 *         because the merge created new fully-merged content for this file
 	 *         into the index. This means: the merge wrote a new stage 0 entry
 	 *         for this path.
 	 */
 	public Map<String, DirCacheEntry> getToBeCheckedOut() {
 		return workTreeUpdater.getToBeCheckedOut();
 	}
 
 	/**
 	 * Get the mergeResults
 	 *
 	 * @return the mergeResults
 	 */
 	public Map<String, MergeResult<? extends Sequence>> getMergeResults() {
 		return mergeResults;
 	}
 
 	/**
 	 * Get list of paths causing this merge to fail (not stopped because of a
 	 * conflict).
 	 *
 	 * @return lists paths causing this merge to fail (not stopped because of a
 	 *         conflict). <code>null</code> is returned if this merge didn't
 	 *         fail.
 	 */
 	public Map<String, MergeFailureReason> getFailingPaths() {
 		return failingPaths.isEmpty() ? null : failingPaths;
 	}
 
 	/**
 	 * Returns whether this merge failed (i.e. not stopped because of a
 	 * conflict)
 	 *
 	 * @return <code>true</code> if a failure occurred, <code>false</code>
 	 *         otherwise
 	 */
 	public boolean failed() {
 		return !failingPaths.isEmpty();
 	}
 
 	/**
 	 * Sets the DirCache which shall be used by this merger. If the DirCache is
 	 * not set explicitly and if this merger doesn't work in-core, this merger
 	 * will implicitly get and lock a default DirCache. If the DirCache is
 	 * explicitly set the caller is responsible to lock it in advance. Finally
 	 * the merger will call {@link org.eclipse.jgit.dircache.DirCache#commit()}
 	 * which requires that the DirCache is locked. If the {@link #mergeImpl()}
 	 * returns without throwing an exception the lock will be released. In case
 	 * of exceptions the caller is responsible to release the lock.
 	 *
 	 * @param dc
 	 *            the DirCache to set
 	 */
 	public void setDirCache(DirCache dc) {
 		this.dircache = dc;
 	}
 
 	/**
 	 * Sets the WorkingTreeIterator to be used by this merger. If no
 	 * WorkingTreeIterator is set this merger will ignore the working tree and
 	 * fail if a content merge is necessary.
 	 * <p>
 	 * TODO: enhance WorkingTreeIterator to support write operations. Then this
 	 * merger will be able to merge with a different working tree abstraction.
 	 *
 	 * @param workingTreeIterator
 	 *            the workingTreeIt to set
 	 */
 	public void setWorkingTreeIterator(WorkingTreeIterator workingTreeIterator) {
 		this.workingTreeIterator = workingTreeIterator;
 	}
 
 
 	/**
 	 * The resolve conflict way of three way merging
 	 *
 	 * @param baseTree
 	 *            a {@link org.eclipse.jgit.treewalk.AbstractTreeIterator}
 	 *            object.
 	 * @param headTree
 	 *            a {@link org.eclipse.jgit.revwalk.RevTree} object.
 	 * @param mergeTree
 	 *            a {@link org.eclipse.jgit.revwalk.RevTree} object.
 	 * @param ignoreConflicts
 	 *            Controls what to do in case a content-merge is done and a
 	 *            conflict is detected. The default setting for this should be
 	 *            <code>false</code>. In this case the working tree file is
 	 *            filled with new content (containing conflict markers) and the
 	 *            index is filled with multiple stages containing BASE, OURS and
 	 *            THEIRS content. Having such non-0 stages is the sign to git
 	 *            tools that there are still conflicts for that path.
 	 *            <p>
 	 *            If <code>true</code> is specified the behavior is different.
 	 *            In case a conflict is detected the working tree file is again
 	 *            filled with new content (containing conflict markers). But
 	 *            also stage 0 of the index is filled with that content. No
 	 *            other stages are filled. Means: there is no conflict on that
 	 *            path but the new content (including conflict markers) is
 	 *            stored as successful merge result. This is needed in the
 	 *            context of {@link org.eclipse.jgit.merge.RecursiveMerger}
 	 *            where when determining merge bases we don't want to deal with
 	 *            content-merge conflicts.
 	 * @return whether the trees merged cleanly
 	 * @throws java.io.IOException
 	 * @since 3.5
 	 */
 	protected boolean mergeTrees(AbstractTreeIterator baseTree,
 			RevTree headTree, RevTree mergeTree, boolean ignoreConflicts)
 			throws IOException {
 		try {
 			workTreeUpdater = inCore ?
 					WorkTreeUpdater.createInCoreWorkTreeUpdater(db, dircache, getObjectInserter()) :
 					WorkTreeUpdater.createWorkTreeUpdater(db, dircache);
 			dircache = workTreeUpdater.getLockedDirCache();
 			tw = new NameConflictTreeWalk(db, reader);
 
 			tw.addTree(baseTree);
 			tw.setHead(tw.addTree(headTree));
 			tw.addTree(mergeTree);
 			DirCacheBuildIterator buildIt = workTreeUpdater.createDirCacheBuildIterator();
 			int dciPos = tw.addTree(buildIt);
 			if (workingTreeIterator != null) {
 				tw.addTree(workingTreeIterator);
 				workingTreeIterator.setDirCacheIterator(tw, dciPos);
 			} else {
 				tw.setFilter(TreeFilter.ANY_DIFF);
 			}
 
 			if (!mergeTreeWalk(tw, ignoreConflicts)) {
 				return false;
 			}
 
 			workTreeUpdater.writeWorkTreeChanges(true);
 			if (getUnmergedPaths().isEmpty() && !failed()) {
 				WorkTreeUpdater.Result result = workTreeUpdater.writeIndexChanges();
 				resultTree = result.getTreeId();
 				modifiedFiles = result.getModifiedFiles();
 				for (String f : result.getFailedToDelete()) {
 					failingPaths.put(f, MergeFailureReason.COULD_NOT_DELETE);
 				}
 				return result.getFailedToDelete().isEmpty();
 			}
 			resultTree = null;
 			return false;
 		} finally {
 			if(modifiedFiles.isEmpty()) {
 				modifiedFiles = workTreeUpdater.getModifiedFiles();
 			}
 			workTreeUpdater.close();
 			workTreeUpdater = null;
 		}
 	}
 
 	/**
 	 * Process the given TreeWalk's entries.
 	 *
 	 * @param treeWalk
 	 *            The walk to iterate over.
 	 * @param ignoreConflicts
 	 *            see
 	 *            {@link org.eclipse.jgit.merge.ResolveMerger#mergeTrees(AbstractTreeIterator, RevTree, RevTree, boolean)}
 	 * @return Whether the trees merged cleanly.
 	 * @throws java.io.IOException
 	 * @since 3.5
 	 */
 	protected boolean mergeTreeWalk(TreeWalk treeWalk, boolean ignoreConflicts)
 			throws IOException {
 		boolean hasWorkingTreeIterator = tw.getTreeCount() > T_FILE;
 		boolean hasAttributeNodeProvider = treeWalk
 				.getAttributesNodeProvider() != null;
 		while (treeWalk.next()) {
 			Attributes[] attributes = {NO_ATTRIBUTES, NO_ATTRIBUTES,
 					NO_ATTRIBUTES};
 			if (hasAttributeNodeProvider) {
 				attributes[T_BASE] = treeWalk.getAttributes(T_BASE);
 				attributes[T_OURS] = treeWalk.getAttributes(T_OURS);
 				attributes[T_THEIRS] = treeWalk.getAttributes(T_THEIRS);
 			}
 			if (!processEntry(
 					treeWalk.getTree(T_BASE, CanonicalTreeParser.class),
 					treeWalk.getTree(T_OURS, CanonicalTreeParser.class),
 					treeWalk.getTree(T_THEIRS, CanonicalTreeParser.class),
 					treeWalk.getTree(T_INDEX, DirCacheBuildIterator.class),
 					hasWorkingTreeIterator ? treeWalk.getTree(T_FILE,
 							WorkingTreeIterator.class) : null,
 					ignoreConflicts, attributes)) {
 				workTreeUpdater.revertModifiedFiles();
 				return false;
 			}
 			if (treeWalk.isSubtree() && enterSubtree) {
 				treeWalk.enterSubtree();
 			}
 		}
 		return true;
 	}
 }