/*
 * Copyright (c) 2013 TMate Software Ltd
 *  
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * For information on how to redistribute this software under
 * the terms of a license other than GNU General Public License
 * contact TMate Software at support@hg4j.com
 */
package org.tmatesoft.hg.test;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.tmatesoft.hg.core.HgIterateDirection.NewToOld;
import static org.tmatesoft.hg.core.HgIterateDirection.OldToNew;
import static org.tmatesoft.hg.repo.HgRepository.TIP;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.junit.Assert;
import org.junit.Rule;
import org.junit.Test;
import org.tmatesoft.hg.core.HgAnnotateCommand;
import org.tmatesoft.hg.core.HgAnnotateCommand.LineInfo;
import org.tmatesoft.hg.core.HgBlameInspector;
import org.tmatesoft.hg.core.HgCallbackTargetException;
import org.tmatesoft.hg.core.HgDiffCommand;
import org.tmatesoft.hg.core.HgRepoFacade;
import org.tmatesoft.hg.core.Nodeid;
import org.tmatesoft.hg.internal.IntVector;
import org.tmatesoft.hg.internal.diff.ForwardAnnotateInspector;
import org.tmatesoft.hg.internal.diff.ReverseAnnotateInspector;
import org.tmatesoft.hg.repo.HgChangelog;
import org.tmatesoft.hg.repo.HgDataFile;
import org.tmatesoft.hg.repo.HgLookup;
import org.tmatesoft.hg.repo.HgRepository;
import org.tmatesoft.hg.util.CancelSupport;
import org.tmatesoft.hg.util.CancelledException;
import org.tmatesoft.hg.util.Path;
import org.tmatesoft.hg.util.ProgressSupport;

/**
 * 
 * @author Artem Tikhomirov
 * @author TMate Software Ltd.
 */
public class TestBlame {

	@Rule
	public ErrorCollectorExt errorCollector = new ErrorCollectorExt();

	
	@Test
	public void testSingleParentBlame() throws Exception {
		HgRepository repo = new HgLookup().detectFromWorkingDir();
		final String fname = "src/org/tmatesoft/hg/internal/PatchGenerator.java";
		final int checkChangeset = repo.getChangelog().getRevisionIndex(Nodeid.fromAscii("946b131962521f9199e1fedbdc2487d3aaef5e46")); // 539
		HgDataFile df = repo.getFileNode(fname);
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		HgDiffCommand diffCmd = new HgDiffCommand(repo);
		diffCmd.file(df).changeset(checkChangeset);
		diffCmd.executeParentsAnnotate(new DiffOutInspector(new PrintStream(bos)));
		LineGrepOutputParser gp = new LineGrepOutputParser("^@@.+");
		ExecHelper eh = new ExecHelper(gp, null);
		eh.run("hg", "diff", "-c", String.valueOf(checkChangeset), "-U", "0", fname);
		//
		String[] apiResult = splitLines(bos.toString());
		String[] expected = splitLines(gp.result());
		Assert.assertArrayEquals(expected, apiResult);
	}
	
	@Test
	public void testFileLineAnnotate1() throws Exception {
		HgRepository repo = new HgLookup().detectFromWorkingDir();
		final String fname = "src/org/tmatesoft/hg/internal/PatchGenerator.java";
		HgDataFile df = repo.getFileNode(fname);
		AnnotateRunner ar = new AnnotateRunner(df.getPath(), null);

		final HgDiffCommand diffCmd = new HgDiffCommand(repo);
		diffCmd.file(df).order(NewToOld);
		final HgChangelog clog = repo.getChangelog();
		final int[] toTest = new int[] { 
			clog.getRevisionIndex(Nodeid.fromAscii("946b131962521f9199e1fedbdc2487d3aaef5e46")), // 539
			clog.getRevisionIndex(Nodeid.fromAscii("1e95f48d9886abe79b9711ab371bc877ca5e773e")), // 541 
			/*, TIP */};
		for (int cs : toTest) {
			ar.run(cs, false);
			diffCmd.range(0, cs);
			final ReverseAnnotateInspector insp = new ReverseAnnotateInspector();
			diffCmd.executeAnnotate(insp);
			AnnotateInspector fa = new AnnotateInspector().fill(cs, insp);
			doAnnotateLineCheck(cs, ar, fa);
		}
	}
	
	@Test
	public void testFileLineAnnotate2() throws Exception {
		HgRepository repo = Configuration.get().find("test-annotate");
		HgDataFile df = repo.getFileNode("file1");
		AnnotateRunner ar = new AnnotateRunner(df.getPath(), repo.getWorkingDir());

		final HgDiffCommand diffCmd = new HgDiffCommand(repo).file(df).order(NewToOld);
		for (int cs : new int[] { 4, 6 /*, 8 see below*/, TIP}) {
			ar.run(cs, false);
			diffCmd.range(0, cs);
			final ReverseAnnotateInspector insp = new ReverseAnnotateInspector();
			diffCmd.executeAnnotate(insp);
			AnnotateInspector fa = new AnnotateInspector().fill(cs, insp);
			doAnnotateLineCheck(cs, ar, fa);
		}
		/*`hg annotate -r 8` and HgBlameFacility give different result
		 * for "r0, line 5" line, which was deleted in rev2 and restored back in
		 * rev4 (both in default branch), while branch with r3 and r6 kept the line intact.
		 * HgBlame reports rev4 for the line, `hg annotate` gives original, rev0.
		 * However `hg annotate -r 4` shows rev4 for the line, too. The aforementioned rev0 for 
		 * the merge rev8 results from the iteration order and is implementation specific 
		 * (i.e. one can't tell which one is right). Mercurial walks from parents to children,
		 * and traces equal lines, while HgBlameFacility walks from child to parents and records 
		 * changes (additions). Seems it processes branch with rev3 and rev6 first 
		 * (printout in context.py, annotate and annotate.pair reveals that), and the line 0_5
		 * comes as unchanged through this branch, and later processing rev2 and rev4 doesn't 
		 * change that. 
		 */
	}
	
	@Test
	public void testComplexHistoryAnnotate() throws Exception {
		HgRepository repo = Configuration.get().find("test-annotate");
		HgDataFile df = repo.getFileNode("file1");
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		DiffOutInspector dump = new DiffOutInspector(new PrintStream(bos));
		HgDiffCommand diffCmd = new HgDiffCommand(repo);
		diffCmd.file(df).range(0, TIP).order(OldToNew);
		diffCmd.executeAnnotate(dump);
		LinkedList<String> apiResult = new LinkedList<String>(Arrays.asList(splitLines(bos.toString())));
		
		/*
		 * FIXME this is an ugly hack to deal with the way `hg diff -c <mergeRev>` describes the change
		 * and our merge handling approach. For merged revision m, and lines changed both in p1 and p2
		 * we report lines from p2 as pure additions, regardless of intersecting p1 changes (which
		 * are reported as deletions, if no sufficient changed lines in m found)
		 * So, here we try to combine deletion that follows a change (based on identical insertionPoint)
		 * into a single change
		 * To fix, need to find better approach to find out reference info (i.e. `hg diff -c` is flawed in this case,
		 * as it uses first parent only).
		 */
		Pattern fix = Pattern.compile("@@ -(\\d+),(\\d+) \\+(\\d+),(\\d+) @@");
		int v1, v2, v3, v4;
		v1 = v2 = v3 = v4 = -1;
		for (ListIterator<String> it = apiResult.listIterator(); it.hasNext();) {
			String n = it.next();
			Matcher m = fix.matcher(n);
			if (m.find()) {
				int d1 = Integer.parseInt(m.group(1));
				int d2 = Integer.parseInt(m.group(2));
				int d3 = Integer.parseInt(m.group(3));
				int d4 = Integer.parseInt(m.group(4));
				if (v1 == d1 && d4 == 0) {
					it.previous(); // shift to current element
					it.previous(); // to real previous
					it.remove();
					it.next();
					it.set(String.format("@@ -%d,%d +%d,%d @@", v1, v2+d2, v3, v4));
				}
				v1 = d1;
				v2 = d2;
				v3 = d3;
				v4 = d4;
			}
		}
		
		LineGrepOutputParser gp = new LineGrepOutputParser("^@@.+");
		ExecHelper eh = new ExecHelper(gp, repo.getWorkingDir());
		for (int cs : dump.getReportedTargetRevisions()) {
			gp.reset();
			eh.run("hg", "diff", "-c", String.valueOf(cs), "-U", "0", df.getPath().toString());
			for (String expected : splitLines(gp.result())) {
				if (!apiResult.remove(expected)) {
					errorCollector.fail(String.format("Expected diff output '%s' for changes in revision %d", expected, cs));
				}
			}
		}
		errorCollector.assertTrue(String.format("Annotate API reported excessive diff: %s ", apiResult.toString()), apiResult.isEmpty());
	}

	
	@Test
	public void testPartialHistoryFollow() throws Exception {
		HgRepository repo = Configuration.get().find("test-annotate2");
		HgDataFile df = repo.getFileNode("file1b.txt");
		// rev3: file1 -> file1a,  rev7: file1a -> file1b, tip: rev10
		DiffOutInspector insp = new DiffOutInspector(new PrintStream(new OutputStream() {
			@Override
			public void write(int b) throws IOException {
				// NULL OutputStream
			}
		}));
		// rev6 changes rev4, rev4 changes rev3. Plus, anything changed 
		// earlier than rev2 shall be reported as new from change3
		int[] change_2_8_new2old = new int[] {4, 6, 3, 4, -1, 3}; 
		int[] change_2_8_old2new = new int[] {-1, 3, 3, 4, 4, 6 };
		final HgDiffCommand cmd = new HgDiffCommand(repo);
		cmd.file(df);
		cmd.range(2, 8).order(NewToOld);
		cmd.executeAnnotate(insp);
		Assert.assertArrayEquals(change_2_8_new2old, insp.getReportedRevisionPairs());
		insp.reset();
		cmd.order(OldToNew).executeAnnotate(insp);
		Assert.assertArrayEquals(change_2_8_old2new, insp.getReportedRevisionPairs());
		// same as 2 to 8, with addition of rev9 changes rev7  (rev6 to rev7 didn't change content, only name)
		int[] change_3_9_new2old = new int[] {7, 9, 4, 6, 3, 4, -1, 3 }; 
		int[] change_3_9_old2new = new int[] {-1, 3, 3, 4, 4, 6, 7, 9 };
		insp.reset();
		cmd.range(3, 9).order(NewToOld).executeAnnotate(insp);
		Assert.assertArrayEquals(change_3_9_new2old, insp.getReportedRevisionPairs());
		insp.reset();
		cmd.order(OldToNew).executeAnnotate(insp);
		Assert.assertArrayEquals(change_3_9_old2new, insp.getReportedRevisionPairs());
	}

	@Test
	public void testAnnotateCmdFollowNoFollow() throws Exception {
		HgRepoFacade hgRepoFacade = new HgRepoFacade();
		HgRepository repo = Configuration.get().find("test-annotate2");
		hgRepoFacade.init(repo);
		HgAnnotateCommand cmd = hgRepoFacade.createAnnotateCommand();
		final Path fname = Path.create("file1b.txt");
		final int changeset = TIP;
		AnnotateInspector ai = new AnnotateInspector();

		cmd.changeset(changeset);
		// follow
		cmd.file(fname);
		cmd.execute(ai);
		AnnotateRunner ar = new AnnotateRunner(fname, repo.getWorkingDir());
		ar.run(changeset, true);
		doAnnotateLineCheck(changeset, ar, ai);
		
		// no follow
		cmd.file(fname, false);
		ai = new AnnotateInspector();
		cmd.execute(ai);
		ar.run(changeset, false);
		doAnnotateLineCheck(changeset, ar, ai);
	}
	
	@Test
	public void testDiffTwoRevisions() throws Exception {
		HgRepository repo = Configuration.get().find("test-annotate");
		HgDataFile df = repo.getFileNode("file1");
		LineGrepOutputParser gp = new LineGrepOutputParser("^@@.+");
		ExecHelper eh = new ExecHelper(gp, repo.getWorkingDir());
		int[] toTest = { 3, 4, 5 }; // p1 ancestry line, p2 ancestry line, not in ancestry line
		final HgDiffCommand diffCmd = new HgDiffCommand(repo).file(df);
		for (int cs : toTest) {
			ByteArrayOutputStream bos = new ByteArrayOutputStream();
			diffCmd.range(cs, 8).executeDiff(new DiffOutInspector(new PrintStream(bos)));
			eh.run("hg", "diff", "-r", String.valueOf(cs), "-r", "8", "-U", "0", df.getPath().toString());
			//
			String[] apiResult = splitLines(bos.toString());
			String[] expected = splitLines(gp.result());
			Assert.assertArrayEquals("diff -r " + cs + "-r 8", expected, apiResult);
			gp.reset();
		}
	}
	
	/**
	 * Make sure boundary values are ok (down to BlameHelper#prepare and FileHistory) 
	 */
	@Test
	public void testAnnotateFirstFileRev() throws Exception {
		HgRepository repo = Configuration.get().find("test-annotate");
		HgDataFile df = repo.getFileNode("file1");
		LineGrepOutputParser gp = new LineGrepOutputParser("^@@.+");
		ExecHelper eh = new ExecHelper(gp, repo.getWorkingDir());
		eh.run("hg", "diff", "-c", "0", "-U", "0", df.getPath().toString());
		//
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		HgDiffCommand diffCmd = new HgDiffCommand(repo).file(df);
		diffCmd.changeset(0).executeParentsAnnotate(new DiffOutInspector(new PrintStream(bos)));
		//
		String[] apiResult = splitLines(bos.toString());
		String[] expected = splitLines(gp.result());
		Assert.assertArrayEquals(expected, apiResult);
	}
	
	@Test
	public void testAnnotateMergeMapViaBase() throws Exception {
		HgRepository repo = Configuration.get().find("test-annotate3");
		HgDataFile df1 = repo.getFileNode("file1");
		HgDataFile df4 = repo.getFileNode("file4");
		HgDataFile df5 = repo.getFileNode("file5");
		assertTrue("[sanity]", df1.exists() && df4.exists());
		// hg annotate handles merge in its own way, here we check 
		// how map(diff(p1->base->p2)) merge strategy works
		final String file1AnnotateResult = "3:1:1\n3:2:2x\n3:3:3y\n2:4:z\n0:1:1\n1:2:2x\n4:3:3y\n";
		final String file4AnnotateResult = "3:1:1\n1:2:2x\n4:3:3y\n2:4:z\n0:1:1\n3:6:2x\n3:7:3y\n";
		final String file5AnnotateResult = "0:1:1\n1:2:2x\n4:3:3y\n2:4:z\n5:5:1\n5:6:2x\n5:7:3y\n";
		HgAnnotateCommand cmd = new HgAnnotateCommand(repo);
		cmd.changeset(5);
		AnnotateInspector insp = new AnnotateInspector();
		// file1
		cmd.file(df1, false).execute(insp);
		doAnnotateLineCheck(5, splitLines(file1AnnotateResult), insp);
		// file4
		cmd.file(df4, false).execute(insp = new AnnotateInspector());
		doAnnotateLineCheck(5, splitLines(file4AnnotateResult), insp);
		// file5
		cmd.file(df5, false).execute(insp = new AnnotateInspector());
		doAnnotateLineCheck(5, splitLines(file5AnnotateResult), insp);
}

	// TODO HgWorkingCopyStatusCollector (and HgStatusCollector), with their ancestors (rev 59/69) have examples
	// of *incorrect* assignment of common lines (like "}") - our impl doesn't process common lines in any special way
	// while original diff lib does. Would be nice to behave as close to original, as possible.
	
	private static String[] splitLines(CharSequence seq) {
		int lineCount = 0;
		for (int i = 0, x = seq.length(); i < x; i++) {
			if (seq.charAt(i) == '\n') {
				lineCount++;
			}
		}
		if (seq.length() > 0 && seq.charAt(seq.length()-1) != '\n') {
			lineCount++;
		}
		String[] rv = new String[lineCount];
		int lineStart = 0, lineEnd = 0, ix = 0;
		do {
			while (lineEnd < seq.length() && seq.charAt(lineEnd) != '\n') lineEnd++;
			if (lineEnd == lineStart) {
				continue;
			}
			CharSequence line = seq.subSequence(lineStart, lineEnd);
			rv[ix++] = line.toString();
			lineStart = ++lineEnd;
		} while (lineStart < seq.length());
		assert ix == lineCount;
		return rv;
	}
	
	private void doAnnotateLineCheck(int cs, AnnotateRunner ar, AnnotateInspector hg4jResult) {
		String[] hgAnnotateLines = ar.getLines();
		assertTrue("[sanity]", hgAnnotateLines.length > 0);
		assertEquals("Number of lines reported by native annotate and our impl", hgAnnotateLines.length, hg4jResult.getLineCount());
		doAnnotateLineCheck(cs, hgAnnotateLines, hg4jResult);
	}

	private void doAnnotateLineCheck(int cs, String[] expectedAnnotateLines, AnnotateInspector hg4jResult) { 
		for (int i = 0; i < expectedAnnotateLines.length; i++) {
			String[] hgLine = expectedAnnotateLines[i].split(":");
			assertTrue(expectedAnnotateLines[i], hgLine.length >= 3);
			int hgAnnotateRevIndex = Integer.parseInt(hgLine[0].trim());
			int hgFirstAppLine = Integer.parseInt(hgLine[1].trim());
			String hgLineText = expectedAnnotateLines[i].substring(hgLine[0].length() + hgLine[1].length() + 2).trim(); 
			errorCollector.assertEquals(String.format("Revision mismatch for line %d (annotating rev: %d)", i+1, cs), hgAnnotateRevIndex, hg4jResult.getChangeset(i));
			errorCollector.assertEquals("Line text", hgLineText, hg4jResult.getLine(i).trim());
			errorCollector.assertEquals("Line in origin", hgFirstAppLine, hg4jResult.getOriginLine(i));
		}
	}
	
	private void ddd() throws Throwable {
//		HgRepository repo = new HgLookup().detect("/home/artem/hg/blame-merge/");
		HgRepository repo = new HgLookup().detect("/home/artem/hg/junit-test-repos/test-annotate3/");
		final DiffOutInspector insp = new DiffOutInspector(System.out);
		insp.needRevisions(true);
		new HgDiffCommand(repo).file(Path.create("file1")).executeParentsAnnotate(insp);
	}

	public static void main(String[] args) throws Throwable {
		TestBlame tt = new TestBlame();
		tt.ddd();
	}

	private static class DiffOutInspector implements HgBlameInspector {
		private final PrintStream out;
		private boolean dumpRevs;
		private IntVector reportedRevisionPairs = new IntVector();
		
		DiffOutInspector(PrintStream ps) {
			out = ps;
		}
		
		// Note, true makes output incompatible with 'hg diff'
		public void needRevisions(boolean dumpRevs) {
			this.dumpRevs = dumpRevs;
		}
		
		private void printRevs(Block b) {
			if (dumpRevs) {
				out.printf("[%3d -> %3d] ", b.originChangesetIndex(), b.targetChangesetIndex());
			}
			reportedRevisionPairs.add(b.originChangesetIndex(), b.targetChangesetIndex());
		}
		
		int[] getReportedTargetRevisions() {
			LinkedHashSet<Integer> rv = new LinkedHashSet<Integer>();
			for (int i = 1; i < reportedRevisionPairs.size(); i += 2) {
				rv.add(reportedRevisionPairs.get(i));
			}
			int[] x = new int[rv.size()];
			int i = 0;
			for (int v : rv) {
				x[i++] = v;
			}
			return x;
		}
		
		int[] getReportedRevisionPairs() {
			return reportedRevisionPairs.toArray();
		}
		
		void reset() {
			reportedRevisionPairs.clear();
		}
		
		public void same(EqualBlock block) {
			// nothing 
		}
		
		public void deleted(DeleteBlock block) {
			printRevs(block);
			out.printf("@@ -%d,%d +%d,0 @@\n", block.firstRemovedLine() + 1, block.totalRemovedLines(), block.removedAt());
		}
		
		public void changed(ChangeBlock block) {
			printRevs(block);
			out.printf("@@ -%d,%d +%d,%d @@\n", block.firstRemovedLine() + 1, block.totalRemovedLines(), block.firstAddedLine() + 1, block.totalAddedLines());
		}
		
		public void added(AddBlock block) {
			printRevs(block);
			out.printf("@@ -%d,0 +%d,%d @@\n", block.insertedAt(), block.firstAddedLine() + 1, block.totalAddedLines());
		}
	}
	
	public static class LineGrepOutputParser implements OutputParser {
		
		private final Pattern pattern;
		private final StringBuilder result = new StringBuilder();

		public LineGrepOutputParser(String regexp) {
			pattern = Pattern.compile(regexp);
		}
		
		public void reset() {
			result.setLength(0);
		}
		
		public CharSequence result() {
			return result;
		}

		public void parse(CharSequence seq) {
			int lineStart = 0, lineEnd = 0;
			do {
				while (lineEnd < seq.length() && seq.charAt(lineEnd) != '\n') lineEnd++;
				if (lineEnd == lineStart) {
					continue;
				}
				CharSequence line = seq.subSequence(lineStart, lineEnd);
				if (pattern.matcher(line).matches()) {
					result.append(line);
					result.append('\n');
				}
				lineStart = ++lineEnd;
			} while (lineStart < seq.length());
		}
	}

	@SuppressWarnings("unused")
	private static class LineDumpInspector implements HgBlameInspector {
		
		private final boolean lineByLine;

		public LineDumpInspector(boolean lineByLine) {
			this.lineByLine = lineByLine;
		}

		public void same(EqualBlock block) {
		}

		public void added(AddBlock block) {
			BlockData lines = block.addedLines();
			printBlock(lines, block.targetChangesetIndex(), block.firstAddedLine(), block.totalAddedLines(), "+++");
		}

		public void changed(ChangeBlock block) {
			deleted(block);
			added(block);
		}

		public void deleted(DeleteBlock block) {
			BlockData lines = block.removedLines();
			assert lines.elementCount() == block.totalRemovedLines();
			printBlock(lines, block.originChangesetIndex(), block.firstRemovedLine(), block.totalRemovedLines(), "---");
		}
		
		private void printBlock(BlockData lines, int cset, int first, int length, String marker) {
			assert lines.elementCount() == length;
			if (lineByLine) {
				for (int i = 0, ln = first; i < length; i++, ln++) {
					String line = new String(lines.elementAt(i).asArray());
					System.out.printf("%3d:%3d:%s:%s", cset, ln, marker, line);
				}
			} else {
				String content = new String(lines.asArray());
				System.out.printf("%3d:%s:[%d..%d):\n%s", cset, marker, first, first+length, content);
			}
		}
	}
	
	/**
	 * Note, this class expects lines coming in natural sequence (not the order they are detected - possible with {@link ReverseAnnotateInspector})
	 * Once async lines are done, shall change implementation here 
	 */
	static class AnnotateInspector implements HgAnnotateCommand.Inspector {
		private int lineNumber = 1;
		private final ArrayList<String> lines = new ArrayList<String>();
		private final IntVector changesets = new IntVector();
		private final IntVector firstAppLines = new IntVector();

		AnnotateInspector fill(int rev, ReverseAnnotateInspector ai) throws HgCallbackTargetException, CancelledException {
			ai.report(rev, this, ProgressSupport.Factory.get(null), CancelSupport.Factory.get(null));
			return this;
		}
		AnnotateInspector fill(int rev, ForwardAnnotateInspector ai) throws HgCallbackTargetException, CancelledException {
			ai.report(rev, this, ProgressSupport.Factory.get(null), CancelSupport.Factory.get(null));
			return this;
		}

		public void next(LineInfo lineInfo) throws HgCallbackTargetException {
			Assert.assertEquals(lineInfo.getLineNumber(), lineNumber);
			lineNumber++;
			lines.add(new String(lineInfo.getContent()));
			changesets.add(lineInfo.getChangesetIndex());
			firstAppLines.add(lineInfo.getOriginLineNumber());
		}
		
		int getLineCount() {
			return changesets.size();
		}
		int getChangeset(int line) {
			return changesets.get(line);
		}
		String getLine(int line) {
			return lines.get(line);
		}
		int getOriginLine(int line) {
			return firstAppLines.get(line);
		}
	}
	
	private static class AnnotateRunner {
		private final ExecHelper eh;
		private final OutputParser.Stub op;
		private final Path file;
		
		public AnnotateRunner(Path filePath, File repoDir) {
			file = filePath;
			op = new OutputParser.Stub();
			eh = new ExecHelper(op, repoDir);
		}
		
		public void run(int cset, boolean follow) throws Exception {
			op.reset();
			ArrayList<String> args = new ArrayList<String>();
			args.add("hg");
			args.add("annotate");
			args.add("--line-number");
			args.add("-r");
			args.add(cset == TIP ? "tip" : String.valueOf(cset));
			if (!follow) {
				args.add("--no-follow");
			}
			args.add(file.toString());
			eh.run(args);
		}
		
		public String[] getLines() {
			return splitLines(op.result());
		}
	}
}