/*
    * 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.storage.reftree;
  
  import static org.eclipse.jgit.lib.Constants.OBJ_BLOB;
  import static org.eclipse.jgit.lib.Constants.encode;
  import static org.eclipse.jgit.lib.FileMode.TYPE_GITLINK;
  import static org.eclipse.jgit.lib.FileMode.TYPE_SYMLINK;
  import static org.eclipse.jgit.lib.Ref.Storage.NETWORK;
  import static org.eclipse.jgit.transport.ReceiveCommand.Result.NOT_ATTEMPTED;
  import static org.eclipse.jgit.transport.ReceiveCommand.Result.REJECTED_OTHER_REASON;
  
  import java.io.IOException;
  
  import org.eclipse.jgit.annotations.Nullable;
  import org.eclipse.jgit.dircache.DirCacheEntry;
  import org.eclipse.jgit.errors.MissingObjectException;
  import org.eclipse.jgit.internal.JGitText;
  import org.eclipse.jgit.lib.ObjectId;
  import org.eclipse.jgit.lib.ObjectIdRef;
  import org.eclipse.jgit.lib.ObjectInserter;
  import org.eclipse.jgit.lib.Ref;
  import org.eclipse.jgit.revwalk.RevObject;
  import org.eclipse.jgit.revwalk.RevTag;
  import org.eclipse.jgit.revwalk.RevWalk;
  import org.eclipse.jgit.transport.ReceiveCommand;
  import org.eclipse.jgit.transport.ReceiveCommand.Result;
  
  /**
   * Command to create, update or delete an entry inside a {@link RefTree}.
   * <p>
   * Unlike {@link ReceiveCommand} (which can only update a reference to an
   * {@link ObjectId}), a RefTree Command can also create, modify or delete
   * symbolic references to a target reference.
   * <p>
   * RefTree Commands may wrap a {@code ReceiveCommand} to allow callers to
   * process an existing ReceiveCommand against a RefTree.
   * <p>
   * Commands should be passed into {@link RefTree#apply(java.util.Collection)}
   * for processing.
   */
  public class Command {
  	/**
  	 * Set unprocessed commands as failed due to transaction aborted.
  	 * <p>
  	 * If a command is still {@link Result#NOT_ATTEMPTED} it will be set to
  	 * {@link Result#REJECTED_OTHER_REASON}. If {@code why} is non-null its
  	 * contents will be used as the message for the first command status.
  	 *
  	 * @param commands
  	 *            commands to mark as failed.
  	 * @param why
  	 *            optional message to set on the first aborted command.
  	 */
  	public static void abort(Iterable<Command> commands, @Nullable String why) {
  		if (why == null || why.isEmpty()) {
  			why = JGitText.get().transactionAborted;
  		}
 		for (Command c : commands) {
 			if (c.getResult() == NOT_ATTEMPTED) {
 				c.setResult(REJECTED_OTHER_REASON, why);
 				why = JGitText.get().transactionAborted;
 			}
 		}
 	}
 
 	private final Ref oldRef;
 	private final Ref newRef;
 	private final ReceiveCommand cmd;
 	private Result result;
 
 	/**
 	 * Create a command to create, update or delete a reference.
 	 * <p>
 	 * At least one of {@code oldRef} or {@code newRef} must be supplied.
 	 *
 	 * @param oldRef
 	 *            expected value. Null if the ref should not exist.
 	 * @param newRef
 	 *            desired value, must be peeled if not null and not symbolic.
 	 *            Null to delete the ref.
 	 */
 	public Command(@Nullable Ref oldRef, @Nullable Ref newRef) {
 		this.oldRef = oldRef;
 		this.newRef = newRef;
 		this.cmd = null;
 		this.result = NOT_ATTEMPTED;
 
 		if (oldRef == null && newRef == null) {
 			throw new IllegalArgumentException();
 		}
 		if (newRef != null && !newRef.isPeeled() && !newRef.isSymbolic()) {
 			throw new IllegalArgumentException();
 		}
 		if (oldRef != null && newRef != null
 				&& !oldRef.getName().equals(newRef.getName())) {
 			throw new IllegalArgumentException();
 		}
 	}
 
 	/**
 	 * Construct a RefTree command wrapped around a ReceiveCommand.
 	 *
 	 * @param rw
 	 *            walk instance to peel the {@code newId}.
 	 * @param cmd
 	 *            command received from a push client.
 	 * @throws MissingObjectException
 	 *             {@code oldId} or {@code newId} is missing.
 	 * @throws IOException
 	 *             {@code oldId} or {@code newId} cannot be peeled.
 	 */
 	public Command(RevWalk rw, ReceiveCommand cmd)
 			throws MissingObjectException, IOException {
 		this.oldRef = toRef(rw, cmd.getOldId(), cmd.getRefName(), false);
 		this.newRef = toRef(rw, cmd.getNewId(), cmd.getRefName(), true);
 		this.cmd = cmd;
 	}
 
 	static Ref toRef(RevWalk rw, ObjectId id, String name,
 			boolean mustExist) throws MissingObjectException, IOException {
 		if (ObjectId.zeroId().equals(id)) {
 			return null;
 		}
 
 		try {
 			RevObject o = rw.parseAny(id);
 			if (o instanceof RevTag) {
 				RevObject p = rw.peel(o);
 				return new ObjectIdRef.PeeledTag(NETWORK, name, id, p.copy());
 			}
 			return new ObjectIdRef.PeeledNonTag(NETWORK, name, id);
 		} catch (MissingObjectException e) {
 			if (mustExist) {
 				throw e;
 			}
 			return new ObjectIdRef.Unpeeled(NETWORK, name, id);
 		}
 	}
 
 	/** @return name of the reference affected by this command. */
 	public String getRefName() {
 		if (cmd != null) {
 			return cmd.getRefName();
 		} else if (newRef != null) {
 			return newRef.getName();
 		}
 		return oldRef.getName();
 	}
 
 	/**
 	 * Set the result of this command.
 	 *
 	 * @param result
 	 *            the command result.
 	 */
 	public void setResult(Result result) {
 		setResult(result, null);
 	}
 
 	/**
 	 * Set the result of this command.
 	 *
 	 * @param result
 	 *            the command result.
 	 * @param why
 	 *            optional message explaining the result status.
 	 */
 	public void setResult(Result result, @Nullable String why) {
 		if (cmd != null) {
 			cmd.setResult(result, why);
 		} else {
 			this.result = result;
 		}
 	}
 
 	/** @return result of executing this command. */
 	public Result getResult() {
 		return cmd != null ? cmd.getResult() : result;
 	}
 
 	/** @return optional message explaining command failure. */
 	@Nullable
 	public String getMessage() {
 		return cmd != null ? cmd.getMessage() : null;
 	}
 
 	/**
 	 * Old peeled reference.
 	 *
 	 * @return the old reference; null if the command is creating the reference.
 	 */
 	@Nullable
 	public Ref getOldRef() {
 		return oldRef;
 	}
 
 	/**
 	 * New peeled reference.
 	 *
 	 * @return the new reference; null if the command is deleting the reference.
 	 */
 	@Nullable
 	public Ref getNewRef() {
 		return newRef;
 	}
 
 	@Override
 	public String toString() {
 		StringBuilder s = new StringBuilder();
 		append(s, oldRef, "CREATE"); //$NON-NLS-1$
 		s.append(' ');
 		append(s, newRef, "DELETE"); //$NON-NLS-1$
 		s.append(' ').append(getRefName());
 		s.append(' ').append(getResult());
 		if (getMessage() != null) {
 			s.append(' ').append(getMessage());
 		}
 		return s.toString();
 	}
 
 	private static void append(StringBuilder s, Ref r, String nullName) {
 		if (r == null) {
 			s.append(nullName);
 		} else if (r.isSymbolic()) {
 			s.append(r.getTarget().getName());
 		} else {
 			ObjectId id = r.getObjectId();
 			if (id != null) {
 				s.append(id.name());
 			}
 		}
 	}
 
 	/**
 	 * Check the entry is consistent with either the old or the new ref.
 	 *
 	 * @param entry
 	 *            current entry; null if the entry does not exist.
 	 * @return true if entry matches {@link #getOldRef()} or
 	 *         {@link #getNewRef()}; otherwise false.
 	 */
 	boolean checkRef(@Nullable DirCacheEntry entry) {
 		if (entry != null && entry.getRawMode() == 0) {
 			entry = null;
 		}
 		return check(entry, oldRef) || check(entry, newRef);
 	}
 
 	private static boolean check(@Nullable DirCacheEntry cur,
 			@Nullable Ref exp) {
 		if (cur == null) {
 			// Does not exist, ok if oldRef does not exist.
 			return exp == null;
 		} else if (exp == null) {
 			// Expected to not exist, but currently exists, fail.
 			return false;
 		}
 
 		if (exp.isSymbolic()) {
 			String dst = exp.getTarget().getName();
 			return cur.getRawMode() == TYPE_SYMLINK
 					&& cur.getObjectId().equals(symref(dst));
 		}
 
 		return cur.getRawMode() == TYPE_GITLINK
 				&& cur.getObjectId().equals(exp.getObjectId());
 	}
 
 	static ObjectId symref(String s) {
 		@SuppressWarnings("resource")
 		ObjectInserter.Formatter fmt = new ObjectInserter.Formatter();
 		return fmt.idFor(OBJ_BLOB, encode(s));
 	}
 }