/*
 * Copyright (C) 2011, 2013 Christian Halstrick <christian.halstrick@sap.com>
 * 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.api;

import java.util.Collections;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.eclipse.jgit.lib.IndexDiff;
import org.eclipse.jgit.lib.IndexDiff.StageState;

A class telling where the working-tree, the index and the current HEAD differ from each other. Collections are exposed containing the paths of the modified files. E.g. to find out which files are dirty in the working tree (modified but not added) you would inspect the collection returned by getModified(). 
 The same path can be returned by multiple getters. E.g. if a modification has been added to the index and afterwards the corresponding working tree file is again modified this path will be returned by getModified() and getChanged() /**
 * A class telling where the working-tree, the index and the current HEAD differ
 * from each other. Collections are exposed containing the paths of the modified
 * files. E.g. to find out which files are dirty in the working tree (modified
 * but not added) you would inspect the collection returned by
 * {@link #getModified()}.
 * <p>
 * The same path can be returned by multiple getters. E.g. if a modification has
 * been added to the index and afterwards the corresponding working tree file is
 * again modified this path will be returned by {@link #getModified()} and
 * {@link #getChanged()}
 */
public class Status {
	private final IndexDiff diff;

	private final boolean clean;

	private final boolean hasUncommittedChanges;

	
Constructor for Status.
Params:
diff –  the IndexDiff having the status/**
	 * Constructor for Status.
	 *
	 * @param diff
	 *            the {@link org.eclipse.jgit.lib.IndexDiff} having the status
	 */
	public Status(IndexDiff diff) {
		super();
		this.diff = diff;
		hasUncommittedChanges = !diff.getAdded().isEmpty() //
				|| !diff.getChanged().isEmpty() //
				|| !diff.getRemoved().isEmpty() //
				|| !diff.getMissing().isEmpty() //
				|| !diff.getModified().isEmpty() //
				|| !diff.getConflicting().isEmpty();
		clean = !hasUncommittedChanges //
				&& diff.getUntracked().isEmpty();
	}

	
Whether the status is clean
Returns:
true if no differences exist between the working-tree, the index, and the current HEAD, false if differences do exist/**
	 * Whether the status is clean
	 *
	 * @return {@code true} if no differences exist between the working-tree,
	 *         the index, and the current HEAD, {@code false} if differences do
	 *         exist
	 */
	public boolean isClean() {
		return clean;
	}

	
Whether there are uncommitted changes
Returns:
true if any tracked file is changed
Since:
3.2/**
	 * Whether there are uncommitted changes
	 *
	 * @return {@code true} if any tracked file is changed
	 * @since 3.2
	 */
	public boolean hasUncommittedChanges() {
		return hasUncommittedChanges;
	}

	
Get files added to the index
Returns:
list of files added to the index, not in HEAD (e.g. what you get if you call git add ... on a newly created file)/**
	 * Get files added to the index
	 *
	 * @return list of files added to the index, not in HEAD (e.g. what you get
	 *         if you call {@code git add ...} on a newly created file)
	 */
	public Set<String> getAdded() {
		return Collections.unmodifiableSet(diff.getAdded());
	}

	
Get changed files from HEAD to index
Returns:
list of files changed from HEAD to index (e.g. what you get if
        you modify an existing file and call 'git add ...' on it)/**
	 * Get changed files from HEAD to index
	 *
	 * @return list of files changed from HEAD to index (e.g. what you get if
	 *         you modify an existing file and call 'git add ...' on it)
	 */
	public Set<String> getChanged() {
		return Collections.unmodifiableSet(diff.getChanged());
	}

	
Get removed files
Returns:
list of files removed from index, but in HEAD (e.g. what you get
        if you call 'git rm ...' on a existing file)/**
	 * Get removed files
	 *
	 * @return list of files removed from index, but in HEAD (e.g. what you get
	 *         if you call 'git rm ...' on a existing file)
	 */
	public Set<String> getRemoved() {
		return Collections.unmodifiableSet(diff.getRemoved());
	}

	
Get missing files
Returns:
list of files in index, but not filesystem (e.g. what you get if
        you call 'rm ...' on a existing file)/**
	 * Get missing files
	 *
	 * @return list of files in index, but not filesystem (e.g. what you get if
	 *         you call 'rm ...' on a existing file)
	 */
	public Set<String> getMissing() {
		return Collections.unmodifiableSet(diff.getMissing());
	}

	
Get modified files relative to the index
Returns:
list of files modified on disk relative to the index (e.g. what
        you get if you modify an existing file without adding it to the
        index)/**
	 * Get modified files relative to the index
	 *
	 * @return list of files modified on disk relative to the index (e.g. what
	 *         you get if you modify an existing file without adding it to the
	 *         index)
	 */
	public Set<String> getModified() {
		return Collections.unmodifiableSet(diff.getModified());
	}

	
Get untracked files
Returns:
list of files that are not ignored, and not in the index. (e.g.
        what you get if you create a new file without adding it to the
        index)/**
	 * Get untracked files
	 *
	 * @return list of files that are not ignored, and not in the index. (e.g.
	 *         what you get if you create a new file without adding it to the
	 *         index)
	 */
	public Set<String> getUntracked() {
		return Collections.unmodifiableSet(diff.getUntracked());
	}

	
Get untracked folders
Returns:
set of directories that are not ignored, and not in the index./**
	 * Get untracked folders
	 *
	 * @return set of directories that are not ignored, and not in the index.
	 */
	public Set<String> getUntrackedFolders() {
		return Collections.unmodifiableSet(diff.getUntrackedFolders());
	}

	
Get conflicting files
Returns:
list of files that are in conflict. (e.g what you get if you
        modify file that was modified by someone else in the meantime)/**
	 * Get conflicting files
	 *
	 * @return list of files that are in conflict. (e.g what you get if you
	 *         modify file that was modified by someone else in the meantime)
	 */
	public Set<String> getConflicting() {
		return Collections.unmodifiableSet(diff.getConflicting());
	}

	
Get StageState of conflicting files
Returns:
a map from conflicting path to its StageState.
Since:
3.0/**
	 * Get StageState of conflicting files
	 *
	 * @return a map from conflicting path to its
	 *         {@link org.eclipse.jgit.lib.IndexDiff.StageState}.
	 * @since 3.0
	 */
	public Map<String, StageState> getConflictingStageState() {
		return Collections.unmodifiableMap(diff.getConflictingStageStates());
	}

	
Get ignored files which are not in the index
Returns:
set of files and folders that are ignored and not in the index./**
	 * Get ignored files which are not in the index
	 *
	 * @return set of files and folders that are ignored and not in the index.
	 */
	public Set<String> getIgnoredNotInIndex() {
		return Collections.unmodifiableSet(diff.getIgnoredNotInIndex());
	}

	
Get uncommitted changes, i.e. all files changed in the index or working
tree
Returns:
set of files and folders that are known to the repo and changed
        either in the index or in the working tree.
Since:
3.2/**
	 * Get uncommitted changes, i.e. all files changed in the index or working
	 * tree
	 *
	 * @return set of files and folders that are known to the repo and changed
	 *         either in the index or in the working tree.
	 * @since 3.2
	 */
	public Set<String> getUncommittedChanges() {
		Set<String> uncommittedChanges = new HashSet<>();
		uncommittedChanges.addAll(diff.getAdded());
		uncommittedChanges.addAll(diff.getChanged());
		uncommittedChanges.addAll(diff.getRemoved());
		uncommittedChanges.addAll(diff.getMissing());
		uncommittedChanges.addAll(diff.getModified());
		uncommittedChanges.addAll(diff.getConflicting());
		return uncommittedChanges;
	}
}