/*
    * Copyright (C) 2012, IBM Corporation and others. 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.lib;
  
  import static org.junit.Assert.assertEquals;
  
  import java.io.File;
  import java.io.IOException;
  import java.nio.file.Path;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.List;
  
  import org.eclipse.jgit.junit.JGitTestUtil;
  import org.eclipse.jgit.junit.LocalDiskRepositoryTestCase;
  import org.eclipse.jgit.pgm.CLIGitCommand;
  import org.eclipse.jgit.pgm.CLIGitCommand.Result;
  import org.eclipse.jgit.pgm.TextBuiltin.TerminatedByHelpException;
  import org.junit.Before;
  
  public class CLIRepositoryTestCase extends LocalDiskRepositoryTestCase {
  	/** Test repository, initialized for this test case. */
  	protected Repository db;
  
  	@Override
  	@Before
  	public void setUp() throws Exception {
  		super.setUp();
  		db = createWorkRepository();
  	}
  
  	/**
  	 * Executes specified git commands (with arguments)
  	 *
  	 * @param cmds
  	 *            each string argument must be a valid git command line, e.g.
  	 *            "git branch -h"
  	 * @return command output
  	 * @throws Exception
  	 */
  	protected String[] executeUnchecked(String... cmds) throws Exception {
  		List<String> result = new ArrayList<>(cmds.length);
  		for (String cmd : cmds) {
  			result.addAll(CLIGitCommand.executeUnchecked(cmd, db));
  		}
  		return result.toArray(new String[0]);
  	}
  
  	/**
  	 * Executes specified git commands (with arguments), throws exception and
  	 * stops execution on first command which output contains a 'fatal:' error
  	 *
  	 * @param cmds
  	 *            each string argument must be a valid git command line, e.g.
  	 *            "git branch -h"
  	 * @return command output
  	 * @throws Exception
  	 */
  	protected String[] execute(String... cmds) throws Exception {
  		List<String> result = new ArrayList<>(cmds.length);
  		for (String cmd : cmds) {
  			Result r = CLIGitCommand.executeRaw(cmd, db);
  			if (r.ex instanceof TerminatedByHelpException) {
  				result.addAll(r.errLines());
  			} else if (r.ex != null) {
  				throw r.ex;
  			}
  			result.addAll(r.outLines());
  		}
  		return result.toArray(new String[0]);
  	}
  
  	/**
  	 * @param link
  	 *            the path of the symbolic link to create
  	 * @param target
  	 *            the target of the symbolic link
  	 * @return the path to the symbolic link
  	 * @throws Exception
  	 */
  	protected Path writeLink(String link, String target) throws Exception {
  		return JGitTestUtil.writeLink(db, link, target);
  	}
  
  	protected File writeTrashFile(String name, String data)
  			throws IOException {
  		return JGitTestUtil.writeTrashFile(db, name, data);
  	}
  
  	@Override
  	protected String read(File file) throws IOException {
  		return JGitTestUtil.read(file);
 	}
 
 	protected void deleteTrashFile(String name) throws IOException {
 		JGitTestUtil.deleteTrashFile(db, name);
 	}
 
 	/**
 	 * Execute the given commands and print the output to stdout. Use this
 	 * function instead of the normal {@link #execute(String...)} when preparing
 	 * a test case: the command is executed and then its output is printed on
 	 * stdout, thus making it easier to prepare the correct command and expected
 	 * output for the test case.
 	 *
 	 * @param cmds
 	 *            The commands to execute
 	 * @return the result of the command, see {@link #execute(String...)}
 	 * @throws Exception
 	 */
 	protected String[] executeAndPrint(String... cmds) throws Exception {
 		String[] lines = execute(cmds);
 		for (String line : lines) {
 			System.out.println(line);
 		}
 		return lines;
 	}
 
 	/**
 	 * Execute the given commands and print test code comparing expected and
 	 * actual output. Use this function instead of the normal
 	 * {@link #execute(String...)} when preparing a test case: the command is
 	 * executed and test code is generated using the command output as a
 	 * template of what is expected. The code generated is printed on stdout and
 	 * can be pasted in the test case function.
 	 *
 	 * @param cmds
 	 *            The commands to execute
 	 * @return the result of the command, see {@link #execute(String...)}
 	 * @throws Exception
 	 */
 	protected String[] executeAndPrintTestCode(String... cmds) throws Exception {
 		String[] lines = execute(cmds);
 		String cmdString = cmdString(cmds);
 		if (lines.length == 0)
 			System.out.println("\t\tassertTrue(execute(" + cmdString
 					+ ").length == 0);");
 		else {
 			System.out
 					.println("\t\tassertArrayOfLinesEquals(new String[] { //");
 			System.out.print("\t\t\t\t\t\t\"" + escapeJava(lines[0]));
 			for (int i=1; i<lines.length; i++) {
 				System.out.println("\", //");
 				System.out.print("\t\t\t\t\t\t\"" + escapeJava(lines[i]));
 			}
 			System.out.println("\" //");
 			System.out.println("\t\t\t\t}, execute(" + cmdString + ")); //");
 		}
 		return lines;
 	}
 
 	protected String cmdString(String... cmds) {
 		switch (cmds.length) {
 		case 0:
 			return "";
 		case 1:
 			return "\"" + escapeJava(cmds[0]) + "\"";
 		default:
 			StringBuilder sb = new StringBuilder(cmdString(cmds[0]));
 			for (int i=1; i<cmds.length; i++) {
 				sb.append(", ");
 				sb.append(cmdString(cmds[i]));
 			}
 			return sb.toString();
 		}
 	}
 
 	protected String escapeJava(String line) {
 		// very crude implementation but ok for generating test code
 		return line.replaceAll("\"", "\\\\\"") //
 				.replaceAll("\\\\", "\\\\\\")
 				.replaceAll("\t", "\\\\t");
 	}
 
 	protected String shellQuote(String s) {
 		return "'" + s.replace("'", "'\\''") + "'";
 	}
 
 	protected String shellQuote(File f) {
 		return "'" + f.getPath().replace("'", "'\\''") + "'";
 	}
 
 	protected void assertStringArrayEquals(String expected, String[] actual) {
 		// if there is more than one line, ignore last one if empty
 		assertEquals(1,
 				actual.length > 1 && actual[actual.length - 1].isEmpty()
 						? actual.length - 1 : actual.length);
 		assertEquals(expected, actual[0]);
 	}
 
 	protected void assertArrayOfLinesEquals(String[] expected, String[] actual) {
 		assertEquals(toString(expected), toString(actual));
 	}
 
 	public static String toString(String... lines) {
 		return toString(Arrays.asList(lines));
 	}
 
 	public static String toString(List<String> lines) {
 		StringBuilder b = new StringBuilder();
 		for (String s : lines) {
 			// trim indentation, to simplify tests
 			s = s.trim();
 			if (s != null && !s.isEmpty()) {
 				b.append(s);
 				b.append('\n');
 			}
 		}
 		// delete last line break to allow simpler tests with one line compare
 		if (b.length() > 0 && b.charAt(b.length() - 1) == '\n') {
 			b.deleteCharAt(b.length() - 1);
 		}
 		return b.toString();
 	}
 
 	public static boolean contains(List<String> lines, String str) {
 		for (String s : lines) {
 			if (s.contains(str)) {
 				return true;
 			}
 		}
 		return false;
 	}
 }