import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.infra.Blackhole;

import java.io.Serializable;
import java.util.Random;
import java.util.concurrent.TimeUnit;

@State(Scope.Benchmark)
public class MyBenchmark {


    private Random randomForX = new Random();
    private Random randomForLambda = new Random(1000);
    private Random randomForClazz = new Random(1000);
    private Random randomForPredictableClazz = new Random(1000);
    private Runnable anonymousRunnable;
    private Runnable randomAnonymousRunnable;
    private Runnable predictableAnonymousRunnable;
    private Runnable declaredRunnable;
    private Runnable randomDeclaredRunnable;
    private Runnable predictableDeclaredRunnable;

    class DeclaredClazz implements Runnable, Serializable {

        private final Blackhole bh;
        private final double stuffToConsume;

        public DeclaredClazz(Blackhole bh, double stuffToConsume) {
            this.bh = bh;
            this.stuffToConsume = stuffToConsume;
        }

        @Override
        public void run() {
            bh.consume(stuffToConsume);
        }
    }

    class DeclaredClazz1 implements Runnable, Serializable {

        private final Blackhole bh;
        private final double stuffToConsume;

        public DeclaredClazz1(Blackhole bh, double stuffToConsume) {
            this.bh = bh;
            this.stuffToConsume = stuffToConsume;
        }

        @Override
        public void run() {
            bh.consume(stuffToConsume);
            Blackhole.consumeCPU(1000);
        }
    }

    class DeclaredClazz2 implements Runnable, Serializable {

        private final Blackhole bh;
        private final double stuffToConsume;

        public DeclaredClazz2(Blackhole bh, double stuffToConsume) {
            this.bh = bh;
            this.stuffToConsume = stuffToConsume;
        }

        @Override
        public void run() {
            bh.consume(stuffToConsume);
            Blackhole.consumeCPU(2000);
        }
    }

    class DeclaredClazz3 implements Runnable, Serializable {

        private final Blackhole bh;
        private final double stuffToConsume;

        public DeclaredClazz3(Blackhole bh, double stuffToConsume) {
            this.bh = bh;
            this.stuffToConsume = stuffToConsume;
        }

        @Override
        public void run() {
            bh.consume(stuffToConsume);
            Blackhole.consumeCPU(3000);
        }
    }


    @Setup(Level.Invocation)
    public void setupAnonymousRunnable(Blackhole bh) {
        double x = randomForX.nextDouble() + randomForX.nextDouble();
        anonymousRunnable = ((Runnable & Serializable) () -> bh.consume(x));
    }

    @Benchmark
    @BenchmarkMode(Mode.SampleTime)
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    public void testAnonymousLambda(Blackhole bh) {
        anonymousRunnable.run();
    }

    @Setup(Level.Invocation)
    public void setupRandomAnonymousRunnable(Blackhole bh) {
        double x = randomForX.nextDouble() + randomForX.nextDouble();
        switch (randomForLambda.nextInt(11)) {
            case 0: case 1: case 2: { randomAnonymousRunnable = ((Runnable & Serializable) () -> bh.consume(x)); break; }
            case 3: case 4: case 5: { randomAnonymousRunnable = ((Runnable & Serializable) () -> {bh.consume(x);Blackhole.consumeCPU(1000);}); break; }
            case 6: case 7: case 8: { randomAnonymousRunnable = ((Runnable & Serializable) () -> {bh.consume(x);Blackhole.consumeCPU(2000);}); break; }
            default: { randomAnonymousRunnable = ((Runnable & Serializable) () -> {bh.consume(x);Blackhole.consumeCPU(3000);}); break; }
        }
    }

    @Benchmark
    @BenchmarkMode(Mode.SampleTime)
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    public void testRandomAnonymousLambda(Blackhole bh) {
        randomAnonymousRunnable.run();
    }

    @Setup(Level.Invocation)
    public void setupPredictableAnonymousRunnable(Blackhole bh) {
        double x = randomForX.nextDouble() + randomForX.nextDouble();
        switch (randomForLambda.nextInt(11)) {
            case 0: { predictableAnonymousRunnable = ((Runnable & Serializable) () -> bh.consume(x)); break; }
            case 1: { predictableAnonymousRunnable = ((Runnable & Serializable) () -> {bh.consume(x);Blackhole.consumeCPU(1000);}); break; }
            case 2: { predictableAnonymousRunnable = ((Runnable & Serializable) () -> {bh.consume(x);Blackhole.consumeCPU(2000);}); break; }
            default: { predictableAnonymousRunnable = ((Runnable & Serializable) () -> {bh.consume(x);Blackhole.consumeCPU(3000);}); break; }
        }
    }

    @Benchmark
    @BenchmarkMode(Mode.SampleTime)
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    public void testPredictableAnonymousLambda(Blackhole bh) {
        predictableAnonymousRunnable.run();
    }

    @Setup(Level.Invocation)
    public void setupDeclaredClass(Blackhole bh) {
        double x = randomForX.nextDouble() + randomForX.nextDouble();
        declaredRunnable = new DeclaredClazz(bh, x);
    }

    @Benchmark
    @BenchmarkMode(Mode.SampleTime)
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    public void testDeclared(Blackhole bh) {
        declaredRunnable.run();
    }

    @Setup(Level.Invocation)
    public void setupRandomClass(Blackhole bh) {
        double x = randomForX.nextDouble() + randomForX.nextDouble();
        switch (randomForClazz.nextInt(11)) {
            case 0: case 1: case 2: { randomDeclaredRunnable = new DeclaredClazz(bh, x); break; }
            case 3: case 4: case 5: { randomDeclaredRunnable = new DeclaredClazz1(bh, x); break; }
            case 6: case 7: case 8: { randomDeclaredRunnable = new DeclaredClazz2(bh, x); break; }
            default: { randomDeclaredRunnable = new DeclaredClazz3(bh, x); break; }
        }
    }

    @Benchmark
    @BenchmarkMode(Mode.SampleTime)
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    public void testRandomBranchingDeclared(Blackhole bh) {
        randomDeclaredRunnable.run();
    }

    @Setup(Level.Invocation)
    public void setupPredictableClazz(Blackhole bh) {
        double x = randomForX.nextDouble() + randomForX.nextDouble();
        switch (randomForPredictableClazz.nextInt(11)) {
            case 0: { predictableDeclaredRunnable = new DeclaredClazz(bh, x); break; }
            case 1: { predictableDeclaredRunnable = new DeclaredClazz1(bh, x); break; }
            case 2: { predictableDeclaredRunnable = new DeclaredClazz2(bh, x); break; }
            default: { predictableDeclaredRunnable = new DeclaredClazz3(bh, x); break; }
        }
    }

    @Benchmark
    @BenchmarkMode(Mode.SampleTime)
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    public void testPredictableBranchingDeclared(Blackhole bh) {
        predictableDeclaredRunnable.run();
    }
}