/*
    * Copyright (C) 2012 Google Inc.
    * and other copyright owners as documented in the project's IP log.
    *
    * This program and the accompanying materials are made available
    * under the terms of the Eclipse Distribution License v1.0 which
    * accompanies this distribution, is reproduced below, and is
    * available at http://www.eclipse.org/org/documents/edl-v10.php
    *
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or
   * without modification, are permitted provided that the following
   * conditions are met:
   *
   * - Redistributions of source code must retain the above copyright
   *   notice, this list of conditions and the following disclaimer.
   *
   * - Redistributions in binary form must reproduce the above
   *   copyright notice, this list of conditions and the following
   *   disclaimer in the documentation and/or other materials provided
   *   with the distribution.
   *
   * - Neither the name of the Eclipse Foundation, Inc. nor the
   *   names of its contributors may be used to endorse or promote
   *   products derived from this software without specific prior
   *   written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
   * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
   * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
   * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
   * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  package org.eclipse.jgit.api;
  
  import java.io.Closeable;
  import java.io.IOException;
  import java.io.OutputStream;
  import java.text.MessageFormat;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.ConcurrentMap;
  
  import org.eclipse.jgit.api.errors.GitAPIException;
  import org.eclipse.jgit.api.errors.JGitInternalException;
  import org.eclipse.jgit.errors.IncorrectObjectTypeException;
  import org.eclipse.jgit.internal.JGitText;
  import org.eclipse.jgit.lib.Constants;
  import org.eclipse.jgit.lib.FileMode;
  import org.eclipse.jgit.lib.MutableObjectId;
  import org.eclipse.jgit.lib.ObjectId;
  import org.eclipse.jgit.lib.ObjectLoader;
  import org.eclipse.jgit.lib.ObjectReader;
  import org.eclipse.jgit.lib.Repository;
  import org.eclipse.jgit.revwalk.RevCommit;
  import org.eclipse.jgit.revwalk.RevObject;
  import org.eclipse.jgit.revwalk.RevTree;
  import org.eclipse.jgit.revwalk.RevWalk;
  import org.eclipse.jgit.treewalk.TreeWalk;
  import org.eclipse.jgit.treewalk.filter.PathFilterGroup;
  
  /**
   * Create an archive of files from a named tree.
   * <p>
   * Examples (<code>git</code> is a {@link org.eclipse.jgit.api.Git} instance):
   * <p>
   * Create a tarball from HEAD:
   *
   * <pre>
   * ArchiveCommand.registerFormat("tar", new TarFormat());
   * try {
   * 	git.archive().setTree(db.resolve(&quot;HEAD&quot;)).setOutputStream(out).call();
   * } finally {
   * 	ArchiveCommand.unregisterFormat("tar");
   * }
   * </pre>
   * <p>
   * Create a ZIP file from master:
   *
   * <pre>
   * ArchiveCommand.registerFormat("zip", new ZipFormat());
   * try {
   *	git.archive().
   *		.setTree(db.resolve(&quot;master&quot;))
   *		.setFormat("zip")
   *		.setOutputStream(out)
  *		.call();
  * } finally {
  *	ArchiveCommand.unregisterFormat("zip");
  * }
  * </pre>
  *
  * @see <a href="http://git-htmldocs.googlecode.com/git/git-archive.html" >Git
  *      documentation about archive</a>
  * @since 3.1
  */
 public class ArchiveCommand extends GitCommand<OutputStream> {
 	/**
 	 * Archival format.
 	 *
 	 * Usage:
 	 *	Repository repo = git.getRepository();
 	 *	T out = format.createArchiveOutputStream(System.out);
 	 *	try {
 	 *		for (...) {
 	 *			format.putEntry(out, path, mode, repo.open(objectId));
 	 *		}
 	 *		out.close();
 	 *	}
 	 *
 	 * @param <T>
 	 *            type representing an archive being created.
 	 */
 	public static interface Format<T extends Closeable> {
 		/**
 		 * Start a new archive. Entries can be included in the archive using the
 		 * putEntry method, and then the archive should be closed using its
 		 * close method.
 		 *
 		 * @param s
 		 *            underlying output stream to which to write the archive.
 		 * @return new archive object for use in putEntry
 		 * @throws IOException
 		 *             thrown by the underlying output stream for I/O errors
 		 */
 		T createArchiveOutputStream(OutputStream s) throws IOException;
 
 		/**
 		 * Start a new archive. Entries can be included in the archive using the
 		 * putEntry method, and then the archive should be closed using its
 		 * close method. In addition options can be applied to the underlying
 		 * stream. E.g. compression level.
 		 *
 		 * @param s
 		 *            underlying output stream to which to write the archive.
 		 * @param o
 		 *            options to apply to the underlying output stream. Keys are
 		 *            option names and values are option values.
 		 * @return new archive object for use in putEntry
 		 * @throws IOException
 		 *             thrown by the underlying output stream for I/O errors
 		 * @since 4.0
 		 */
 		T createArchiveOutputStream(OutputStream s, Map<String, Object> o)
 				throws IOException;
 
 		/**
 		 * Write an entry to an archive.
 		 *
 		 * @param out
 		 *            archive object from createArchiveOutputStream
 		 * @param tree
 		 *            the tag, commit, or tree object to produce an archive for
 		 * @param path
 		 *            full filename relative to the root of the archive (with
 		 *            trailing '/' for directories)
 		 * @param mode
 		 *            mode (for example FileMode.REGULAR_FILE or
 		 *            FileMode.SYMLINK)
 		 * @param loader
 		 *            blob object with data for this entry (null for
 		 *            directories)
 		 * @throws IOException
 		 *             thrown by the underlying output stream for I/O errors
 		 * @since 4.7
 		 */
 		void putEntry(T out, ObjectId tree, String path, FileMode mode,
 				ObjectLoader loader) throws IOException;
 
 		/**
 		 * Filename suffixes representing this format (e.g.,
 		 * { ".tar.gz", ".tgz" }).
 		 *
 		 * The behavior is undefined when suffixes overlap (if
 		 * one format claims suffix ".7z", no other format should
 		 * take ".tar.7z").
 		 *
 		 * @return this format's suffixes
 		 */
 		Iterable<String> suffixes();
 	}
 
 	/**
 	 * Signals an attempt to use an archival format that ArchiveCommand
 	 * doesn't know about (for example due to a typo).
 	 */
 	public static class UnsupportedFormatException extends GitAPIException {
 		private static final long serialVersionUID = 1L;
 
 		private final String format;
 
 		/**
 		 * @param format the problematic format name
 		 */
 		public UnsupportedFormatException(String format) {
 			super(MessageFormat.format(JGitText.get().unsupportedArchiveFormat, format));
 			this.format = format;
 		}
 
 		/**
 		 * @return the problematic format name
 		 */
 		public String getFormat() {
 			return format;
 		}
 	}
 
 	private static class FormatEntry {
 		final Format<?> format;
 		/** Number of times this format has been registered. */
 		final int refcnt;
 
 		public FormatEntry(Format<?> format, int refcnt) {
 			if (format == null)
 				throw new NullPointerException();
 			this.format = format;
 			this.refcnt = refcnt;
 		}
 	}
 
 	/**
 	 * Available archival formats (corresponding to values for
 	 * the --format= option)
 	 */
 	private static final ConcurrentMap<String, FormatEntry> formats =
 			new ConcurrentHashMap<>();
 
 	/**
 	 * Replaces the entry for a key only if currently mapped to a given
 	 * value.
 	 *
 	 * @param map a map
 	 * @param key key with which the specified value is associated
 	 * @param oldValue expected value for the key (null if should be absent).
 	 * @param newValue value to be associated with the key (null to remove).
 	 * @return true if the value was replaced
 	 */
 	private static <K, V> boolean replace(ConcurrentMap<K, V> map,
 			K key, V oldValue, V newValue) {
 		if (oldValue == null && newValue == null) // Nothing to do.
 			return true;
 
 		if (oldValue == null)
 			return map.putIfAbsent(key, newValue) == null;
 		else if (newValue == null)
 			return map.remove(key, oldValue);
 		else
 			return map.replace(key, oldValue, newValue);
 	}
 
 	/**
 	 * Adds support for an additional archival format.  To avoid
 	 * unnecessary dependencies, ArchiveCommand does not have support
 	 * for any formats built in; use this function to add them.
 	 * <p>
 	 * OSGi plugins providing formats should call this function at
 	 * bundle activation time.
 	 * <p>
 	 * It is okay to register the same archive format with the same
 	 * name multiple times, but don't forget to unregister it that
 	 * same number of times, too.
 	 * <p>
 	 * Registering multiple formats with different names and the
 	 * same or overlapping suffixes results in undefined behavior.
 	 * TODO: check that suffixes don't overlap.
 	 *
 	 * @param name name of a format (e.g., "tar" or "zip").
 	 * @param fmt archiver for that format
 	 * @throws JGitInternalException
 	 *              A different archival format with that name was
 	 *              already registered.
 	 */
 	public static void registerFormat(String name, Format<?> fmt) {
 		if (fmt == null)
 			throw new NullPointerException();
 
 		FormatEntry old, entry;
 		do {
 			old = formats.get(name);
 			if (old == null) {
 				entry = new FormatEntry(fmt, 1);
 				continue;
 			}
 			if (!old.format.equals(fmt))
 				throw new JGitInternalException(MessageFormat.format(
 						JGitText.get().archiveFormatAlreadyRegistered,
 						name));
 			entry = new FormatEntry(old.format, old.refcnt + 1);
 		} while (!replace(formats, name, old, entry));
 	}
 
 	/**
 	 * Marks support for an archival format as no longer needed so its
 	 * Format can be garbage collected if no one else is using it either.
 	 * <p>
 	 * In other words, this decrements the reference count for an
 	 * archival format.  If the reference count becomes zero, removes
 	 * support for that format.
 	 *
 	 * @param name name of format (e.g., "tar" or "zip").
 	 * @throws JGitInternalException
 	 *              No such archival format was registered.
 	 */
 	public static void unregisterFormat(String name) {
 		FormatEntry old, entry;
 		do {
 			old = formats.get(name);
 			if (old == null)
 				throw new JGitInternalException(MessageFormat.format(
 						JGitText.get().archiveFormatAlreadyAbsent,
 						name));
 			if (old.refcnt == 1) {
 				entry = null;
 				continue;
 			}
 			entry = new FormatEntry(old.format, old.refcnt - 1);
 		} while (!replace(formats, name, old, entry));
 	}
 
 	private static Format<?> formatBySuffix(String filenameSuffix)
 			throws UnsupportedFormatException {
 		if (filenameSuffix != null)
 			for (FormatEntry entry : formats.values()) {
 				Format<?> fmt = entry.format;
 				for (String sfx : fmt.suffixes())
 					if (filenameSuffix.endsWith(sfx))
 						return fmt;
 			}
 		return lookupFormat("tar"); //$NON-NLS-1$
 	}
 
 	private static Format<?> lookupFormat(String formatName) throws UnsupportedFormatException {
 		FormatEntry entry = formats.get(formatName);
 		if (entry == null)
 			throw new UnsupportedFormatException(formatName);
 		return entry.format;
 	}
 
 	private OutputStream out;
 	private ObjectId tree;
 	private String prefix;
 	private String format;
 	private Map<String, Object> formatOptions = new HashMap<>();
 	private List<String> paths = new ArrayList<>();
 
 	/** Filename suffix, for automatically choosing a format. */
 	private String suffix;
 
 	/**
 	 * Constructor for ArchiveCommand
 	 *
 	 * @param repo
 	 *            the {@link org.eclipse.jgit.lib.Repository}
 	 */
 	public ArchiveCommand(Repository repo) {
 		super(repo);
 		setCallable(false);
 	}
 
 	private <T extends Closeable> OutputStream writeArchive(Format<T> fmt) {
 		try {
 			try (TreeWalk walk = new TreeWalk(repo);
 					RevWalk rw = new RevWalk(walk.getObjectReader());
 					T outa = fmt.createArchiveOutputStream(out,
 							formatOptions)) {
 				String pfx = prefix == null ? "" : prefix; //$NON-NLS-1$
 				MutableObjectId idBuf = new MutableObjectId();
 				ObjectReader reader = walk.getObjectReader();
 
 				RevObject o = rw.peel(rw.parseAny(tree));
 				walk.reset(getTree(o));
 				if (!paths.isEmpty()) {
 					walk.setFilter(PathFilterGroup.createFromStrings(paths));
 				}
 
 				// Put base directory into archive
 				if (pfx.endsWith("/")) { //$NON-NLS-1$
 					fmt.putEntry(outa, o, pfx.replaceAll("[/]+$", "/"), //$NON-NLS-1$ //$NON-NLS-2$
 							FileMode.TREE, null);
 				}
 
 				while (walk.next()) {
 					String name = pfx + walk.getPathString();
 					FileMode mode = walk.getFileMode(0);
 
 					if (walk.isSubtree())
 						walk.enterSubtree();
 
 					if (mode == FileMode.GITLINK) {
 						// TODO(jrn): Take a callback to recurse
 						// into submodules.
 						mode = FileMode.TREE;
 					}
 
 					if (mode == FileMode.TREE) {
 						fmt.putEntry(outa, o, name + "/", mode, null); //$NON-NLS-1$
 						continue;
 					}
 					walk.getObjectId(idBuf, 0);
 					fmt.putEntry(outa, o, name, mode, reader.open(idBuf));
 				}
 				return out;
 			} finally {
 				out.close();
 			}
 		} catch (IOException e) {
 			// TODO(jrn): Throw finer-grained errors.
 			throw new JGitInternalException(
 					JGitText.get().exceptionCaughtDuringExecutionOfArchiveCommand, e);
 		}
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public OutputStream call() throws GitAPIException {
 		checkCallable();
 
 		Format<?> fmt;
 		if (format == null)
 			fmt = formatBySuffix(suffix);
 		else
 			fmt = lookupFormat(format);
 		return writeArchive(fmt);
 	}
 
 	/**
 	 * Set the tag, commit, or tree object to produce an archive for
 	 *
 	 * @param tree
 	 *            the tag, commit, or tree object to produce an archive for
 	 * @return this
 	 */
 	public ArchiveCommand setTree(ObjectId tree) {
 		if (tree == null)
 			throw new IllegalArgumentException();
 
 		this.tree = tree;
 		setCallable(true);
 		return this;
 	}
 
 	/**
 	 * Set string prefixed to filenames in archive
 	 *
 	 * @param prefix
 	 *            string prefixed to filenames in archive (e.g., "master/").
 	 *            null means to not use any leading prefix.
 	 * @return this
 	 * @since 3.3
 	 */
 	public ArchiveCommand setPrefix(String prefix) {
 		this.prefix = prefix;
 		return this;
 	}
 
 	/**
 	 * Set the intended filename for the produced archive. Currently the only
 	 * effect is to determine the default archive format when none is specified
 	 * with {@link #setFormat(String)}.
 	 *
 	 * @param filename
 	 *            intended filename for the archive
 	 * @return this
 	 */
 	public ArchiveCommand setFilename(String filename) {
 		int slash = filename.lastIndexOf('/');
 		int dot = filename.indexOf('.', slash + 1);
 
 		if (dot == -1)
 			this.suffix = ""; //$NON-NLS-1$
 		else
 			this.suffix = filename.substring(dot);
 		return this;
 	}
 
 	/**
 	 * Set output stream
 	 *
 	 * @param out
 	 *            the stream to which to write the archive
 	 * @return this
 	 */
 	public ArchiveCommand setOutputStream(OutputStream out) {
 		this.out = out;
 		return this;
 	}
 
 	/**
 	 * Set archive format
 	 *
 	 * @param fmt
 	 *            archive format (e.g., "tar" or "zip"). null means to choose
 	 *            automatically based on the archive filename.
 	 * @return this
 	 */
 	public ArchiveCommand setFormat(String fmt) {
 		this.format = fmt;
 		return this;
 	}
 
 	/**
 	 * Set archive format options
 	 *
 	 * @param options
 	 *            archive format options (e.g., level=9 for zip compression).
 	 * @return this
 	 * @since 4.0
 	 */
 	public ArchiveCommand setFormatOptions(Map<String, Object> options) {
 		this.formatOptions = options;
 		return this;
 	}
 
 	/**
 	 * Set an optional parameter path. without an optional path parameter, all
 	 * files and subdirectories of the current working directory are included in
 	 * the archive. If one or more paths are specified, only these are included.
 	 *
 	 * @param paths
 	 *            file names (e.g <code>file1.c</code>) or directory names (e.g.
 	 *            <code>dir</code> to add <code>dir/file1</code> and
 	 *            <code>dir/file2</code>) can also be given to add all files in
 	 *            the directory, recursively. Fileglobs (e.g. *.c) are not yet
 	 *            supported.
 	 * @return this
 	 * @since 3.4
 	 */
 	public ArchiveCommand setPaths(String... paths) {
 		this.paths = Arrays.asList(paths);
 		return this;
 	}
 
 	private RevTree getTree(RevObject o)
 			throws IncorrectObjectTypeException {
 		final RevTree t;
 		if (o instanceof RevCommit) {
 			t = ((RevCommit) o).getTree();
 		} else if (!(o instanceof RevTree)) {
 			throw new IncorrectObjectTypeException(tree.toObjectId(),
 					Constants.TYPE_TREE);
 		} else {
 			t = (RevTree) o;
 		}
 		return t;
 	}
 
 }