/*
    * Copyright (C) 2010, Chris Aniszczyk <caniszczyk@gmail.com>
    * 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 static java.util.stream.Collectors.toList;
  
  import java.io.IOException;
  import java.net.URISyntaxException;
  import java.text.MessageFormat;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.List;
  
  import org.eclipse.jgit.annotations.Nullable;
  import org.eclipse.jgit.api.errors.GitAPIException;
  import org.eclipse.jgit.api.errors.InvalidConfigurationException;
  import org.eclipse.jgit.api.errors.InvalidRemoteException;
  import org.eclipse.jgit.api.errors.JGitInternalException;
  import org.eclipse.jgit.errors.ConfigInvalidException;
  import org.eclipse.jgit.errors.NoRemoteRepositoryException;
  import org.eclipse.jgit.errors.NotSupportedException;
  import org.eclipse.jgit.errors.TransportException;
  import org.eclipse.jgit.internal.JGitText;
  import org.eclipse.jgit.lib.ConfigConstants;
  import org.eclipse.jgit.lib.Constants;
  import org.eclipse.jgit.lib.NullProgressMonitor;
  import org.eclipse.jgit.lib.ObjectId;
  import org.eclipse.jgit.lib.ProgressMonitor;
  import org.eclipse.jgit.lib.Repository;
  import org.eclipse.jgit.lib.StoredConfig;
  import org.eclipse.jgit.lib.SubmoduleConfig.FetchRecurseSubmodulesMode;
  import org.eclipse.jgit.revwalk.RevWalk;
  import org.eclipse.jgit.submodule.SubmoduleWalk;
  import org.eclipse.jgit.transport.FetchResult;
  import org.eclipse.jgit.transport.RefSpec;
  import org.eclipse.jgit.transport.TagOpt;
  import org.eclipse.jgit.transport.Transport;
  
  /**
   * A class used to execute a {@code Fetch} command. It has setters for all
   * supported options and arguments of this command and a {@link #call()} method
   * to finally execute the command.
   *
   * @see <a href="http://www.kernel.org/pub/software/scm/git/docs/git-fetch.html"
   *      >Git documentation about Fetch</a>
   */
  public class FetchCommand extends TransportCommand<FetchCommand, FetchResult> {
  	private String remote = Constants.DEFAULT_REMOTE_NAME;
  
  	private List<RefSpec> refSpecs;
  
  	private ProgressMonitor monitor = NullProgressMonitor.INSTANCE;
  
  	private boolean checkFetchedObjects;
  
  	private Boolean removeDeletedRefs;
  
  	private boolean dryRun;
  
 	private boolean thin = Transport.DEFAULT_FETCH_THIN;
 
 	private TagOpt tagOption;
 
 	private FetchRecurseSubmodulesMode submoduleRecurseMode = null;
 
 	private Callback callback;
 
 	private boolean isForceUpdate;
 
 	/**
 	 * Callback for status of fetch operation.
 	 *
 	 * @since 4.8
 	 *
 	 */
 	public interface Callback {
 		/**
 		 * Notify fetching a submodule.
 		 *
 		 * @param name
 		 *            the submodule name.
 		 */
 		void fetchingSubmodule(String name);
 	}
 
 	/**
 	 * Constructor for FetchCommand.
 	 *
 	 * @param repo
 	 *            a {@link org.eclipse.jgit.lib.Repository} object.
 	 */
 	protected FetchCommand(Repository repo) {
 		super(repo);
 		refSpecs = new ArrayList<>(3);
 	}
 
 	private FetchRecurseSubmodulesMode getRecurseMode(String path) {
 		// Use the caller-specified mode, if set
 		if (submoduleRecurseMode != null) {
 			return submoduleRecurseMode;
 		}
 
 		// Fall back to submodule.name.fetchRecurseSubmodules, if set
 		FetchRecurseSubmodulesMode mode = repo.getConfig().getEnum(
 				FetchRecurseSubmodulesMode.values(),
 				ConfigConstants.CONFIG_SUBMODULE_SECTION, path,
 				ConfigConstants.CONFIG_KEY_FETCH_RECURSE_SUBMODULES, null);
 		if (mode != null) {
 			return mode;
 		}
 
 		// Fall back to fetch.recurseSubmodules, if set
 		mode = repo.getConfig().getEnum(FetchRecurseSubmodulesMode.values(),
 				ConfigConstants.CONFIG_FETCH_SECTION, null,
 				ConfigConstants.CONFIG_KEY_RECURSE_SUBMODULES, null);
 		if (mode != null) {
 			return mode;
 		}
 
 		// Default to on-demand mode
 		return FetchRecurseSubmodulesMode.ON_DEMAND;
 	}
 
 	private void fetchSubmodules(FetchResult results)
 			throws org.eclipse.jgit.api.errors.TransportException,
 			GitAPIException, InvalidConfigurationException {
 		try (SubmoduleWalkuleWalk.html#SubmoduleWalk">SubmoduleWalk walk = new SubmoduleWalk(repo);
 				RevWalk revWalk = new RevWalk(repo)) {
 			// Walk over submodules in the parent repository's FETCH_HEAD.
 			ObjectId fetchHead = repo.resolve(Constants.FETCH_HEAD);
 			if (fetchHead == null) {
 				return;
 			}
 			walk.setTree(revWalk.parseTree(fetchHead));
 			while (walk.next()) {
 				try (Repository submoduleRepo = walk.getRepository()) {
 
 					// Skip submodules that don't exist locally (have not been
 					// cloned), are not registered in the .gitmodules file, or
 					// not registered in the parent repository's config.
 					if (submoduleRepo == null || walk.getModulesPath() == null
 							|| walk.getConfigUrl() == null) {
 						continue;
 					}
 
 					FetchRecurseSubmodulesMode recurseMode = getRecurseMode(
 							walk.getPath());
 
 					// When the fetch mode is "yes" we always fetch. When the
 					// mode
 					// is "on demand", we only fetch if the submodule's revision
 					// was
 					// updated to an object that is not currently present in the
 					// submodule.
 					if ((recurseMode == FetchRecurseSubmodulesMode.ON_DEMAND
 							&& !submoduleRepo.getObjectDatabase()
 									.has(walk.getObjectId()))
 							|| recurseMode == FetchRecurseSubmodulesMode.YES) {
 						FetchCommand f = new FetchCommand(submoduleRepo)
 								.setProgressMonitor(monitor)
 								.setTagOpt(tagOption)
 								.setCheckFetchedObjects(checkFetchedObjects)
 								.setRemoveDeletedRefs(isRemoveDeletedRefs())
 								.setThin(thin)
 								.setRefSpecs(applyOptions(refSpecs))
 								.setDryRun(dryRun)
 								.setRecurseSubmodules(recurseMode);
 						configure(f);
 						if (callback != null) {
 							callback.fetchingSubmodule(walk.getPath());
 						}
 						results.addSubmodule(walk.getPath(), f.call());
 					}
 				}
 			}
 		} catch (IOException e) {
 			throw new JGitInternalException(e.getMessage(), e);
 		} catch (ConfigInvalidException e) {
 			throw new InvalidConfigurationException(e.getMessage(), e);
 		}
 	}
 
 	/**
 	 * {@inheritDoc}
 	 * <p>
 	 * Execute the {@code fetch} command with all the options and parameters
 	 * collected by the setter methods of this class. Each instance of this
 	 * class should only be used for one invocation of the command (means: one
 	 * call to {@link #call()})
 	 */
 	@Override
 	public FetchResult call() throws GitAPIException, InvalidRemoteException,
 			org.eclipse.jgit.api.errors.TransportException {
 		checkCallable();
 
 		try (Transport transport = Transport.open(repo, remote)) {
 			transport.setCheckFetchedObjects(checkFetchedObjects);
 			transport.setRemoveDeletedRefs(isRemoveDeletedRefs());
 			transport.setDryRun(dryRun);
 			if (tagOption != null)
 				transport.setTagOpt(tagOption);
 			transport.setFetchThin(thin);
 			configure(transport);
 			FetchResult result = transport.fetch(monitor,
 					applyOptions(refSpecs));
 			if (!repo.isBare()) {
 				fetchSubmodules(result);
 			}
 
 			return result;
 		} catch (NoRemoteRepositoryException e) {
 			throw new InvalidRemoteException(MessageFormat.format(
 					JGitText.get().invalidRemote, remote), e);
 		} catch (TransportException e) {
 			throw new org.eclipse.jgit.api.errors.TransportException(
 					e.getMessage(), e);
 		} catch (URISyntaxException e) {
 			throw new InvalidRemoteException(MessageFormat.format(
 					JGitText.get().invalidRemote, remote));
 		} catch (NotSupportedException e) {
 			throw new JGitInternalException(
 					JGitText.get().exceptionCaughtDuringExecutionOfFetchCommand,
 					e);
 		}
 
 	}
 
 	private List<RefSpec> applyOptions(List<RefSpec> refSpecs2) {
 		if (!isForceUpdate()) {
 			return refSpecs2;
 		}
 		List<RefSpec> updated = new ArrayList<>(3);
 		for (RefSpec refSpec : refSpecs2) {
 			updated.add(refSpec.setForceUpdate(true));
 		}
 		return updated;
 	}
 
 	/**
 	 * Set the mode to be used for recursing into submodules.
 	 *
 	 * @param recurse
 	 *            corresponds to the
 	 *            --recurse-submodules/--no-recurse-submodules options. If
 	 *            {@code null} use the value of the
 	 *            {@code submodule.name.fetchRecurseSubmodules} option
 	 *            configured per submodule. If not specified there, use the
 	 *            value of the {@code fetch.recurseSubmodules} option configured
 	 *            in git config. If not configured in either, "on-demand" is the
 	 *            built-in default.
 	 * @return {@code this}
 	 * @since 4.7
 	 */
 	public FetchCommand setRecurseSubmodules(
 			@Nullable FetchRecurseSubmodulesMode recurse) {
 		checkCallable();
 		submoduleRecurseMode = recurse;
 		return this;
 	}
 
 	/**
 	 * The remote (uri or name) used for the fetch operation. If no remote is
 	 * set, the default value of <code>Constants.DEFAULT_REMOTE_NAME</code> will
 	 * be used.
 	 *
 	 * @see Constants#DEFAULT_REMOTE_NAME
 	 * @param remote
 	 *            name of a remote
 	 * @return {@code this}
 	 */
 	public FetchCommand setRemote(String remote) {
 		checkCallable();
 		this.remote = remote;
 		return this;
 	}
 
 	/**
 	 * Get the remote
 	 *
 	 * @return the remote used for the remote operation
 	 */
 	public String getRemote() {
 		return remote;
 	}
 
 	/**
 	 * Get timeout
 	 *
 	 * @return the timeout used for the fetch operation
 	 */
 	public int getTimeout() {
 		return timeout;
 	}
 
 	/**
 	 * Whether to check received objects for validity
 	 *
 	 * @return whether to check received objects for validity
 	 */
 	public boolean isCheckFetchedObjects() {
 		return checkFetchedObjects;
 	}
 
 	/**
 	 * If set to {@code true}, objects received will be checked for validity
 	 *
 	 * @param checkFetchedObjects
 	 *            whether to check objects for validity
 	 * @return {@code this}
 	 */
 	public FetchCommand setCheckFetchedObjects(boolean checkFetchedObjects) {
 		checkCallable();
 		this.checkFetchedObjects = checkFetchedObjects;
 		return this;
 	}
 
 	/**
 	 * Whether to remove refs which no longer exist in the source
 	 *
 	 * @return whether to remove refs which no longer exist in the source
 	 */
 	public boolean isRemoveDeletedRefs() {
 		if (removeDeletedRefs != null)
 			return removeDeletedRefs.booleanValue();
 		else { // fall back to configuration
 			boolean result = false;
 			StoredConfig config = repo.getConfig();
 			result = config.getBoolean(ConfigConstants.CONFIG_FETCH_SECTION,
 					null, ConfigConstants.CONFIG_KEY_PRUNE, result);
 			result = config.getBoolean(ConfigConstants.CONFIG_REMOTE_SECTION,
 					remote, ConfigConstants.CONFIG_KEY_PRUNE, result);
 			return result;
 		}
 	}
 
 	/**
 	 * If set to {@code true}, refs are removed which no longer exist in the
 	 * source
 	 *
 	 * @param removeDeletedRefs
 	 *            whether to remove deleted {@code Ref}s
 	 * @return {@code this}
 	 */
 	public FetchCommand setRemoveDeletedRefs(boolean removeDeletedRefs) {
 		checkCallable();
 		this.removeDeletedRefs = Boolean.valueOf(removeDeletedRefs);
 		return this;
 	}
 
 	/**
 	 * Get progress monitor
 	 *
 	 * @return the progress monitor for the fetch operation
 	 */
 	public ProgressMonitor getProgressMonitor() {
 		return monitor;
 	}
 
 	/**
 	 * The progress monitor associated with the fetch operation. By default,
 	 * this is set to <code>NullProgressMonitor</code>
 	 *
 	 * @see NullProgressMonitor
 	 * @param monitor
 	 *            a {@link org.eclipse.jgit.lib.ProgressMonitor}
 	 * @return {@code this}
 	 */
 	public FetchCommand setProgressMonitor(ProgressMonitor monitor) {
 		checkCallable();
 		if (monitor == null) {
 			monitor = NullProgressMonitor.INSTANCE;
 		}
 		this.monitor = monitor;
 		return this;
 	}
 
 	/**
 	 * Get list of {@code RefSpec}s
 	 *
 	 * @return the ref specs
 	 */
 	public List<RefSpec> getRefSpecs() {
 		return refSpecs;
 	}
 
 	/**
 	 * The ref specs to be used in the fetch operation
 	 *
 	 * @param specs
 	 *            String representation of {@code RefSpec}s
 	 * @return {@code this}
 	 * @since 4.9
 	 */
 	public FetchCommand setRefSpecs(String... specs) {
 		return setRefSpecs(
 				Arrays.stream(specs).map(RefSpec::new).collect(toList()));
 	}
 
 	/**
 	 * The ref specs to be used in the fetch operation
 	 *
 	 * @param specs
 	 *            one or multiple {@link org.eclipse.jgit.transport.RefSpec}s
 	 * @return {@code this}
 	 */
 	public FetchCommand setRefSpecs(RefSpec... specs) {
 		return setRefSpecs(Arrays.asList(specs));
 	}
 
 	/**
 	 * The ref specs to be used in the fetch operation
 	 *
 	 * @param specs
 	 *            list of {@link org.eclipse.jgit.transport.RefSpec}s
 	 * @return {@code this}
 	 */
 	public FetchCommand setRefSpecs(List<RefSpec> specs) {
 		checkCallable();
 		this.refSpecs.clear();
 		this.refSpecs.addAll(specs);
 		return this;
 	}
 
 	/**
 	 * Whether to do a dry run
 	 *
 	 * @return the dry run preference for the fetch operation
 	 */
 	public boolean isDryRun() {
 		return dryRun;
 	}
 
 	/**
 	 * Sets whether the fetch operation should be a dry run
 	 *
 	 * @param dryRun
 	 *            whether to do a dry run
 	 * @return {@code this}
 	 */
 	public FetchCommand setDryRun(boolean dryRun) {
 		checkCallable();
 		this.dryRun = dryRun;
 		return this;
 	}
 
 	/**
 	 * Get thin-pack preference
 	 *
 	 * @return the thin-pack preference for fetch operation
 	 */
 	public boolean isThin() {
 		return thin;
 	}
 
 	/**
 	 * Sets the thin-pack preference for fetch operation.
 	 *
 	 * Default setting is Transport.DEFAULT_FETCH_THIN
 	 *
 	 * @param thin
 	 *            the thin-pack preference
 	 * @return {@code this}
 	 */
 	public FetchCommand setThin(boolean thin) {
 		checkCallable();
 		this.thin = thin;
 		return this;
 	}
 
 	/**
 	 * Sets the specification of annotated tag behavior during fetch
 	 *
 	 * @param tagOpt
 	 *            the {@link org.eclipse.jgit.transport.TagOpt}
 	 * @return {@code this}
 	 */
 	public FetchCommand setTagOpt(TagOpt tagOpt) {
 		checkCallable();
 		this.tagOption = tagOpt;
 		return this;
 	}
 
 	/**
 	 * Register a progress callback.
 	 *
 	 * @param callback
 	 *            the callback
 	 * @return {@code this}
 	 * @since 4.8
 	 */
 	public FetchCommand setCallback(Callback callback) {
 		this.callback = callback;
 		return this;
 	}
 
 	/**
 	 * Whether fetch --force option is enabled
 	 *
 	 * @return whether refs affected by the fetch are updated forcefully
 	 * @since 5.0
 	 */
 	public boolean isForceUpdate() {
 		return this.isForceUpdate;
 	}
 
 	/**
 	 * Set fetch --force option
 	 *
 	 * @param force
 	 *            whether to update refs affected by the fetch forcefully
 	 * @return this command
 	 * @since 5.0
 	 */
 	public FetchCommand setForceUpdate(boolean force) {
 		this.isForceUpdate = force;
 		return this;
 	}
 }