package test;

import java.util.concurrent.TimeUnit;
import java.util.stream.*;
import java.util.*;

import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.annotations.*;
 
@Warmup(iterations = 3, time = 500, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 5, time = 500, timeUnit = TimeUnit.MILLISECONDS)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@Fork(1)
@State(Scope.Benchmark)
public class LimitTest {
    @Param({"false", "true"})
    boolean _par;

    @Param({"1", "3", "5", "10", "100", "1000"})
    private double factor;
  
    @Param({"2", "10", "100", "1000"})
    private int limit;

    @Param({"asc", "desc", "rand", "10asc", "10ad", "ascPairs", "descPairs"})
    String mode;

    Integer[] input;

    @Setup
    public void setup() {
        Random r = new Random(1);
        int n = (int)(factor * limit);
        int[] input;
        if(_par && n < 200)
           throw new IllegalStateException("Skipped state: too small number of elements for parallel sort");
        if(n == 0 || n == 1 && !mode.equals("asc") || n == 2 && !mode.equals("asc") && !mode.equals("desc"))
           throw new IllegalStateException("Skipped state");
        switch(mode) {
        case "asc": input = r.ints(n).sorted().toArray(); break;
        case "desc": input = r.ints(n).sorted().map(x -> ~x).toArray(); break;
        case "rand": input = r.ints(n).toArray(); break;
        case "10asc": input = IntStream.range(0, 10).flatMap(i -> r.ints(n/10+1).sorted()).limit(n).toArray(); break;
        case "10ad": input = IntStream.range(0, 10).flatMap(i -> r.ints(n/10+1).sorted()
                                        .map(r.nextBoolean() ? x -> x : x -> ~x)).limit(n).toArray(); break;
        case "ascPairs": input = r.ints(n).sorted().toArray();
            for(int i=0; i<n-1; i+=2) {int x = input[i]; input[i] = input[i+1]; input[i+1] = x;}
            break;
        case "descPairs": input = r.ints(n).sorted().map(x -> ~x).toArray();
            for(int i=0; i<n-1; i+=2) {int x = input[i]; input[i] = input[i+1]; input[i+1] = x;}
            break;
        default: throw new InternalError(mode);
        }
        if(input.length != n) throw new InternalError(input.length+" != "+n);
        this.input = IntStream.of(input).boxed().toArray(Integer[]::new);
    }

    @Benchmark
    public Optional<Integer> sorted() {
        Stream<Integer> s = Stream.of(input);
        if(_par) s = s.parallel();
        return s.sorted().limit(limit).reduce((a, b) -> b);
    }
}