/*
    * Copyright (C) 2009, Google Inc.
    * Copyright (C) 2008, Robin Rosenberg <robin.rosenberg@dewire.com>
    * Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org> 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.transport;
  
  import java.io.Serializable;
  import java.net.URISyntaxException;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  
  import org.eclipse.jgit.lib.Config;
  
  /**
   * A remembered remote repository, including URLs and RefSpecs.
   * <p>
   * A remote configuration remembers one or more URLs for a frequently accessed
   * remote repository as well as zero or more fetch and push specifications
   * describing how refs should be transferred between this repository and the
   * remote repository.
   */
  public class RemoteConfig implements Serializable {
  	private static final long serialVersionUID = 1L;
  
  	private static final String SECTION = "remote"; //$NON-NLS-1$
  
  	private static final String KEY_URL = "url"; //$NON-NLS-1$
  
  	private static final String KEY_PUSHURL = "pushurl"; //$NON-NLS-1$
  
  	private static final String KEY_FETCH = "fetch"; //$NON-NLS-1$
  
  	private static final String KEY_PUSH = "push"; //$NON-NLS-1$
  
  	private static final String KEY_UPLOADPACK = "uploadpack"; //$NON-NLS-1$
  
  	private static final String KEY_RECEIVEPACK = "receivepack"; //$NON-NLS-1$
  
  	private static final String KEY_TAGOPT = "tagopt"; //$NON-NLS-1$
  
  	private static final String KEY_MIRROR = "mirror"; //$NON-NLS-1$
  
  	private static final String KEY_TIMEOUT = "timeout"; //$NON-NLS-1$
  
  	private static final String KEY_INSTEADOF = "insteadof"; //$NON-NLS-1$
  
  	private static final String KEY_PUSHINSTEADOF = "pushinsteadof"; //$NON-NLS-1$
  
  	private static final boolean DEFAULT_MIRROR = false;
  
  	/** Default value for {@link #getUploadPack()} if not specified. */
  	public static final String DEFAULT_UPLOAD_PACK = "git-upload-pack"; //$NON-NLS-1$
  
  	/** Default value for {@link #getReceivePack()} if not specified. */
  	public static final String DEFAULT_RECEIVE_PACK = "git-receive-pack"; //$NON-NLS-1$
  
  	/**
  	 * Parse all remote blocks in an existing configuration file, looking for
  	 * remotes configuration.
  	 *
  	 * @param rc
  	 *            the existing configuration to get the remote settings from.
  	 *            The configuration must already be loaded into memory.
  	 * @return all remotes configurations existing in provided repository
  	 *         configuration. Returned configurations are ordered
  	 *         lexicographically by names.
  	 * @throws java.net.URISyntaxException
  	 *             one of the URIs within the remote's configuration is invalid.
  	 */
  	public static List<RemoteConfig> getAllRemoteConfigs(Config rc)
  			throws URISyntaxException {
  		final List<String> names = new ArrayList<>(rc
  				.getSubsections(SECTION));
  		Collections.sort(names);
  
  		final List<RemoteConfig> result = new ArrayList<>(names
  				.size());
  		for (String name : names)
  			result.add(new RemoteConfig(rc, name));
  		return result;
  	}
  
  	private String name;
  
  	private List<URIish> uris;
  
  	private List<URIish> pushURIs;
 
 	private List<RefSpec> fetch;
 
 	private List<RefSpec> push;
 
 	private String uploadpack;
 
 	private String receivepack;
 
 	private TagOpt tagopt;
 
 	private boolean mirror;
 
 	private int timeout;
 
 	/**
 	 * Parse a remote block from an existing configuration file.
 	 * <p>
 	 * This constructor succeeds even if the requested remote is not defined
 	 * within the supplied configuration file. If that occurs then there will be
 	 * no URIs and no ref specifications known to the new instance.
 	 *
 	 * @param rc
 	 *            the existing configuration to get the remote settings from.
 	 *            The configuration must already be loaded into memory.
 	 * @param remoteName
 	 *            subsection key indicating the name of this remote.
 	 * @throws java.net.URISyntaxException
 	 *             one of the URIs within the remote's configuration is invalid.
 	 */
 	public RemoteConfig(Config rc, String remoteName)
 			throws URISyntaxException {
 		name = remoteName;
 
 		String[] vlst;
 		String val;
 
 		vlst = rc.getStringList(SECTION, name, KEY_URL);
 		Map<String, String> insteadOf = getReplacements(rc, KEY_INSTEADOF);
 		uris = new ArrayList<>(vlst.length);
 		for (String s : vlst) {
 			uris.add(new URIish(replaceUri(s, insteadOf)));
 		}
 		String[] plst = rc.getStringList(SECTION, name, KEY_PUSHURL);
 		pushURIs = new ArrayList<>(plst.length);
 		for (String s : plst) {
 			pushURIs.add(new URIish(s));
 		}
 		if (pushURIs.isEmpty()) {
 			// Would default to the uris. If we have pushinsteadof, we must
 			// supply rewritten push uris.
 			Map<String, String> pushInsteadOf = getReplacements(rc,
 					KEY_PUSHINSTEADOF);
 			if (!pushInsteadOf.isEmpty()) {
 				for (String s : vlst) {
 					String replaced = replaceUri(s, pushInsteadOf);
 					if (!s.equals(replaced)) {
 						pushURIs.add(new URIish(replaced));
 					}
 				}
 			}
 		}
 		fetch = rc.getRefSpecs(SECTION, name, KEY_FETCH);
 		push = rc.getRefSpecs(SECTION, name, KEY_PUSH);
 		val = rc.getString(SECTION, name, KEY_UPLOADPACK);
 		if (val == null) {
 			val = DEFAULT_UPLOAD_PACK;
 		}
 		uploadpack = val;
 
 		val = rc.getString(SECTION, name, KEY_RECEIVEPACK);
 		if (val == null) {
 			val = DEFAULT_RECEIVE_PACK;
 		}
 		receivepack = val;
 
 		try {
 			val = rc.getString(SECTION, name, KEY_TAGOPT);
 			tagopt = TagOpt.fromOption(val);
 		} catch (IllegalArgumentException e) {
 			// C git silently ignores invalid tagopt values.
 			tagopt = TagOpt.AUTO_FOLLOW;
 		}
 		mirror = rc.getBoolean(SECTION, name, KEY_MIRROR, DEFAULT_MIRROR);
 		timeout = rc.getInt(SECTION, name, KEY_TIMEOUT, 0);
 	}
 
 	/**
 	 * Update this remote's definition within the configuration.
 	 *
 	 * @param rc
 	 *            the configuration file to store ourselves into.
 	 */
 	public void update(Config rc) {
 		final List<String> vlst = new ArrayList<>();
 
 		vlst.clear();
 		for (URIish u : getURIs())
 			vlst.add(u.toPrivateString());
 		rc.setStringList(SECTION, getName(), KEY_URL, vlst);
 
 		vlst.clear();
 		for (URIish u : getPushURIs())
 			vlst.add(u.toPrivateString());
 		rc.setStringList(SECTION, getName(), KEY_PUSHURL, vlst);
 
 		vlst.clear();
 		for (RefSpec u : getFetchRefSpecs())
 			vlst.add(u.toString());
 		rc.setStringList(SECTION, getName(), KEY_FETCH, vlst);
 
 		vlst.clear();
 		for (RefSpec u : getPushRefSpecs())
 			vlst.add(u.toString());
 		rc.setStringList(SECTION, getName(), KEY_PUSH, vlst);
 
 		set(rc, KEY_UPLOADPACK, getUploadPack(), DEFAULT_UPLOAD_PACK);
 		set(rc, KEY_RECEIVEPACK, getReceivePack(), DEFAULT_RECEIVE_PACK);
 		set(rc, KEY_TAGOPT, getTagOpt().option(), TagOpt.AUTO_FOLLOW.option());
 		set(rc, KEY_MIRROR, mirror, DEFAULT_MIRROR);
 		set(rc, KEY_TIMEOUT, timeout, 0);
 	}
 
 	private void set(final Config rc, final String key,
 			final String currentValue, final String defaultValue) {
 		if (defaultValue.equals(currentValue))
 			unset(rc, key);
 		else
 			rc.setString(SECTION, getName(), key, currentValue);
 	}
 
 	private void set(final Config rc, final String key,
 			final boolean currentValue, final boolean defaultValue) {
 		if (defaultValue == currentValue)
 			unset(rc, key);
 		else
 			rc.setBoolean(SECTION, getName(), key, currentValue);
 	}
 
 	private void set(final Config rc, final String key, final int currentValue,
 			final int defaultValue) {
 		if (defaultValue == currentValue)
 			unset(rc, key);
 		else
 			rc.setInt(SECTION, getName(), key, currentValue);
 	}
 
 	private void unset(Config rc, String key) {
 		rc.unset(SECTION, getName(), key);
 	}
 
 	private Map<String, String> getReplacements(final Config config,
 			final String keyName) {
 		final Map<String, String> replacements = new HashMap<>();
 		for (String url : config.getSubsections(KEY_URL))
 			for (String insteadOf : config.getStringList(KEY_URL, url, keyName))
 				replacements.put(insteadOf, url);
 		return replacements;
 	}
 
 	private String replaceUri(final String uri,
 			final Map<String, String> replacements) {
 		if (replacements.isEmpty()) {
 			return uri;
 		}
 		Entry<String, String> match = null;
 		for (Entry<String, String> replacement : replacements.entrySet()) {
 			// Ignore current entry if not longer than previous match
 			if (match != null
 					&& match.getKey().length() > replacement.getKey()
 							.length()) {
 				continue;
 			}
 			if (!uri.startsWith(replacement.getKey())) {
 				continue;
 			}
 			match = replacement;
 		}
 		if (match != null) {
 			return match.getValue() + uri.substring(match.getKey().length());
 		}
 		return uri;
 	}
 
 	/**
 	 * Get the local name this remote configuration is recognized as.
 	 *
 	 * @return name assigned by the user to this configuration block.
 	 */
 	public String getName() {
 		return name;
 	}
 
 	/**
 	 * Get all configured URIs under this remote.
 	 *
 	 * @return the set of URIs known to this remote.
 	 */
 	public List<URIish> getURIs() {
 		return Collections.unmodifiableList(uris);
 	}
 
 	/**
 	 * Add a new URI to the end of the list of URIs.
 	 *
 	 * @param toAdd
 	 *            the new URI to add to this remote.
 	 * @return true if the URI was added; false if it already exists.
 	 */
 	public boolean addURI(URIish toAdd) {
 		if (uris.contains(toAdd))
 			return false;
 		return uris.add(toAdd);
 	}
 
 	/**
 	 * Remove a URI from the list of URIs.
 	 *
 	 * @param toRemove
 	 *            the URI to remove from this remote.
 	 * @return true if the URI was added; false if it already exists.
 	 */
 	public boolean removeURI(URIish toRemove) {
 		return uris.remove(toRemove);
 	}
 
 	/**
 	 * Get all configured push-only URIs under this remote.
 	 *
 	 * @return the set of URIs known to this remote.
 	 */
 	public List<URIish> getPushURIs() {
 		return Collections.unmodifiableList(pushURIs);
 	}
 
 	/**
 	 * Add a new push-only URI to the end of the list of URIs.
 	 *
 	 * @param toAdd
 	 *            the new URI to add to this remote.
 	 * @return true if the URI was added; false if it already exists.
 	 */
 	public boolean addPushURI(URIish toAdd) {
 		if (pushURIs.contains(toAdd))
 			return false;
 		return pushURIs.add(toAdd);
 	}
 
 	/**
 	 * Remove a push-only URI from the list of URIs.
 	 *
 	 * @param toRemove
 	 *            the URI to remove from this remote.
 	 * @return true if the URI was added; false if it already exists.
 	 */
 	public boolean removePushURI(URIish toRemove) {
 		return pushURIs.remove(toRemove);
 	}
 
 	/**
 	 * Remembered specifications for fetching from a repository.
 	 *
 	 * @return set of specs used by default when fetching.
 	 */
 	public List<RefSpec> getFetchRefSpecs() {
 		return Collections.unmodifiableList(fetch);
 	}
 
 	/**
 	 * Add a new fetch RefSpec to this remote.
 	 *
 	 * @param s
 	 *            the new specification to add.
 	 * @return true if the specification was added; false if it already exists.
 	 */
 	public boolean addFetchRefSpec(RefSpec s) {
 		if (fetch.contains(s))
 			return false;
 		return fetch.add(s);
 	}
 
 	/**
 	 * Override existing fetch specifications with new ones.
 	 *
 	 * @param specs
 	 *            list of fetch specifications to set. List is copied, it can be
 	 *            modified after this call.
 	 */
 	public void setFetchRefSpecs(List<RefSpec> specs) {
 		fetch.clear();
 		fetch.addAll(specs);
 	}
 
 	/**
 	 * Override existing push specifications with new ones.
 	 *
 	 * @param specs
 	 *            list of push specifications to set. List is copied, it can be
 	 *            modified after this call.
 	 */
 	public void setPushRefSpecs(List<RefSpec> specs) {
 		push.clear();
 		push.addAll(specs);
 	}
 
 	/**
 	 * Remove a fetch RefSpec from this remote.
 	 *
 	 * @param s
 	 *            the specification to remove.
 	 * @return true if the specification existed and was removed.
 	 */
 	public boolean removeFetchRefSpec(RefSpec s) {
 		return fetch.remove(s);
 	}
 
 	/**
 	 * Remembered specifications for pushing to a repository.
 	 *
 	 * @return set of specs used by default when pushing.
 	 */
 	public List<RefSpec> getPushRefSpecs() {
 		return Collections.unmodifiableList(push);
 	}
 
 	/**
 	 * Add a new push RefSpec to this remote.
 	 *
 	 * @param s
 	 *            the new specification to add.
 	 * @return true if the specification was added; false if it already exists.
 	 */
 	public boolean addPushRefSpec(RefSpec s) {
 		if (push.contains(s))
 			return false;
 		return push.add(s);
 	}
 
 	/**
 	 * Remove a push RefSpec from this remote.
 	 *
 	 * @param s
 	 *            the specification to remove.
 	 * @return true if the specification existed and was removed.
 	 */
 	public boolean removePushRefSpec(RefSpec s) {
 		return push.remove(s);
 	}
 
 	/**
 	 * Override for the location of 'git-upload-pack' on the remote system.
 	 * <p>
 	 * This value is only useful for an SSH style connection, where Git is
 	 * asking the remote system to execute a program that provides the necessary
 	 * network protocol.
 	 *
 	 * @return location of 'git-upload-pack' on the remote system. If no
 	 *         location has been configured the default of 'git-upload-pack' is
 	 *         returned instead.
 	 */
 	public String getUploadPack() {
 		return uploadpack;
 	}
 
 	/**
 	 * Override for the location of 'git-receive-pack' on the remote system.
 	 * <p>
 	 * This value is only useful for an SSH style connection, where Git is
 	 * asking the remote system to execute a program that provides the necessary
 	 * network protocol.
 	 *
 	 * @return location of 'git-receive-pack' on the remote system. If no
 	 *         location has been configured the default of 'git-receive-pack' is
 	 *         returned instead.
 	 */
 	public String getReceivePack() {
 		return receivepack;
 	}
 
 	/**
 	 * Get the description of how annotated tags should be treated during fetch.
 	 *
 	 * @return option indicating the behavior of annotated tags in fetch.
 	 */
 	public TagOpt getTagOpt() {
 		return tagopt;
 	}
 
 	/**
 	 * Set the description of how annotated tags should be treated on fetch.
 	 *
 	 * @param option
 	 *            method to use when handling annotated tags.
 	 */
 	public void setTagOpt(TagOpt option) {
 		tagopt = option != null ? option : TagOpt.AUTO_FOLLOW;
 	}
 
 	/**
 	 * Whether pushing to the remote automatically deletes remote refs which
 	 * don't exist on the source side.
 	 *
 	 * @return true if pushing to the remote automatically deletes remote refs
 	 *         which don't exist on the source side.
 	 */
 	public boolean isMirror() {
 		return mirror;
 	}
 
 	/**
 	 * Set the mirror flag to automatically delete remote refs.
 	 *
 	 * @param m
 	 *            true to automatically delete remote refs during push.
 	 */
 	public void setMirror(boolean m) {
 		mirror = m;
 	}
 
 	/**
 	 * Get timeout (in seconds) before aborting an IO operation.
 	 *
 	 * @return timeout (in seconds) before aborting an IO operation.
 	 */
 	public int getTimeout() {
 		return timeout;
 	}
 
 	/**
 	 * Set the timeout before willing to abort an IO call.
 	 *
 	 * @param seconds
 	 *            number of seconds to wait (with no data transfer occurring)
 	 *            before aborting an IO read or write operation with this
 	 *            remote.  A timeout of 0 will block indefinitely.
 	 */
 	public void setTimeout(int seconds) {
 		timeout = seconds;
 	}
 }