import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Optional;
import java.util.OptionalInt;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import org.junit.Assert;
import org.junit.Test;

public class LambdaExamples {

	@Test
	public void collectToList() {
		List<Integer> result = Stream.of(1, 2, 2).collect(Collectors.toList());
		Assert.assertEquals("[1, 2, 2]", result.toString());
	}

	@Test
	public void collectToListDistinct() {
		List<Integer> result = Stream.of(1, 2, 2).distinct().collect(Collectors.toList());
		Assert.assertEquals("[1, 2]", result.toString());
	}

	@Test
	public void collectToSet() {
		Set<Integer> result = Stream.of(1, 2, 2).collect(Collectors.toSet());
		Assert.assertEquals("[1, 2]", result.toString());
	}

	@Test
	public void collectToMap() {
		Function<Integer, Integer> identity = n -> n;
		Function<Integer, Integer> square = n -> n * n;
		Map<Integer, Integer> result = Stream.of(1, 2, 3).collect(Collectors.toMap(identity, square));
		Assert.assertEquals("{1=1, 2=4, 3=9}", result.toString());
	}

	@Test
	public void filterMax3() {
		Predicate<Integer> predicate = n -> n <= 3;
		Stream<Integer> filtered = Stream.of(1, 2, 3, 4, 5).filter(predicate);
		Assert.assertEquals("[1, 2, 3]", filtered.collect(Collectors.toList()).toString());
	}

	private String applyTo1To5(Predicate<Integer> predicate) {
		return Stream.of(1, 2, 3, 4, 5).filter(predicate).collect(Collectors.toList()).toString();
	}

	@Test
	public void filterWithPredicates() {
		Predicate<Integer> evenPredicate = n -> n % 2 == 0;
		Predicate<Integer> smallPreficate = n -> n <= 3;

		Assert.assertEquals("[2, 4]", applyTo1To5(evenPredicate));
		Assert.assertEquals("[1, 2, 3]", applyTo1To5(smallPreficate));
		Assert.assertEquals("[1, 3, 5]", applyTo1To5(evenPredicate.negate()));
		Assert.assertEquals("[2]", applyTo1To5(smallPreficate.and(evenPredicate)));
		Assert.assertEquals("[1, 2, 3, 4]", applyTo1To5(smallPreficate.or(evenPredicate)));
	}

	@Test
	public void skip() {
		Stream<Integer> filtered = Stream.of(5, 4, 3, 2, 1).skip(2);
		Assert.assertEquals("[3, 2, 1]", filtered.collect(Collectors.toList()).toString());
	}

	@Test
	public void limit() {
		Stream<Integer> filtered = Stream.of(5, 4, 3, 2, 1).limit(2);
		Assert.assertEquals("[5, 4]", filtered.collect(Collectors.toList()).toString());
	}

	@Test
	public void findFirst() {
		Optional<Integer> first = Stream.of(5, 4, 3, 2, 1).findFirst();
		Assert.assertTrue(first.isPresent());
		Assert.assertEquals(new Integer(5), first.get());
	}
	@Test
	public void findAny() {
		Optional<Integer> unknown = Stream.of(5, 4, 3, 2, 1).findAny();
		Assert.assertTrue(unknown.isPresent());
	}

	@Test
	public void forEachSquare() {
		List<Integer> squared = new ArrayList<>();
		Stream.of(1, 2, 3).forEach((n) -> squared.add(n * n));
		Assert.assertEquals("[1, 4, 9]", squared.toString());
	}

	@Test
	public void mapToSquare() {
		Stream<Integer> stream = Stream.of(1, 2, 3).map(n -> n * n);
		Assert.assertEquals("[1, 4, 9]", stream.collect(Collectors.toList()).toString());
	}

	@Test
	public void mapToAnotherType() {
		Stream<String> mapped = Stream.of(1, 2, 3).map(n -> "#" + n);
		Assert.assertEquals("[#1, #2, #3]", mapped.collect(Collectors.toList()).toString());
	}

	@Test
	public void flatMap() {
		List<String> strings = new ArrayList<>();
		strings.add("a,b,c");
		strings.add("d,e,f");

		Stream<String> stream = strings.stream().flatMap(str -> Stream.of(str.split(",")));
		Assert.assertEquals("[a, b, c, d, e, f]", stream.collect(Collectors.toList()).toString());
	}

	@Test
	public void reduceSeedlessSum() {
		OptionalInt total = IntStream.of(1, 2, 3, 4).reduce(Integer::sum);
		Assert.assertEquals(10, total.getAsInt());
	}

	@Test(expected = NoSuchElementException.class)
	public void reduceSeedlessEmpty() {
		OptionalInt total = IntStream.empty().reduce(Integer::sum);
		total.getAsInt();
	}

	@Test
	public void reduceSeededSum() {
		int total = IntStream.of(1, 2, 3, 4).reduce(0, Integer::sum);
		Assert.assertEquals(10, total);
	}

	@Test
	public void reduceSeededSumEmpty() {
		int total = IntStream.empty().reduce(0, Integer::sum);
		Assert.assertEquals(0, total);
	}

	@Test
	public void reduceToAnotherType() {
		BiFunction<StringBuilder, Integer, StringBuilder> accumulator = (sb, val) -> sb.append(val);
		BinaryOperator<StringBuilder> combiner = (s1, s2) -> s1.append(s2);
		StringBuilder reduced = Stream.of(1, 2, 3).reduce(new StringBuilder(), accumulator, combiner);
		Assert.assertEquals("123", reduced.toString());
	}

	public Collector<?, StringBuilder, StringBuilder> stringBuilderCollector() {
		Supplier<StringBuilder> supplier = StringBuilder::new;
		BiConsumer<StringBuilder, ?> accumulator = (StringBuilder sb, Object o) -> sb.append(o);
		BinaryOperator<StringBuilder> combiner = (StringBuilder s1, StringBuilder s2) -> s1.append(s2);
		return Collector.of(supplier, accumulator, combiner);
	}

	public Collector<?, StringBuilder, String> stringCollector() {
		Supplier<StringBuilder> supplier = StringBuilder::new;
		BiConsumer<StringBuilder, ?> accumulator = (StringBuilder sb, Object o) -> sb.append(o);
		BinaryOperator<StringBuilder> combiner = (s1, s2) -> s1.append(s2);
		Function<StringBuilder, String> finisher = StringBuilder::toString;
		return Collector.of(supplier, accumulator, combiner, finisher);
	}
}