package animaltype;

import static org.junit.Assert.*;
import org.junit.Assert;
import org.junit.Test;

import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.Spliterator;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class AnimalTest {
    @Test
    public void testPublish() {

        List<Animal> animals = Arrays
            .asList(
                new Animal( "first", AnimalType.HUMAN ),
                new Animal( "first", AnimalType.DOG ),
                new Animal( "second", AnimalType.HUMAN ),
                new Animal( "first", AnimalType.CAT )
            )
        ;


        Stream<Integer> infiniteStreamOfInts = Stream.iterate( 0, i -> i+1 );

        Stream<Animal> infiniteStreamOfAnimals = infiniteStreamOfInts
            .map(
                i->animals.get(
                    i % animals.size()
                )
            )
        ;

        Set<Animal> setOfAnimals = InfiniteStream.firstFrom( infiniteStreamOfAnimals, AnimalType.values().length );

        Assert.assertTrue( setOfAnimals.size() == AnimalType.values().length );

        System.out.println( setOfAnimals );

        String actual = setOfAnimals.toString();
        String expected = "[first HUMAN animal, first DOG animal, first CAT animal]";
        String message = System.lineSeparator() +
            expected + " <- expected" + System.lineSeparator() +
            actual + " <- actual" + System.lineSeparator()
        ;
        Assert.assertEquals(message, expected, actual);
    }

}

// Displays
// [HUMAN animal 1, DOG animal 1, CAT animal 1]

class InfiniteStream {
    public static <T> Set<T> firstFrom( Stream<T> infiniteStream, int size ) {
        Set<T> set = new LinkedHashSet<>();

        infiniteStream
            .takeWhile( x->set.size() < size )
            .collect(
                Collectors.toCollection(
                    ()->set
                )
            )
        ;

        return set;
    }
}

enum AnimalType{ HUMAN, DOG, CAT }

class Animal {

    public Animal( String tag, AnimalType type ) {
        this.tag = tag;
        this.type = type;
    }

    public AnimalType getAnimalType() { return type; }

    public String toString() { return tag + " " + type + " animal"; }

    @Override
    public int hashCode() { return Objects.hashCode( type ); }

    @Override
    public boolean equals( Object that ) {
        return that != null
            && that.getClass() == this.getClass()
            && ( (Animal) that ).type == this.type
        ;
    }

    private String tag;
    private AnimalType type;
}