/*
 * Copyright (C) 2008 The Guava Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.collect;

import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Predicates.and;
import static com.google.common.base.Predicates.in;
import static com.google.common.base.Predicates.not;
import static com.google.common.collect.CollectPreconditions.checkNonnegative;
import static com.google.common.math.LongMath.binomial;

import java.util.AbstractCollection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

import javax.annotation.Nullable;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Function;
import com.google.common.base.Joiner;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import com.google.common.math.IntMath;
import com.google.common.primitives.Ints;

/**
 * Provides static methods for working with {@code Collection} instances.
 *
 * @author Chris Povirk
 * @author Mike Bostock
 * @author Jared Levy
 * @since 2.0 (imported from Google Collections Library)
 */
@GwtCompatible
public final class Collections2 {
	private Collections2() {
	}

	/**
	 * Returns the elements of {@code unfiltered} that satisfy a predicate. The
	 * returned collection is a live view of {@code unfiltered}; changes to one
	 * affect the other.
	 *
	 * <p>
	 * The resulting collection's iterator does not support {@code remove()}, but
	 * all other collection methods are supported. When given an element that
	 * doesn't satisfy the predicate, the collection's {@code add()} and {@code
	 * addAll()} methods throw an {@link IllegalArgumentException}. When methods
	 * such as {@code removeAll()} and {@code clear()} are called on the filtered
	 * collection, only elements that satisfy the filter will be removed from the
	 * underlying collection.
	 *
	 * <p>
	 * The returned collection isn't threadsafe or serializable, even if
	 * {@code unfiltered} is.
	 *
	 * <p>
	 * Many of the filtered collection's methods, such as {@code size()}, iterate
	 * across every element in the underlying collection and determine which
	 * elements satisfy the filter. When a live view is <i>not</i> needed, it may be
	 * faster to copy {@code Iterables.filter(unfiltered, predicate)} and use the
	 * copy.
	 *
	 * <p>
	 * <b>Warning:</b> {@code predicate} must be <i>consistent with equals</i>, as
	 * documented at {@link Predicate#apply}. Do not provide a predicate such as
	 * {@code Predicates.instanceOf(ArrayList.class)}, which is inconsistent with
	 * equals. (See {@link Iterables#filter(Iterable, Class)} for related
	 * functionality.)
	 */
	// TODO(kevinb): how can we omit that Iterables link when building gwt
	// javadoc?
	public static <E> Collection<E> filter(Collection<E> unfiltered, Predicate<? super E> predicate) {
		if (unfiltered instanceof FilteredCollection) {
			// Support clear(), removeAll(), and retainAll() when filtering a filtered
			// collection.
			return ((FilteredCollection<E>) unfiltered).createCombined(predicate);
		}

		return new FilteredCollection<E>(checkNotNull(unfiltered), checkNotNull(predicate));
	}

	/**
	 * Delegates to {@link Collection#contains}. Returns {@code false} if the
	 * {@code contains} method throws a {@code ClassCastException} or
	 * {@code NullPointerException}.
	 */
	static boolean safeContains(Collection<?> collection, @Nullable Object object) {
		checkNotNull(collection);
		try {
			return collection.contains(object);
		} catch (ClassCastException e) {
			return false;
		} catch (NullPointerException e) {
			return false;
		}
	}

	/**
	 * Delegates to {@link Collection#remove}. Returns {@code false} if the
	 * {@code remove} method throws a {@code ClassCastException} or
	 * {@code NullPointerException}.
	 */
	static boolean safeRemove(Collection<?> collection, @Nullable Object object) {
		checkNotNull(collection);
		try {
			return collection.remove(object);
		} catch (ClassCastException e) {
			return false;
		} catch (NullPointerException e) {
			return false;
		}
	}

	static class FilteredCollection<E> extends AbstractCollection<E> {
		final Collection<E> unfiltered;
		final Predicate<? super E> predicate;

		FilteredCollection(Collection<E> unfiltered, Predicate<? super E> predicate) {
			this.unfiltered = unfiltered;
			this.predicate = predicate;
		}

		FilteredCollection<E> createCombined(Predicate<? super E> newPredicate) {
			return new FilteredCollection<E>(unfiltered, Predicates.<E>and(predicate, newPredicate));
			// .<E> above needed to compile in JDK 5
		}

		@Override
		public boolean add(E element) {
			checkArgument(predicate.apply(element));
			return unfiltered.add(element);
		}

		@Override
		public boolean addAll(Collection<? extends E> collection) {
			for (E element : collection) {
				checkArgument(predicate.apply(element));
			}
			return unfiltered.addAll(collection);
		}

		@Override
		public void clear() {
			Iterables.removeIf(unfiltered, predicate);
		}

		@Override
		public boolean contains(@Nullable Object element) {
			if (safeContains(unfiltered, element)) {
				@SuppressWarnings("unchecked") // element is in unfiltered, so it must be an E
				E e = (E) element;
				return predicate.apply(e);
			}
			return false;
		}

		@Override
		public boolean containsAll(Collection<?> collection) {
			return containsAllImpl(this, collection);
		}

		@Override
		public boolean isEmpty() {
			return !Iterables.any(unfiltered, predicate);
		}

		@Override
		public Iterator<E> iterator() {
			return Iterators.filter(unfiltered.iterator(), predicate);
		}

		@Override
		public boolean remove(Object element) {
			return contains(element) && unfiltered.remove(element);
		}

		@Override
		public boolean removeAll(final Collection<?> collection) {
			return Iterables.removeIf(unfiltered, and(predicate, (Predicate<E>)in(collection)));
		}

		@Override
		public boolean retainAll(final Collection<?> collection) {
			return Iterables.removeIf(unfiltered, and(predicate, (Predicate<E>)not(in(collection))));
		}

		@Override
		public int size() {
			return Iterators.size(iterator());
		}

		@Override
		public Object[] toArray() {
			// creating an ArrayList so filtering happens once
			return Lists.newArrayList(iterator()).toArray();
		}

		@Override
		public <T> T[] toArray(T[] array) {
			return Lists.newArrayList(iterator()).toArray(array);
		}
	}

	/**
	 * Returns a collection that applies {@code function} to each element of
	 * {@code fromCollection}. The returned collection is a live view of {@code
	 * fromCollection}; changes to one affect the other.
	 *
	 * <p>
	 * The returned collection's {@code add()} and {@code addAll()} methods throw an
	 * {@link UnsupportedOperationException}. All other collection methods are
	 * supported, as long as {@code fromCollection} supports them.
	 *
	 * <p>
	 * The returned collection isn't threadsafe or serializable, even if
	 * {@code fromCollection} is.
	 *
	 * <p>
	 * When a live view is <i>not</i> needed, it may be faster to copy the
	 * transformed collection and use the copy.
	 *
	 * <p>
	 * If the input {@code Collection} is known to be a {@code List}, consider
	 * {@link Lists#transform}. If only an {@code Iterable} is available, use
	 * {@link Iterables#transform}.
	 */
	public static <F, T> Collection<T> transform(Collection<F> fromCollection, Function<? super F, T> function) {
		return new TransformedCollection<F, T>(fromCollection, function);
	}

	static class TransformedCollection<F, T> extends AbstractCollection<T> {
		final Collection<F> fromCollection;
		final Function<? super F, ? extends T> function;

		TransformedCollection(Collection<F> fromCollection, Function<? super F, ? extends T> function) {
			this.fromCollection = checkNotNull(fromCollection);
			this.function = checkNotNull(function);
		}

		@Override
		public void clear() {
			fromCollection.clear();
		}

		@Override
		public boolean isEmpty() {
			return fromCollection.isEmpty();
		}

		@Override
		public Iterator<T> iterator() {
			return Iterators.transform(fromCollection.iterator(), function);
		}

		@Override
		public int size() {
			return fromCollection.size();
		}
	}

	/**
	 * Returns {@code true} if the collection {@code self} contains all of the
	 * elements in the collection {@code c}.
	 *
	 * <p>
	 * This method iterates over the specified collection {@code c}, checking each
	 * element returned by the iterator in turn to see if it is contained in the
	 * specified collection {@code self}. If all elements are so contained,
	 * {@code true} is returned, otherwise {@code false}.
	 *
	 * @param self a collection which might contain all elements in {@code c}
	 * @param c    a collection whose elements might be contained by {@code self}
	 */
	static boolean containsAllImpl(Collection<?> self, Collection<?> c) {
		return Iterables.all(c, Predicates.in(self));
	}

	/**
	 * An implementation of {@link Collection#toString()}.
	 */
	static String toStringImpl(final Collection<?> collection) {
		StringBuilder sb = newStringBuilderForCollection(collection.size()).append('[');
		STANDARD_JOINER.appendTo(sb, Iterables.transform(collection, new Function<Object, Object>() {
			@Override
			public Object apply(Object input) {
				return input == collection ? "(this Collection)" : input;
			}
		}));
		return sb.append(']').toString();
	}

	/**
	 * Returns best-effort-sized StringBuilder based on the given collection size.
	 */
	static StringBuilder newStringBuilderForCollection(int size) {
		checkNonnegative(size, "size");
		return new StringBuilder((int) Math.min(size * 8L, Ints.MAX_POWER_OF_TWO));
	}

	/**
	 * Used to avoid http://bugs.sun.com/view_bug.do?bug_id=6558557
	 */
	static <T> Collection<T> cast(Iterable<T> iterable) {
		return (Collection<T>) iterable;
	}

	static final Joiner STANDARD_JOINER = Joiner.on(", ").useForNull("null");

	/**
	 * Returns a {@link Collection} of all the permutations of the specified
	 * {@link Iterable}.
	 *
	 * <p>
	 * <i>Notes:</i> This is an implementation of the algorithm for Lexicographical
	 * Permutations Generation, described in Knuth's "The Art of Computer
	 * Programming", Volume 4, Chapter 7, Section 7.2.1.2. The iteration order
	 * follows the lexicographical order. This means that the first permutation will
	 * be in ascending order, and the last will be in descending order.
	 *
	 * <p>
	 * Duplicate elements are considered equal. For example, the list [1, 1] will
	 * have only one permutation, instead of two. This is why the elements have to
	 * implement {@link Comparable}.
	 *
	 * <p>
	 * An empty iterable has only one permutation, which is an empty list.
	 *
	 * <p>
	 * This method is equivalent to
	 * {@code Collections2.orderedPermutations(list, Ordering.natural())}.
	 *
	 * @param elements the original iterable whose elements have to be permuted.
	 * @return an immutable {@link Collection} containing all the different
	 *         permutations of the original iterable.
	 * @throws NullPointerException if the specified iterable is null or has any
	 *                              null elements.
	 * @since 12.0
	 */
	@Beta
	public static <E extends Comparable<? super E>> Collection<List<E>> orderedPermutations(Iterable<E> elements) {
		return orderedPermutations(elements, Ordering.natural());
	}

	/**
	 * Returns a {@link Collection} of all the permutations of the specified
	 * {@link Iterable} using the specified {@link Comparator} for establishing the
	 * lexicographical ordering.
	 *
	 * <p>
	 * Examples:
	 * 
	 * <pre>
	 *    {@code
	 *
	 *   for (List<String> perm : orderedPermutations(asList("b", "c", "a"))) {
	 *     println(perm);
	 *   }
	 *   // -> ["a", "b", "c"]
	 *   // -> ["a", "c", "b"]
	 *   // -> ["b", "a", "c"]
	 *   // -> ["b", "c", "a"]
	 *   // -> ["c", "a", "b"]
	 *   // -> ["c", "b", "a"]
	 *
	 *   for (List<Integer> perm : orderedPermutations(asList(1, 2, 2, 1))) {
	 *     println(perm);
	 *   }
	 *   // -> [1, 1, 2, 2]
	 *   // -> [1, 2, 1, 2]
	 *   // -> [1, 2, 2, 1]
	 *   // -> [2, 1, 1, 2]
	 *   // -> [2, 1, 2, 1]
	 *   // -> [2, 2, 1, 1]}
	 * </pre>
	 *
	 * <p>
	 * <i>Notes:</i> This is an implementation of the algorithm for Lexicographical
	 * Permutations Generation, described in Knuth's "The Art of Computer
	 * Programming", Volume 4, Chapter 7, Section 7.2.1.2. The iteration order
	 * follows the lexicographical order. This means that the first permutation will
	 * be in ascending order, and the last will be in descending order.
	 *
	 * <p>
	 * Elements that compare equal are considered equal and no new permutations are
	 * created by swapping them.
	 *
	 * <p>
	 * An empty iterable has only one permutation, which is an empty list.
	 *
	 * @param elements   the original iterable whose elements have to be permuted.
	 * @param comparator a comparator for the iterable's elements.
	 * @return an immutable {@link Collection} containing all the different
	 *         permutations of the original iterable.
	 * @throws NullPointerException If the specified iterable is null, has any null
	 *                              elements, or if the specified comparator is
	 *                              null.
	 * @since 12.0
	 */
	@Beta
	public static <E> Collection<List<E>> orderedPermutations(Iterable<E> elements, Comparator<? super E> comparator) {
		return new OrderedPermutationCollection<E>(elements, comparator);
	}

	private static final class OrderedPermutationCollection<E> extends AbstractCollection<List<E>> {
		final ImmutableList<E> inputList;
		final Comparator<? super E> comparator;
		final int size;

		OrderedPermutationCollection(Iterable<E> input, Comparator<? super E> comparator) {
			this.inputList = Ordering.from(comparator).immutableSortedCopy(input);
			this.comparator = comparator;
			this.size = calculateSize(inputList, comparator);
		}

		/**
		 * The number of permutations with repeated elements is calculated as follows:
		 * <ul>
		 * <li>For an empty list, it is 1 (base case).</li>
		 * <li>When r numbers are added to a list of n-r elements, the number of
		 * permutations is increased by a factor of (n choose r).</li>
		 * </ul>
		 */
		private static <E> int calculateSize(List<E> sortedInputList, Comparator<? super E> comparator) {
			long permutations = 1;
			int n = 1;
			int r = 1;
			while (n < sortedInputList.size()) {
				int comparison = comparator.compare(sortedInputList.get(n - 1), sortedInputList.get(n));
				if (comparison < 0) {
					// We move to the next non-repeated element.
					permutations *= binomial(n, r);
					r = 0;
					if (!isPositiveInt(permutations)) {
						return Integer.MAX_VALUE;
					}
				}
				n++;
				r++;
			}
			permutations *= binomial(n, r);
			if (!isPositiveInt(permutations)) {
				return Integer.MAX_VALUE;
			}
			return (int) permutations;
		}

		@Override
		public int size() {
			return size;
		}

		@Override
		public boolean isEmpty() {
			return false;
		}

		@Override
		public Iterator<List<E>> iterator() {
			return new OrderedPermutationIterator<E>(inputList, comparator);
		}

		@Override
		public boolean contains(@Nullable Object obj) {
			if (obj instanceof List) {
				List<?> list = (List<?>) obj;
				return isPermutation(inputList, list);
			}
			return false;
		}

		@Override
		public String toString() {
			return "orderedPermutationCollection(" + inputList + ")";
		}
	}

	private static final class OrderedPermutationIterator<E> extends AbstractIterator<List<E>> {

		List<E> nextPermutation;
		final Comparator<? super E> comparator;

		OrderedPermutationIterator(List<E> list, Comparator<? super E> comparator) {
			this.nextPermutation = Lists.newArrayList(list);
			this.comparator = comparator;
		}

		@Override
		protected List<E> computeNext() {
			if (nextPermutation == null) {
				return endOfData();
			}
			ImmutableList<E> next = ImmutableList.copyOf(nextPermutation);
			calculateNextPermutation();
			return next;
		}

		void calculateNextPermutation() {
			int j = findNextJ();
			if (j == -1) {
				nextPermutation = null;
				return;
			}

			int l = findNextL(j);
			Collections.swap(nextPermutation, j, l);
			int n = nextPermutation.size();
			Collections.reverse(nextPermutation.subList(j + 1, n));
		}

		int findNextJ() {
			for (int k = nextPermutation.size() - 2; k >= 0; k--) {
				if (comparator.compare(nextPermutation.get(k), nextPermutation.get(k + 1)) < 0) {
					return k;
				}
			}
			return -1;
		}

		int findNextL(int j) {
			E ak = nextPermutation.get(j);
			for (int l = nextPermutation.size() - 1; l > j; l--) {
				if (comparator.compare(ak, nextPermutation.get(l)) < 0) {
					return l;
				}
			}
			throw new AssertionError("this statement should be unreachable");
		}
	}

	/**
	 * Returns a {@link Collection} of all the permutations of the specified
	 * {@link Collection}.
	 *
	 * <p>
	 * <i>Notes:</i> This is an implementation of the Plain Changes algorithm for
	 * permutations generation, described in Knuth's "The Art of Computer
	 * Programming", Volume 4, Chapter 7, Section 7.2.1.2.
	 *
	 * <p>
	 * If the input list contains equal elements, some of the generated permutations
	 * will be equal.
	 *
	 * <p>
	 * An empty collection has only one permutation, which is an empty list.
	 *
	 * @param elements the original collection whose elements have to be permuted.
	 * @return an immutable {@link Collection} containing all the different
	 *         permutations of the original collection.
	 * @throws NullPointerException if the specified collection is null or has any
	 *                              null elements.
	 * @since 12.0
	 */
	@Beta
	public static <E> Collection<List<E>> permutations(Collection<E> elements) {
		return new PermutationCollection<E>(ImmutableList.copyOf(elements));
	}

	private static final class PermutationCollection<E> extends AbstractCollection<List<E>> {
		final ImmutableList<E> inputList;

		PermutationCollection(ImmutableList<E> input) {
			this.inputList = input;
		}

		@Override
		public int size() {
			return IntMath.factorial(inputList.size());
		}

		@Override
		public boolean isEmpty() {
			return false;
		}

		@Override
		public Iterator<List<E>> iterator() {
			return new PermutationIterator<E>(inputList);
		}

		@Override
		public boolean contains(@Nullable Object obj) {
			if (obj instanceof List) {
				List<?> list = (List<?>) obj;
				return isPermutation(inputList, list);
			}
			return false;
		}

		@Override
		public String toString() {
			return "permutations(" + inputList + ")";
		}
	}

	private static class PermutationIterator<E> extends AbstractIterator<List<E>> {
		final List<E> list;
		final int[] c;
		final int[] o;
		int j;

		PermutationIterator(List<E> list) {
			this.list = new ArrayList<E>(list);
			int n = list.size();
			c = new int[n];
			o = new int[n];
			Arrays.fill(c, 0);
			Arrays.fill(o, 1);
			j = Integer.MAX_VALUE;
		}

		@Override
		protected List<E> computeNext() {
			if (j <= 0) {
				return endOfData();
			}
			ImmutableList<E> next = ImmutableList.copyOf(list);
			calculateNextPermutation();
			return next;
		}

		void calculateNextPermutation() {
			j = list.size() - 1;
			int s = 0;

			// Handle the special case of an empty list. Skip the calculation of the
			// next permutation.
			if (j == -1) {
				return;
			}

			while (true) {
				int q = c[j] + o[j];
				if (q < 0) {
					switchDirection();
					continue;
				}
				if (q == j + 1) {
					if (j == 0) {
						break;
					}
					s++;
					switchDirection();
					continue;
				}

				Collections.swap(list, j - c[j] + s, j - q + s);
				c[j] = q;
				break;
			}
		}

		void switchDirection() {
			o[j] = -o[j];
			j--;
		}
	}

	/**
	 * Returns {@code true} if the second list is a permutation of the first.
	 */
	private static boolean isPermutation(List<?> first, List<?> second) {
		if (first.size() != second.size()) {
			return false;
		}
		Multiset<?> firstMultiset = HashMultiset.create(first);
		Multiset<?> secondMultiset = HashMultiset.create(second);
		return firstMultiset.equals(secondMultiset);
	}

	private static boolean isPositiveInt(long n) {
		return n >= 0 && n <= Integer.MAX_VALUE;
	}
}
