/*
    * Copyright (C) 2016, 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.internal.ketch;
  
  import static org.eclipse.jgit.internal.ketch.KetchConstants.ACCEPTED;
  import static org.eclipse.jgit.internal.ketch.KetchConstants.COMMITTED;
  import static org.eclipse.jgit.internal.ketch.KetchConstants.CONFIG_KEY_TYPE;
  import static org.eclipse.jgit.internal.ketch.KetchConstants.CONFIG_SECTION_KETCH;
  import static org.eclipse.jgit.internal.ketch.KetchConstants.DEFAULT_TXN_NAMESPACE;
  import static org.eclipse.jgit.internal.ketch.KetchConstants.STAGE;
  import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_NAME;
  import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_REMOTE;
  
  import java.net.URISyntaxException;
  import java.time.Duration;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Random;
  import java.util.concurrent.Executors;
  import java.util.concurrent.ScheduledExecutorService;
  import java.util.concurrent.ThreadFactory;
  import java.util.concurrent.atomic.AtomicInteger;
  
  import org.eclipse.jgit.annotations.Nullable;
  import org.eclipse.jgit.lib.Config;
  import org.eclipse.jgit.lib.PersonIdent;
  import org.eclipse.jgit.lib.Repository;
  import org.eclipse.jgit.transport.RemoteConfig;
  import org.eclipse.jgit.transport.URIish;
  import org.eclipse.jgit.util.time.MonotonicClock;
  import org.eclipse.jgit.util.time.MonotonicSystemClock;
  import org.eclipse.jgit.util.time.ProposedTimestamp;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Ketch system-wide configuration.
   * <p>
   * This class provides useful defaults for testing and small proof of concepts.
   * Full scale installations are expected to subclass and override methods to
   * provide consistent configuration across all managed repositories.
   * <p>
   * Servers should configure their own {@link ScheduledExecutorService}.
   */
  public class KetchSystem {
  	private static final Random RNG = new Random();
  
  	/** @return default executor, one thread per available processor. */
  	public static ScheduledExecutorService defaultExecutor() {
  		return DefaultExecutorHolder.I;
  	}
  
  	private final ScheduledExecutorService executor;
  	private final MonotonicClock clock;
  	private final String txnNamespace;
  	private final String txnAccepted;
  	private final String txnCommitted;
  	private final String txnStage;
 
 	/** Create a default system with a thread pool of 1 thread per CPU. */
 	public KetchSystem() {
 		this(defaultExecutor(), new MonotonicSystemClock(), DEFAULT_TXN_NAMESPACE);
 	}
 
 	/**
 	 * Create a Ketch system with the provided executor service.
 	 *
 	 * @param executor
 	 *            thread pool to run background operations.
 	 * @param clock
 	 *            clock to create timestamps.
 	 * @param txnNamespace
 	 *            reference namespace for the RefTree graph and associated
 	 *            transaction state. Must begin with {@code "refs/"} and end
 	 *            with {@code '/'}, for example {@code "refs/txn/"}.
 	 */
 	public KetchSystem(ScheduledExecutorService executor, MonotonicClock clock,
 			String txnNamespace) {
 		this.executor = executor;
 		this.clock = clock;
 		this.txnNamespace = txnNamespace;
 		this.txnAccepted = txnNamespace + ACCEPTED;
 		this.txnCommitted = txnNamespace + COMMITTED;
 		this.txnStage = txnNamespace + STAGE;
 	}
 
 	/** @return executor to perform background operations. */
 	public ScheduledExecutorService getExecutor() {
 		return executor;
 	}
 
 	/** @return clock to obtain timestamps from. */
 	public MonotonicClock getClock() {
 		return clock;
 	}
 
 	/**
 	 * @return how long the leader will wait for the {@link #getClock()}'s
 	 *         {@code ProposedTimestamp} used in commits proposed to the RefTree
 	 *         graph ({@link #getTxnAccepted()}). Defaults to 5 seconds.
 	 */
 	public Duration getMaxWaitForMonotonicClock() {
 		return Duration.ofSeconds(5);
 	}
 
 	/**
 	 * @return true if elections should require monotonically increasing commit
 	 *         timestamps. This requires a very good {@link MonotonicClock}.
 	 */
 	public boolean requireMonotonicLeaderElections() {
 		return false;
 	}
 
 	/**
 	 * Get the namespace used for the RefTree graph and transaction management.
 	 *
 	 * @return reference namespace such as {@code "refs/txn/"}.
 	 */
 	public String getTxnNamespace() {
 		return txnNamespace;
 	}
 
 	/** @return name of the accepted RefTree graph. */
 	public String getTxnAccepted() {
 		return txnAccepted;
 	}
 
 	/** @return name of the committed RefTree graph. */
 	public String getTxnCommitted() {
 		return txnCommitted;
 	}
 
 	/** @return prefix for staged objects, e.g. {@code "refs/txn/stage/"}. */
 	public String getTxnStage() {
 		return txnStage;
 	}
 
 	/**
 	 * @param time
 	 *            timestamp for the committer.
 	 * @return identity line for the committer header of a RefTreeGraph.
 	 */
 	public PersonIdent newCommitter(ProposedTimestamp time) {
 		String name = "ketch"; //$NON-NLS-1$
 		String email = "ketch@system"; //$NON-NLS-1$
 		return new PersonIdent(name, email, time);
 	}
 
 	/**
 	 * Construct a random tag to identify a candidate during leader election.
 	 * <p>
 	 * Multiple processes trying to elect themselves leaders at exactly the same
 	 * time (rounded to seconds) using the same
 	 * {@link #newCommitter(ProposedTimestamp)} identity strings, for the same
 	 * term, may generate the same ObjectId for the election commit and falsely
 	 * assume they have both won.
 	 * <p>
 	 * Candidates add this tag to their election ballot commit to disambiguate
 	 * the election. The tag only needs to be unique for a given triplet of
 	 * {@link #newCommitter(ProposedTimestamp)}, system time (rounded to
 	 * seconds), and term. If every replica in the system uses a unique
 	 * {@code newCommitter} (such as including the host name after the
 	 * {@code "@"} in the email address) the tag could be the empty string.
 	 * <p>
 	 * The default implementation generates a few bytes of random data.
 	 *
 	 * @return unique tag; null or empty string if {@code newCommitter()} is
 	 *         sufficiently unique to identify the leader.
 	 */
 	@Nullable
 	public String newLeaderTag() {
 		int n = RNG.nextInt(1 << (6 * 4));
 		return String.format("%06x", Integer.valueOf(n)); //$NON-NLS-1$
 	}
 
 	/**
 	 * Construct the KetchLeader instance of a repository.
 	 *
 	 * @param repo
 	 *            local repository stored by the leader.
 	 * @return leader instance.
 	 * @throws URISyntaxException
 	 *             a follower configuration contains an unsupported URI.
 	 */
 	public KetchLeader createLeader(final Repository repo)
 			throws URISyntaxException {
 		KetchLeader leader = new KetchLeader(this) {
 			@Override
 			protected Repository openRepository() {
 				repo.incrementOpen();
 				return repo;
 			}
 		};
 		leader.setReplicas(createReplicas(leader, repo));
 		return leader;
 	}
 
 	/**
 	 * Get the collection of replicas for a repository.
 	 * <p>
 	 * The collection of replicas must include the local repository.
 	 *
 	 * @param leader
 	 *            the leader driving these replicas.
 	 * @param repo
 	 *            repository to get the replicas of.
 	 * @return collection of replicas for the specified repository.
 	 * @throws URISyntaxException
 	 *             a configured URI is invalid.
 	 */
 	protected List<KetchReplica> createReplicas(KetchLeader leader,
 			Repository repo) throws URISyntaxException {
 		List<KetchReplica> replicas = new ArrayList<>();
 		Config cfg = repo.getConfig();
 		String localName = getLocalName(cfg);
 		for (String name : cfg.getSubsections(CONFIG_KEY_REMOTE)) {
 			if (!hasParticipation(cfg, name)) {
 				continue;
 			}
 
 			ReplicaConfig kc = ReplicaConfig.newFromConfig(cfg, name);
 			if (name.equals(localName)) {
 				replicas.add(new LocalReplica(leader, name, kc));
 				continue;
 			}
 
 			RemoteConfig rc = new RemoteConfig(cfg, name);
 			List<URIish> uris = rc.getPushURIs();
 			if (uris.isEmpty()) {
 				uris = rc.getURIs();
 			}
 			for (URIish uri : uris) {
 				String n = uris.size() == 1 ? name : uri.getHost();
 				replicas.add(new RemoteGitReplica(leader, n, uri, kc, rc));
 			}
 		}
 		return replicas;
 	}
 
 	private static boolean hasParticipation(Config cfg, String name) {
 		return cfg.getString(CONFIG_KEY_REMOTE, name, CONFIG_KEY_TYPE) != null;
 	}
 
 	private static String getLocalName(Config cfg) {
 		return cfg.getString(CONFIG_SECTION_KETCH, null, CONFIG_KEY_NAME);
 	}
 
 	static class DefaultExecutorHolder {
 		private static final Logger log = LoggerFactory.getLogger(KetchSystem.class);
 		static final ScheduledExecutorService I = create();
 
 		private static ScheduledExecutorService create() {
 			int cores = Runtime.getRuntime().availableProcessors();
 			int threads = Math.max(5, cores);
 			log.info("Using {} threads", Integer.valueOf(threads)); //$NON-NLS-1$
 			return Executors.newScheduledThreadPool(
 				threads,
 				new ThreadFactory() {
 					private final AtomicInteger threadCnt = new AtomicInteger();
 
 					@Override
 					public Thread newThread(Runnable r) {
 						int id = threadCnt.incrementAndGet();
 						Thread thr = new Thread(r);
 						thr.setName("KetchExecutor-" + id); //$NON-NLS-1$
 						return thr;
 					}
 				});
 		}
 
 		private DefaultExecutorHolder() {
 		}
 	}
 
 	/**
 	 * Compute a delay in a {@code min..max} interval with random jitter.
 	 *
 	 * @param last
 	 *            amount of delay waited before the last attempt. This is used
 	 *            to seed the next delay interval. Should be 0 if there was no
 	 *            prior delay.
 	 * @param min
 	 *            shortest amount of allowable delay between attempts.
 	 * @param max
 	 *            longest amount of allowable delay between attempts.
 	 * @return new amount of delay to wait before the next attempt.
 	 */
 	static long delay(long last, long min, long max) {
 		long r = Math.max(0, last * 3 - min);
 		if (r > 0) {
 			int c = (int) Math.min(r + 1, Integer.MAX_VALUE);
 			r = RNG.nextInt(c);
 		}
 		return Math.max(Math.min(min + r, max), min);
 	}
 }