/*
    * 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.pgm;
  
  import java.text.MessageFormat;
  import java.util.ArrayList;
  import java.util.EnumSet;
  import java.util.List;
  
  import org.eclipse.jgit.diff.DiffConfig;
  import org.eclipse.jgit.errors.IncorrectObjectTypeException;
  import org.eclipse.jgit.lib.Constants;
  import org.eclipse.jgit.lib.ObjectId;
  import org.eclipse.jgit.lib.Ref;
  import org.eclipse.jgit.pgm.internal.CLIText;
  import org.eclipse.jgit.pgm.opt.PathTreeFilterHandler;
  import org.eclipse.jgit.revwalk.FollowFilter;
  import org.eclipse.jgit.revwalk.ObjectWalk;
  import org.eclipse.jgit.revwalk.RevCommit;
  import org.eclipse.jgit.revwalk.RevFlag;
  import org.eclipse.jgit.revwalk.RevObject;
  import org.eclipse.jgit.revwalk.RevSort;
  import org.eclipse.jgit.revwalk.RevWalk;
  import org.eclipse.jgit.revwalk.filter.AndRevFilter;
  import org.eclipse.jgit.revwalk.filter.AuthorRevFilter;
  import org.eclipse.jgit.revwalk.filter.CommitterRevFilter;
  import org.eclipse.jgit.revwalk.filter.MessageRevFilter;
  import org.eclipse.jgit.revwalk.filter.RevFilter;
  import org.eclipse.jgit.treewalk.filter.AndTreeFilter;
  import org.eclipse.jgit.treewalk.filter.TreeFilter;
  import org.kohsuke.args4j.Argument;
  import org.kohsuke.args4j.Option;
  
  abstract class RevWalkTextBuiltin extends TextBuiltin {
  	RevWalk walk;
  
  	@Option(name = "--objects")
  	boolean objects = false;
  
  	@Option(name = "--parents")
  	boolean parents = false;
  
  	@Option(name = "--total-count")
  	boolean count = false;
  
  	@Option(name = "--all")
  	boolean all = false;
  
  	char[] outbuffer = new char[Constants.OBJECT_ID_LENGTH * 2];
  
  	private final EnumSet<RevSort> sorting = EnumSet.noneOf(RevSort.class);
  
  	private void enableRevSort(RevSort type, boolean on) {
  		if (on)
  			sorting.add(type);
  		else
  			sorting.remove(type);
  	}
  
  	@Option(name = "--date-order")
  	void enableDateOrder(boolean on) {
  		enableRevSort(RevSort.COMMIT_TIME_DESC, on);
  	}
  
  	@Option(name = "--topo-order")
  	void enableTopoOrder(boolean on) {
  		enableRevSort(RevSort.TOPO, on);
  	}
  
  	@Option(name = "--reverse")
  	void enableReverse(boolean on) {
  		enableRevSort(RevSort.REVERSE, on);
  	}
  
  	@Option(name = "--boundary")
  	void enableBoundary(boolean on) {
  		enableRevSort(RevSort.BOUNDARY, on);
  	}
  
  	@Option(name = "--follow", metaVar = "metaVar_path")
  	private String followPath;
  
  	@Argument(index = 0, metaVar = "metaVar_commitish")
  	private List<RevCommit> commits = new ArrayList<>();
  
  	@Option(name = "--", metaVar = "metaVar_path", handler = PathTreeFilterHandler.class)
  	protected TreeFilter pathFilter = TreeFilter.ALL;
  
  	private final List<RevFilter> revLimiter = new ArrayList<>();
  
  	@Option(name = "--author")
 	void addAuthorRevFilter(String who) {
 		revLimiter.add(AuthorRevFilter.create(who));
 	}
 
 	@Option(name = "--committer")
 	void addCommitterRevFilter(String who) {
 		revLimiter.add(CommitterRevFilter.create(who));
 	}
 
 	@Option(name = "--grep")
 	void addCMessageRevFilter(String msg) {
 		revLimiter.add(MessageRevFilter.create(msg));
 	}
 
 	@Option(name = "--max-count", aliases = "-n", metaVar = "metaVar_n")
 	private int maxCount = -1;
 
 	/** {@inheritDoc} */
 	@Override
 	protected void run() throws Exception {
 		walk = createWalk();
 		for (RevSort s : sorting)
 			walk.sort(s, true);
 
 		if (pathFilter == TreeFilter.ALL) {
 			if (followPath != null)
 				walk.setTreeFilter(FollowFilter.create(followPath,
 						db.getConfig().get(DiffConfig.KEY)));
 		} else if (pathFilter != TreeFilter.ALL) {
 			walk.setTreeFilter(AndTreeFilter.create(pathFilter,
 					TreeFilter.ANY_DIFF));
 		}
 
 		if (revLimiter.size() == 1)
 			walk.setRevFilter(revLimiter.get(0));
 		else if (revLimiter.size() > 1)
 			walk.setRevFilter(AndRevFilter.create(revLimiter));
 
 		if (all) {
 			for (Ref a : db.getRefDatabase().getRefs()) {
 				ObjectId oid = a.getPeeledObjectId();
 				if (oid == null)
 					oid = a.getObjectId();
 				try {
 					commits.add(walk.parseCommit(oid));
 				} catch (IncorrectObjectTypeException e) {
 					// Ignore all refs which are not commits
 				}
 			}
 		}
 
 		if (commits.isEmpty()) {
 			final ObjectId head = db.resolve(Constants.HEAD);
 			if (head == null)
 				throw die(MessageFormat.format(CLIText.get().cannotResolve, Constants.HEAD));
 			commits.add(walk.parseCommit(head));
 		}
 		for (RevCommit c : commits) {
 			final RevCommit real = argWalk == walk ? c : walk.parseCommit(c);
 			if (c.has(RevFlag.UNINTERESTING))
 				walk.markUninteresting(real);
 			else
 				walk.markStart(real);
 		}
 
 		final long start = System.currentTimeMillis();
 		final int n = walkLoop();
 		if (count) {
 			final long end = System.currentTimeMillis();
 			errw.print(n);
 			errw.print(' ');
 			errw.println(MessageFormat.format(
 							CLIText.get().timeInMilliSeconds,
 							Long.valueOf(end - start)));
 		}
 	}
 
 	/**
 	 * Create RevWalk
 	 *
 	 * @return a {@link org.eclipse.jgit.revwalk.RevWalk} object.
 	 */
 	protected RevWalk createWalk() {
 		RevWalk result;
 		if (objects)
 			result = new ObjectWalk(db);
 		else if (argWalk != null)
 			result = argWalk;
 		else
 		  result = argWalk = new RevWalk(db);
 		result.setRewriteParents(false);
 		return result;
 	}
 
 	/**
 	 * Loop the walk
 	 *
 	 * @return number of RevCommits walked
 	 * @throws java.lang.Exception
 	 *             if any.
 	 */
 	protected int walkLoop() throws Exception {
 		int n = 0;
 		for (RevCommit c : walk) {
 			if (++n > maxCount && maxCount >= 0)
 				break;
 			show(c);
 		}
 		if (walk instanceof ObjectWalk) {
 			final ObjectWalk../../../../org/eclipse/jgit/revwalk/ObjectWalk.html#ObjectWalk">ObjectWalk ow = (ObjectWalk) walk;
 			for (;;) {
 				final RevObject obj = ow.nextObject();
 				if (obj == null)
 					break;
 				show(ow, obj);
 			}
 		}
 		return n;
 	}
 
 	/**
 	 * "Show" the current RevCommit when called from the main processing loop.
 	 * <p>
 	 * Implement this methods to define the behavior for subclasses of
 	 * RevWalkTextBuiltin.
 	 *
 	 * @param c
 	 *            The current {@link org.eclipse.jgit.revwalk.RevCommit}
 	 * @throws java.lang.Exception
 	 */
 	protected abstract void show(RevCommit c) throws Exception;
 
 	/**
 	 * "Show" the current RevCommit when called from the main processing loop.
 	 * <p>
 	 * The default implementation does nothing because most subclasses only
 	 * process RevCommits.
 	 *
 	 * @param objectWalk
 	 *            the {@link org.eclipse.jgit.revwalk.ObjectWalk} used by
 	 *            {@link #walkLoop()}
 	 * @param currentObject
 	 *            The current {@link org.eclipse.jgit.revwalk.RevObject}
 	 * @throws java.lang.Exception
 	 */
 	protected void show(final ObjectWalk objectWalk,
 			final RevObject currentObject) throws Exception {
 		// Do nothing by default. Most applications cannot show an object.
 	}
 }