/*
    * Copyright (C) 2010, Google Inc. 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 org.eclipse.jgit.annotations.NonNull;
  import org.eclipse.jgit.annotations.Nullable;
  
  /**
   * A reference that indirectly points at another
   * {@link org.eclipse.jgit.lib.Ref}.
   * <p>
   * A symbolic reference always derives its current value from the target
   * reference.
   */
  public class SymbolicRef implements Ref {
  	private final String name;
  
  	private final Ref target;
  
  	private final long updateIndex;
  
  	/**
  	 * Create a new ref pairing.
  	 *
  	 * @param refName
  	 *            name of this ref.
  	 * @param target
  	 *            the ref we reference and derive our value from.
  	 */
  	public SymbolicRef(@NonNull String refName, @NonNull Ref target) {
  		this.name = refName;
  		this.target = target;
  		this.updateIndex = UNDEFINED_UPDATE_INDEX;
  	}
  
  	/**
  	 * Create a new ref pairing.
  	 *
  	 * @param refName
  	 *            name of this ref.
  	 * @param target
  	 *            the ref we reference and derive our value from.
  	 * @param updateIndex
  	 *            index that increases with each update of the reference
  	 * @since 5.3
  	 */
  	public SymbolicRef(@NonNull String refName, @NonNull Ref target,
  			long updateIndex) {
  		this.name = refName;
  		this.target = target;
  		this.updateIndex = updateIndex;
  	}
  
  	/** {@inheritDoc} */
  	@Override
  	@NonNull
  	public String getName() {
  		return name;
  	}
  
  	/** {@inheritDoc} */
  	@Override
  	public boolean isSymbolic() {
  		return true;
  	}
  
  	/** {@inheritDoc} */
  	@Override
  	@NonNull
  	public Ref getLeaf() {
  		Ref dst = getTarget();
  		while (dst.isSymbolic())
  			dst = dst.getTarget();
  		return dst;
  	}
  
  	/** {@inheritDoc} */
  	@Override
  	@NonNull
  	public Ref getTarget() {
  		return target;
  	}
  
  	/** {@inheritDoc} */
  	@Override
  	@Nullable
  	public ObjectId getObjectId() {
  		return getLeaf().getObjectId();
  	}
  
  	/** {@inheritDoc} */
 	@Override
 	@NonNull
 	public Storage getStorage() {
 		return Storage.LOOSE;
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	@Nullable
 	public ObjectId getPeeledObjectId() {
 		return getLeaf().getPeeledObjectId();
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public boolean isPeeled() {
 		return getLeaf().isPeeled();
 	}
 
 	/**
 	 * {@inheritDoc}
 	 * @since 5.3
 	 */
 	@Override
 	public long getUpdateIndex() {
 		if (updateIndex == UNDEFINED_UPDATE_INDEX) {
 			throw new UnsupportedOperationException();
 		}
 		return updateIndex;
 	}
 
 	/** {@inheritDoc} */
 	@SuppressWarnings("nls")
 	@Override
 	public String toString() {
 		StringBuilder r = new StringBuilder();
 		r.append("SymbolicRef[");
 		Ref cur = this;
 		while (cur.isSymbolic()) {
 			r.append(cur.getName());
 			r.append(" -> ");
 			cur = cur.getTarget();
 		}
 		r.append(cur.getName());
 		r.append('=');
 		r.append(ObjectId.toString(cur.getObjectId()));
 		r.append("(");
 		r.append(updateIndex); // Print value, even if -1
 		r.append(")]");
 		return r.toString();
 	}
 }