package org.lucares.utils;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class CollectionUtils {
	public static <T, R extends T> void mapInPlace(final List<T> list, final Function<T, R> mapper) {
		for (int i = 0; i < list.size(); i++) {
			final T value = list.get(i);
			final T newValue = mapper.apply(value);
			list.set(i, newValue);
		}
	}

	public static <T, R> List<R> map(final Collection<T> list, final Function<T, R> mapper) {
		final List<R> result = new ArrayList<>(list.size());

		for (final T t : list) {
			result.add(mapper.apply(t));
		}

		return result;
	}

	public static <T, R> List<R> map(final T[] input, final Function<T, R> mapper) {
		return Stream.of(input).map(mapper).collect(Collectors.toList());
	}

	public static <T, V> Map<T, V> createMapFromValues(final Iterable<V> iterable, final Function<V, T> keyMapper) {
		final Map<T, V> result = new HashMap<>();

		for (final V value : iterable) {
			final T key = keyMapper.apply(value);

			result.put(key, value);
		}

		return result;
	}

	public static <KEY, VALUE> Map<KEY, VALUE> createMapFromKeys(final Iterable<KEY> iterable,
			final Function<KEY, VALUE> valueMapper) {
		final Map<KEY, VALUE> result = new HashMap<>();

		for (final KEY key : iterable) {
			final VALUE value = valueMapper.apply(key);

			result.put(key, value);
		}

		return result;
	}

	public static <T> List<T> filter(final Collection<T> collection, final Predicate<T> predicate) {
		return collection.stream().filter(predicate).collect(Collectors.toList());
	}

}