package jdk.test;

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Param;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.Warmup;

import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.TreeMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentSkipListMap;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;

@State(Scope.Thread)
@Fork(1)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 7)
@Measurement(iterations = 10)
public class UnmodifiableMapCopyOfBench {

    private Map<Integer, Integer> map;

    @Param({"HashMap", "IdentityHashMap", "TreeMap", "ConcurrentHashMap", "ConcurrentSkipListMap"})
    public String source;

    @Param({"10", "100", "1000"})
    public int size;

    @SuppressWarnings("deprecation")
    @Setup
    public void setup() {

        Supplier<Map<Integer, Integer>> factory = () -> {
            switch (source) {
                case "HashMap":
                    return new HashMap<>();
                case "IdentityHashMap":
                    return new IdentityHashMap<>();
                case "TreeMap":
                    return new TreeMap<>();
                case "ConcurrentHashMap":
                    return new ConcurrentHashMap<>();
                case "ConcurrentSkipListMap":
                    return new ConcurrentSkipListMap<>();
            }
            throw new AssertionError();
        };

        map = ThreadLocalRandom
            .current()
            .ints(size * 2)
            .mapToObj(Integer::new)
            .collect(Collectors.toCollection(LinkedHashSet::new))
            .stream()
            .limit(size)
            .collect(
                Collectors.toMap(
                    Function.identity(),
                    Function.identity(),
                    (i1, i2) -> i2,
                    factory
                )
            );
    }

    @Benchmark
    public Map<Integer, Integer> copyOf() {
        return Map.copyOf(map);
    }
}