/*
 * Copyright 2016 Google Inc.
 *
 * 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.gwt.emultest.java8.util.stream;

import com.google.gwt.emultest.java.util.EmulTestBase;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.Iterator;
import java.util.List;
import java.util.OptionalInt;
import java.util.Spliterator;
import java.util.function.IntSupplier;
import java.util.function.Supplier;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
import java.util.stream.Stream;

/**
 * Tests {@link IntStream}.
 */
public class IntStreamTest extends EmulTestBase {

  public void testEmptyStream() {
    IntStream empty = IntStream.empty();
    assertEquals(0, empty.count());
    try {
      empty.count();
      fail("second terminal operation should have thrown IllegalStateEx");
    } catch (IllegalStateException expected) {
      // expected
    }

    assertEquals(0, IntStream.empty().limit(2).toArray().length);
    assertEquals(0L, IntStream.empty().count());
    assertEquals(0L, IntStream.empty().limit(2).count());

    assertFalse(IntStream.empty().findFirst().isPresent());
    assertFalse(IntStream.empty().findAny().isPresent());
    assertFalse(IntStream.empty().max().isPresent());
    assertFalse(IntStream.empty().min().isPresent());
    assertTrue(IntStream.empty().noneMatch(item -> true));
    assertTrue(IntStream.empty().allMatch(item -> true));
    assertFalse(IntStream.empty().anyMatch(item -> true));
    assertEquals(new int[0], IntStream.empty().toArray());
  }

  public void testStreamOfOne() {
    Supplier<IntStream> one = () -> IntStream.of(1);
    assertEquals(new int[] {1}, one.get().toArray());
    assertEquals(1L, one.get().count());
    assertEquals(1, one.get().findFirst().getAsInt());
    assertEquals(1, one.get().findAny().getAsInt());
  }

  public void testBuilder() {
    IntStream s = IntStream.builder().add(1).add(3).add(2).build();

    assertEquals(new int[] {1, 3, 2}, s.toArray());

    IntStream.Builder builder = IntStream.builder();
    IntStream built = builder.build();
    assertEquals(0, built.count());
    try {
      builder.build();
      fail("build() after build() should fail");
    } catch (IllegalStateException expected) {
      // expected
    }
    try {
      builder.add(10);
      fail("add() after build() should fail");
    } catch (IllegalStateException expected) {
      // expected
    }
  }

  public void testConcat() {
    Supplier<IntStream> adbc = () -> IntStream.concat(IntStream.of(1, 4), IntStream.of(2, 3));

    assertEquals(new int[] {1, 4, 2, 3}, adbc.get().toArray());
    assertEquals(new int[] {1, 2, 3, 4}, adbc.get().sorted().toArray());

    List<String> closed = new ArrayList<>();
    IntStream first = IntStream.of(1).onClose(() -> closed.add("first"));
    IntStream second = IntStream.of(2).onClose(() -> closed.add("second"));

    IntStream concat = IntStream.concat(first, second);

    // read everything, make sure we saw it all and didn't close automatically
    int collectedAll = concat.sum();
    assertEquals(3, collectedAll);
    assertEquals(0, closed.size());

    concat.close();
    assertEquals(Arrays.asList("first", "second"), closed);
  }

  public void testIterate() {
    assertEquals(
        new int[] {10, 11, 12, 13, 14},
        IntStream.iterate(0, i -> i + 1).skip(10).limit(5).toArray());
  }

  public void testGenerate() {
    // infinite, but if you limit it is already too short to skip much
    assertEquals(new int[0], IntStream.generate(makeGenerator()).limit(4).skip(5).toArray());

    assertEquals(
        new int[] {10, 11, 12, 13, 14},
        IntStream.generate(makeGenerator()).skip(10).limit(5).toArray());
  }

  private IntSupplier makeGenerator() {
    return new IntSupplier() {
      int next = 0;

      @Override
      public int getAsInt() {
        return next++;
      }
    };
  }

  public void testRange() {
    assertEquals(new int[] {1, 2, 3, 4}, IntStream.range(1, 5).toArray());
    assertEquals(new int[] {-1, 0, 1, 2, 3, 4}, IntStream.range(-1, 5).toArray());
    assertEquals(new int[] {}, IntStream.range(1, -5).toArray());
    assertEquals(new int[] {}, IntStream.range(-1, -5).toArray());
  }

  public void testRangeClosed() {
    assertEquals(new int[] {1, 2, 3, 4, 5}, IntStream.rangeClosed(1, 5).toArray());
    assertEquals(new int[] {-1, 0, 1, 2, 3, 4, 5}, IntStream.rangeClosed(-1, 5).toArray());
    assertEquals(new int[] {}, IntStream.rangeClosed(1, -5).toArray());
    assertEquals(new int[] {}, IntStream.rangeClosed(-1, -5).toArray());
  }

  public void testToArray() {
    assertEquals(new int[0], IntStream.of().toArray());
    assertEquals(new int[] {1}, IntStream.of(1).toArray());
    assertEquals(new int[] {3, 2, 0}, IntStream.of(3, 2, 0).toArray());
  }

  public void testReduce() {
    int reduced = IntStream.of(1, 2, 4).reduce(0, Integer::sum);
    assertEquals(7, reduced);

    reduced = IntStream.of().reduce(0, Integer::sum);
    assertEquals(0, reduced);

    OptionalInt maybe = IntStream.of(1, 4, 8).reduce(Integer::sum);
    assertTrue(maybe.isPresent());
    assertEquals(13, maybe.getAsInt());
    maybe = IntStream.of().reduce(Integer::sum);
    assertFalse(maybe.isPresent());
  }

  public void testFilter() {
    // unconsumed stream never runs filter
    boolean[] data = {false};
    IntStream.of(1, 2, 3).filter(i -> data[0] |= true);
    assertFalse(data[0]);

    // Nothing's *defined* to care about the Spliterator characteristics, but the implementation
    // can't actually know the size before executing, so we check the characteristics explicitly.
    assertFalse(
        IntStream.of(1, 2, 3)
            .filter(a -> a == 1)
            .spliterator()
            .hasCharacteristics(Spliterator.SIZED | Spliterator.SUBSIZED));

    // one result
    assertEquals(new int[] {1}, IntStream.of(1, 2, 3, 4, 3).filter(a -> a == 1).toArray());
    // zero results
    assertEquals(new int[0], IntStream.of(1, 2, 3, 4, 3).filter(a -> false).toArray());
    // two results
    assertEquals(new int[] {2, 4}, IntStream.of(1, 2, 3, 4, 3).filter(a -> a % 2 == 0).toArray());
    // all
    assertEquals(
        new int[] {1, 2, 3, 4, 3}, IntStream.of(1, 2, 3, 4, 3).filter(a -> true).toArray());
  }

  public void testMap() {
    // unconsumed stream never runs map
    int[] data = {0};
    IntStream.of(1, 2, 3).map(i -> data[0]++);
    assertEquals(0, data[0]);

    assertEquals(new int[] {2, 4, 6}, IntStream.of(1, 2, 3).map(i -> i * 2).toArray());
  }

  public void testPeek() {
    // unconsumed stream never peeks
    boolean[] data = {false};
    IntStream.of(1, 2, 3).peek(i -> data[0] |= true);
    assertFalse(data[0]);

    // make sure we saw it all in order
    int[] items = new int[] {1, 2, 3};
    List<Integer> peeked = new ArrayList<>();
    IntStream.of(items)
        .peek(peeked::add)
        .forEach(
            item -> {
              // do nothing, just run
            });
    assertEquals(items.length, peeked.size());
    for (int i = 0; i < items.length; i++) {
      assertEquals(items[i], (int) peeked.get(i));
    }
  }

  // same impl, no parallel in browser
  public void testFindFirstOrAny() {
    OptionalInt any = IntStream.of(1, 2).findAny();
    assertTrue(any.isPresent());
    assertEquals(1, any.getAsInt());
  }

  public void testAnyMatch() {
    // all
    assertTrue(IntStream.of(1, 2).anyMatch(s -> true));

    // some
    assertTrue(IntStream.of(1, 2).anyMatch(s -> s == 1));

    // none
    assertFalse(IntStream.of(1, 2).anyMatch(s -> false));
  }

  public void testAllMatch() {
    // all
    assertTrue(IntStream.of(1, 2).allMatch(s -> true));

    // some
    assertFalse(IntStream.of(1, 2).allMatch(s -> s == 1));

    // none
    assertFalse(IntStream.of(1, 2).allMatch(s -> false));
  }

  public void testNoneMatch() {
    // all
    assertFalse(IntStream.of(1, 2).noneMatch(s -> true));

    // some
    assertFalse(IntStream.of(1, 2).noneMatch(s -> s == 1));

    // none
    assertTrue(IntStream.of(1, 2).noneMatch(s -> false));
  }

  public void testFlatMap() {
    assertEquals(0, IntStream.empty().flatMap(value -> IntStream.of(1)).count());
    assertEquals(0, IntStream.of(1).flatMap(value -> IntStream.empty()).count());
    assertEquals(0, IntStream.of(1).flatMap(value -> IntStream.of()).count());
    assertEquals(0, IntStream.of().flatMap(value -> IntStream.of(1)).count());
    assertEquals(1, IntStream.of(1).flatMap(value -> IntStream.of(1)).count());

    IntStream values = IntStream.of(1, 2, 3);

    assertEquals(
        new int[] {1, 2, 2, 4, 3, 6}, values.flatMap(i -> IntStream.of(i, i * 2)).toArray());
  }

  public void testMapToOthers() {
    Supplier<IntStream> s = () -> IntStream.of(1, 2, 10);

    assertEquals(
        new String[] {"1", "2", "10"}, s.get().mapToObj(String::valueOf).toArray(String[]::new));

    assertEquals(new long[] {1, 2, 10}, s.get().mapToLong(i -> (long) i).toArray());

    assertEquals(new double[] {1, 2, 10}, s.get().mapToDouble(i -> (double) i).toArray());
  }

  public void testDistinct() {
    int[] distinct = IntStream.of(1, 2, 3, 2).distinct().toArray();
    assertEquals(3, distinct.length);
    assertEquals(1 + 2 + 3, distinct[0] + distinct[1] + distinct[2]);
  }

  public void testSorted() {
    int[] sorted = IntStream.of(3, 1, 2).sorted().toArray();
    assertEquals(new int[] {1, 2, 3}, sorted);
  }

  public void testMinMax() {
    Supplier<IntStream> stream = () -> IntStream.of(2, 3, 4, 1);

    assertEquals(1, stream.get().min().orElse(0));
    assertEquals(4, stream.get().max().orElse(0));

    assertFalse(stream.get().filter(a -> false).max().isPresent());
    assertFalse(stream.get().filter(a -> false).min().isPresent());
  }

  public void testCountLimitSkip() {
    Supplier<IntStream> stream = () -> IntStream.of(1, 2, 3, 4);

    assertEquals(4, stream.get().count());

    assertEquals(4, stream.get().limit(4).count());
    assertEquals(4, stream.get().limit(5).count());
    assertEquals(3, stream.get().limit(3).count());

    assertEquals(3, stream.get().skip(1).limit(3).count());

    assertEquals(2, stream.get().limit(3).skip(1).count());

    assertEquals(1, stream.get().skip(3).count());

    assertEquals(new int[] {3, 4}, stream.get().skip(2).limit(3).toArray());
    assertEquals(new int[] {3}, stream.get().skip(2).limit(1).toArray());

    assertEquals(new int[] {4}, stream.get().skip(3).toArray());
    assertEquals(new int[] {}, stream.get().skip(5).toArray());

    assertEquals(new int[] {1, 2}, stream.get().limit(2).toArray());

    assertEquals(new int[] {2}, stream.get().limit(2).skip(1).toArray());
  }

  public void testBoxed() {
    Supplier<IntStream> stream = () -> IntStream.of(1, 2);
    Stream<Integer> expected = stream.get().mapToObj(Integer::valueOf);
    assertEquals(expected.toArray(), stream.get().boxed().toArray());
  }

  public void testAsOtherPrimitive() {
    Supplier<IntStream> stream = () -> IntStream.of(1, 2);

    DoubleStream actualDoubleStream = stream.get().asDoubleStream();
    assertEquals(new double[] {1, 2}, actualDoubleStream.toArray());

    LongStream actualLongStream = stream.get().asLongStream();
    assertEquals(new long[] {1, 2}, actualLongStream.toArray());
  }

  public void testSummaryStats() {
    Supplier<IntStream> stream = () -> IntStream.of(1, 2, 3);
    IntSummaryStatistics summaryStats = stream.get().summaryStatistics();
    assertEquals(3, summaryStats.getCount());
    assertEquals(1, summaryStats.getMin());
    assertEquals(2, summaryStats.getAverage(), 0d);
    assertEquals(3, summaryStats.getMax());
    assertEquals(6, summaryStats.getSum());

    summaryStats.accept(6);
    assertEquals(4, summaryStats.getCount());
    assertEquals(1, summaryStats.getMin());
    assertEquals(3, summaryStats.getAverage(), 0d);
    assertEquals(6, summaryStats.getMax());
    assertEquals(12, summaryStats.getSum());

    IntSummaryStatistics combinedSumStats = stream.get().summaryStatistics();
    combinedSumStats.combine(IntStream.of(4, 5, 6, 0).summaryStatistics());
    assertEquals(7, combinedSumStats.getCount());
    assertEquals(0, combinedSumStats.getMin());
    assertEquals(3, combinedSumStats.getAverage(), 0d);
    assertEquals(6, combinedSumStats.getMax());
    assertEquals(21, combinedSumStats.getSum());
  }

  public void testAverage() {
    assertFalse(IntStream.empty().average().isPresent());
    assertEquals(2.0d, IntStream.of(1, 2, 3).average().getAsDouble(), 0d);
    assertEquals(0d, IntStream.of(1, 2, -3).average().getAsDouble(), 0d);
    assertEquals(-2.0d, IntStream.of(-1, -2, -3).average().getAsDouble(), 0d);
  }

  public void testSum() {
    assertEquals(6, IntStream.of(1, 2, 3).sum());
    assertEquals(0, IntStream.of(1, 2, -3).sum());
    assertEquals(-6, IntStream.of(-1, -2, -3).sum());
  }

  public void testCollect() {
    String val =
        IntStream.of(1, 2, 3, 4, 5)
            .collect(
                StringBuilder::new,
                // TODO switch to a lambda reference once #9340 is fixed
                (stringBuilder, i) -> stringBuilder.append(i),
                StringBuilder::append)
            .toString();

    assertEquals("12345", val);
  }

  public void testForEach() {
    List<Integer> vals = new ArrayList<>();
    IntStream.of(1, 2, 3, 4, 5).forEach(vals::add);
    assertEquals(5, vals.size());
    assertEquals(new Integer[] {1, 2, 3, 4, 5}, vals.toArray(new Integer[vals.size()]));
  }

  public void testIterator() {
    List<Integer> vals = new ArrayList<>();
    Iterator<Integer> iterator = IntStream.of(1, 2, 3, 4, 5).iterator();
    while (iterator.hasNext()) {
      vals.add(iterator.next());
    }
    assertEquals(5, vals.size());
    assertEquals(new Integer[] {1, 2, 3, 4, 5}, vals.toArray(new Integer[vals.size()]));
  }

  public void testSpliterator() {
    Spliterator<Integer> spliterator = IntStream.of(1, 2, 3, 4, 5).spliterator();
    assertEquals(5, spliterator.estimateSize());
    assertEquals(5, spliterator.getExactSizeIfKnown());

    List<Integer> vals = new ArrayList<>();
    while (spliterator.tryAdvance(vals::add)) {
      // work is all done in the condition
    }

    assertEquals(5, vals.size());
    assertEquals(new Integer[] {1, 2, 3, 4, 5}, vals.toArray(new Integer[vals.size()]));
  }
}