package au.id.zancanaro.javacheck;

import au.id.zancanaro.javacheck.annotations.DataSource;
import au.id.zancanaro.javacheck.annotations.Property;
import au.id.zancanaro.javacheck.junit.Properties;
import org.junit.runner.RunWith;

import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;

import static au.id.zancanaro.javacheck.Generators.longInteger;
import static au.id.zancanaro.javacheck.Generators.oneOf;
import static org.junit.Assert.assertEquals;

@RunWith(Properties.class)
public class ListFunctorRulesTest {

    @DataSource
    public static Generator<Function<Long, Long>> integerFunction =
            oneOf(
                    longInteger().map(ListFunctorRulesTest::plusI),
                    longInteger().map(ListFunctorRulesTest::timesI),
                    longInteger().map(ListFunctorRulesTest::constantlyI));

    @Property
    public void mappingCompositionsWithStreams(
            List<Long> list,
            Function<Long, Long> f,
            Function<Long, Long> g) {
        List<Long> left = list.stream()
                .map(g)
                .map(f)
                .collect(Collectors.toList());

        List<Long> right = list.stream()
                .map(f.compose(g))
                .collect(Collectors.toList());

        assertEquals(left, right);
    }

    @Property
    public void mappingCompositionsWithIntermediateList(
            List<Long> list,
            Function<Long, Long> f,
            Function<Long, Long> g) {
        List<Long> intermediate = list.stream().map(g).collect(Collectors.toList());
        List<Long> left = intermediate.stream().map(f).collect(Collectors.toList());

        List<Long> right = list.stream()
                .map(f.compose(g))
                .collect(Collectors.toList());

        assertEquals(left, right);
    }

    @Property
    public void mapIdentityIsIdentity(List<Long> list) {
        List<Long> mapped = list.stream().map(x -> x).collect(Collectors.toList());

        assertEquals(list, mapped);
    }

    private static Function<Long, Long> plusI(final long i) {
        return new Function<Long, Long>() {
            @Override
            public Long apply(Long integer) {
                return i + integer;
            }

            @Override
            public String toString() {
                return "x -> x + " + i;
            }
        };
    }

    private static Function<Long, Long> timesI(final long i) {
        return new Function<Long, Long>() {
            @Override
            public Long apply(Long integer) {
                return i * integer;
            }

            @Override
            public String toString() {
                return "x -> x * " + i;
            }
        };
    }

    private static Function<Long, Long> constantlyI(final long i) {
        return new Function<Long, Long>() {
            @Override
            public Long apply(Long integer) {
                return i;
            }

            @Override
            public String toString() {
                return "x -> " + i;
            }
        };
    }
}