/*
    * Copyright (C) 2008-2009, 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.patch;
  
  import static org.eclipse.jgit.lib.Constants.encodeASCII;
  import static org.eclipse.jgit.patch.FileHeader.NEW_NAME;
  import static org.eclipse.jgit.patch.FileHeader.OLD_NAME;
  import static org.eclipse.jgit.patch.FileHeader.isHunkHdr;
  import static org.eclipse.jgit.util.RawParseUtils.match;
  import static org.eclipse.jgit.util.RawParseUtils.nextLF;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.ArrayList;
  import java.util.List;
  
  import org.eclipse.jgit.internal.JGitText;
  import org.eclipse.jgit.util.TemporaryBuffer;
  
  /**
   * A parsed collection of {@link org.eclipse.jgit.patch.FileHeader}s from a
   * unified diff patch file
   */
  public class Patch {
  	static final byte[] DIFF_GIT = encodeASCII("diff --git "); //$NON-NLS-1$
  
  	private static final byte[] DIFF_CC = encodeASCII("diff --cc "); //$NON-NLS-1$
  
  	private static final byte[] DIFF_COMBINED = encodeASCII("diff --combined "); //$NON-NLS-1$
  
  	private static final byte[][] BIN_HEADERS = new byte[][] {
  			encodeASCII("Binary files "), encodeASCII("Files "), }; //$NON-NLS-1$ //$NON-NLS-2$
  
  	private static final byte[] BIN_TRAILER = encodeASCII(" differ\n"); //$NON-NLS-1$
  
  	private static final byte[] GIT_BINARY = encodeASCII("GIT binary patch\n"); //$NON-NLS-1$
  
  	static final byte[] SIG_FOOTER = encodeASCII("-- \n"); //$NON-NLS-1$
  
  	/** The files, in the order they were parsed out of the input. */
  	private final List<FileHeader> files;
  
  	/** Formatting errors, if any were identified. */
  	private final List<FormatError> errors;
  
  	/**
  	 * Create an empty patch.
  	 */
  	public Patch() {
  		files = new ArrayList<>();
  		errors = new ArrayList<>(0);
  	}
  
  	/**
  	 * Add a single file to this patch.
  	 * <p>
  	 * Typically files should be added by parsing the text through one of this
  	 * class's parse methods.
  	 *
  	 * @param fh
  	 *            the header of the file.
  	 */
  	public void addFile(FileHeader fh) {
  		files.add(fh);
  	}
  
  	/**
  	 * Get list of files described in the patch, in occurrence order.
  	 *
  	 * @return list of files described in the patch, in occurrence order.
  	 */
  	public List<? extends FileHeader> getFiles() {
  		return files;
  	}
  
  	/**
  	 * Add a formatting error to this patch script.
  	 *
  	 * @param err
  	 *            the error description.
  	 */
  	public void addError(FormatError err) {
  		errors.add(err);
  	}
  
  	/**
  	 * Get collection of formatting errors.
  	 *
  	 * @return collection of formatting errors, if any.
  	 */
  	public List<FormatError> getErrors() {
 		return errors;
 	}
 
 	/**
 	 * Parse a patch received from an InputStream.
 	 * <p>
 	 * Multiple parse calls on the same instance will concatenate the patch
 	 * data, but each parse input must start with a valid file header (don't
 	 * split a single file across parse calls).
 	 *
 	 * @param is
 	 *            the stream to read the patch data from. The stream is read
 	 *            until EOF is reached.
 	 * @throws java.io.IOException
 	 *             there was an error reading from the input stream.
 	 */
 	public void parse(InputStream is) throws IOException {
 		final byte[] buf = readFully(is);
 		parse(buf, 0, buf.length);
 	}
 
 	private static byte[] readFully(InputStream is) throws IOException {
 		try (TemporaryBuffer b = new TemporaryBuffer.Heap(Integer.MAX_VALUE)) {
 			b.copy(is);
 			return b.toByteArray();
 		}
 	}
 
 	/**
 	 * Parse a patch stored in a byte[].
 	 * <p>
 	 * Multiple parse calls on the same instance will concatenate the patch
 	 * data, but each parse input must start with a valid file header (don't
 	 * split a single file across parse calls).
 	 *
 	 * @param buf
 	 *            the buffer to parse.
 	 * @param ptr
 	 *            starting position to parse from.
 	 * @param end
 	 *            1 past the last position to end parsing. The total length to
 	 *            be parsed is <code>end - ptr</code>.
 	 */
 	public void parse(byte[] buf, int ptr, int end) {
 		while (ptr < end)
 			ptr = parseFile(buf, ptr, end);
 	}
 
 	private int parseFile(byte[] buf, int c, int end) {
 		while (c < end) {
 			if (isHunkHdr(buf, c, end) >= 1) {
 				// If we find a disconnected hunk header we might
 				// have missed a file header previously. The hunk
 				// isn't valid without knowing where it comes from.
 				//
 				error(buf, c, JGitText.get().hunkDisconnectedFromFile);
 				c = nextLF(buf, c);
 				continue;
 			}
 
 			// Valid git style patch?
 			//
 			if (match(buf, c, DIFF_GIT) >= 0)
 				return parseDiffGit(buf, c, end);
 			if (match(buf, c, DIFF_CC) >= 0)
 				return parseDiffCombined(DIFF_CC, buf, c, end);
 			if (match(buf, c, DIFF_COMBINED) >= 0)
 				return parseDiffCombined(DIFF_COMBINED, buf, c, end);
 
 			// Junk between files? Leading junk? Traditional
 			// (non-git generated) patch?
 			//
 			final int n = nextLF(buf, c);
 			if (n >= end) {
 				// Patches cannot be only one line long. This must be
 				// trailing junk that we should ignore.
 				//
 				return end;
 			}
 
 			if (n - c < 6) {
 				// A valid header must be at least 6 bytes on the
 				// first line, e.g. "--- a/b\n".
 				//
 				c = n;
 				continue;
 			}
 
 			if (match(buf, c, OLD_NAME) >= 0 && match(buf, n, NEW_NAME) >= 0) {
 				// Probably a traditional patch. Ensure we have at least
 				// a "@@ -0,0" smelling line next. We only check the "@@ -".
 				//
 				final int f = nextLF(buf, n);
 				if (f >= end)
 					return end;
 				if (isHunkHdr(buf, f, end) == 1)
 					return parseTraditionalPatch(buf, c, end);
 			}
 
 			c = n;
 		}
 		return c;
 	}
 
 	private int parseDiffGit(byte[] buf, int start, int end) {
 		final FileHeader fh = new FileHeader(buf, start);
 		int ptr = fh.parseGitFileName(start + DIFF_GIT.length, end);
 		if (ptr < 0)
 			return skipFile(buf, start);
 
 		ptr = fh.parseGitHeaders(ptr, end);
 		ptr = parseHunks(fh, ptr, end);
 		fh.endOffset = ptr;
 		addFile(fh);
 		return ptr;
 	}
 
 	private int parseDiffCombined(final byte[] hdr, final byte[] buf,
 			final int start, final int end) {
 		final CombinedFileHeader fh = new CombinedFileHeader(buf, start);
 		int ptr = fh.parseGitFileName(start + hdr.length, end);
 		if (ptr < 0)
 			return skipFile(buf, start);
 
 		ptr = fh.parseGitHeaders(ptr, end);
 		ptr = parseHunks(fh, ptr, end);
 		fh.endOffset = ptr;
 		addFile(fh);
 		return ptr;
 	}
 
 	private int parseTraditionalPatch(final byte[] buf, final int start,
 			final int end) {
 		final FileHeader fh = new FileHeader(buf, start);
 		int ptr = fh.parseTraditionalHeaders(start, end);
 		ptr = parseHunks(fh, ptr, end);
 		fh.endOffset = ptr;
 		addFile(fh);
 		return ptr;
 	}
 
 	private static int skipFile(byte[] buf, int ptr) {
 		ptr = nextLF(buf, ptr);
 		if (match(buf, ptr, OLD_NAME) >= 0)
 			ptr = nextLF(buf, ptr);
 		return ptr;
 	}
 
 	private int parseHunks(FileHeader fh, int c, int end) {
 		final byte[] buf = fh.buf;
 		while (c < end) {
 			// If we see a file header at this point, we have all of the
 			// hunks for our current file. We should stop and report back
 			// with this position so it can be parsed again later.
 			//
 			if (match(buf, c, DIFF_GIT) >= 0)
 				break;
 			if (match(buf, c, DIFF_CC) >= 0)
 				break;
 			if (match(buf, c, DIFF_COMBINED) >= 0)
 				break;
 			if (match(buf, c, OLD_NAME) >= 0)
 				break;
 			if (match(buf, c, NEW_NAME) >= 0)
 				break;
 
 			if (isHunkHdr(buf, c, end) == fh.getParentCount()) {
 				final HunkHeader h = fh.newHunkHeader(c);
 				h.parseHeader();
 				c = h.parseBody(this, end);
 				h.endOffset = c;
 				fh.addHunk(h);
 				if (c < end) {
 					switch (buf[c]) {
 					case '@':
 					case 'd':
 					case '\n':
 						break;
 					default:
 						if (match(buf, c, SIG_FOOTER) < 0)
 							warn(buf, c, JGitText.get().unexpectedHunkTrailer);
 					}
 				}
 				continue;
 			}
 
 			final int eol = nextLF(buf, c);
 			if (fh.getHunks().isEmpty() && match(buf, c, GIT_BINARY) >= 0) {
 				fh.patchType = FileHeader.PatchType.GIT_BINARY;
 				return parseGitBinary(fh, eol, end);
 			}
 
 			if (fh.getHunks().isEmpty() && BIN_TRAILER.length < eol - c
 					&& match(buf, eol - BIN_TRAILER.length, BIN_TRAILER) >= 0
 					&& matchAny(buf, c, BIN_HEADERS)) {
 				// The patch is a binary file diff, with no deltas.
 				//
 				fh.patchType = FileHeader.PatchType.BINARY;
 				return eol;
 			}
 
 			// Skip this line and move to the next. Its probably garbage
 			// after the last hunk of a file.
 			//
 			c = eol;
 		}
 
 		if (fh.getHunks().isEmpty()
 				&& fh.getPatchType() == FileHeader.PatchType.UNIFIED
 				&& !fh.hasMetaDataChanges()) {
 			// Hmm, an empty patch? If there is no metadata here we
 			// really have a binary patch that we didn't notice above.
 			//
 			fh.patchType = FileHeader.PatchType.BINARY;
 		}
 
 		return c;
 	}
 
 	private int parseGitBinary(FileHeader fh, int c, int end) {
 		final BinaryHunk postImage = new BinaryHunk(fh, c);
 		final int nEnd = postImage.parseHunk(c, end);
 		if (nEnd < 0) {
 			// Not a binary hunk.
 			//
 			error(fh.buf, c, JGitText.get().missingForwardImageInGITBinaryPatch);
 			return c;
 		}
 		c = nEnd;
 		postImage.endOffset = c;
 		fh.forwardBinaryHunk = postImage;
 
 		final BinaryHunk preImage = new BinaryHunk(fh, c);
 		final int oEnd = preImage.parseHunk(c, end);
 		if (oEnd >= 0) {
 			c = oEnd;
 			preImage.endOffset = c;
 			fh.reverseBinaryHunk = preImage;
 		}
 
 		return c;
 	}
 
 	void warn(byte[] buf, int ptr, String msg) {
 		addError(new FormatError(buf, ptr, FormatError.Severity.WARNING, msg));
 	}
 
 	void error(byte[] buf, int ptr, String msg) {
 		addError(new FormatError(buf, ptr, FormatError.Severity.ERROR, msg));
 	}
 
 	private static boolean matchAny(final byte[] buf, final int c,
 			final byte[][] srcs) {
 		for (byte[] s : srcs) {
 			if (match(buf, c, s) >= 0)
 				return true;
 		}
 		return false;
 	}
 }