/*****************************************************************************
 * Copyright (c) 2020 Dirk Fauth.
 *
 * This program and the accompanying materials are made
 * available under the terms of the Eclipse Public License 2.0
 * which is available at https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *      Dirk Fauth <dirk.fauth@googlemail.com> - Initial API and implementation
 *
 *****************************************************************************/
package org.eclipse.nebula.widgets.nattable.test.performance;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

import org.eclipse.collections.api.factory.Maps;
import org.eclipse.collections.api.list.primitive.MutableIntList;
import org.eclipse.collections.api.map.MutableMap;
import org.eclipse.collections.api.map.primitive.MutableIntIntMap;
import org.eclipse.collections.api.set.primitive.MutableIntSet;
import org.eclipse.collections.api.tuple.primitive.IntIntPair;
import org.eclipse.collections.impl.factory.primitive.IntIntMaps;
import org.eclipse.collections.impl.factory.primitive.IntLists;
import org.eclipse.collections.impl.factory.primitive.IntSets;
import org.eclipse.nebula.widgets.nattable.util.ArrayUtil;

public class CollectionsBenchmark {

    public static final int ITERATIONS = 100;

    MutableMap<String, MutableIntSet> hidden = Maps.mutable.empty();
    MutableIntIntMap map = IntIntMaps.mutable.empty();

    public static void main(String[] args) {

        CollectionsBenchmark benchmark = new CollectionsBenchmark();
        benchmark.startBenchmark();
    }

    CollectionsBenchmark() {
        this.hidden.put("Test1", IntSets.mutable.ofAll(IntStream.range(0, 100_000))); //$NON-NLS-1$
        this.hidden.put("Test2", IntSets.mutable.ofAll(IntStream.range(100_001, 200_000))); //$NON-NLS-1$
        this.hidden.put("Test3", IntSets.mutable.ofAll(IntStream.range(200_000, 300_000))); //$NON-NLS-1$
        this.hidden.put("Test4", IntSets.mutable.ofAll(IntStream.range(300_000, 400_000))); //$NON-NLS-1$
        this.hidden.put("Test5", IntSets.mutable.ofAll(IntStream.range(400_000, 500_000))); //$NON-NLS-1$

        for (int i = 0; i < 1_000_000; i++) {
            this.map.put(i, i * 2);
        }
    }

    public void startBenchmark() {
        // rampUp to remove class loading from performance measure
        findByContains(this.hidden, 1, true);
        findByCollections(this.hidden, 1, true);
        flattenByIterationSet(this.hidden, true);
        flattenByIterationList(this.hidden, true);
        sumAndMaxByIteration(this.map, true);

        int[] valuesArray = createPrimitiveValuesArrayForEach();
        int[] valuesFromIntStream = createPrimitiveValuesArrayIntStream();

        if (!Arrays.equals(valuesArray, valuesFromIntStream)) {
            System.err.println("Primitive input not equal");
        }

        List<Integer> valuesList = createWrapperValuesForEach();
        List<Integer> wrapperFromStream = createWrapperValuesIntStream();

        if (!valuesList.equals(wrapperFromStream)) {
            System.err.println("Wrapper input not equal");
        }

        Set<Integer> valueHashSetWrapper = createWrapperValueHashSetForEach();
        Set<Integer> valueTreeSetWrapper = createWrapperValueTreeSetForEach();
        Set<Integer> wrapperHashSetFromStream = createWrapperValueHashSetIntStream();

        if (!valueHashSetWrapper.equals(wrapperHashSetFromStream) || !valueHashSetWrapper.equals(valueTreeSetWrapper)) {
            System.err.println("Wrapper input not equal");
        }

        System.out.println();

        createEclipseCollectionsListIteration();
        createEclipseCollectionsListOf(valuesArray);
        createEclipseCollectionsListIntegerCollection(valuesList);
        createEclipseCollectionsListIntStream();

        System.out.println();

        createEclipseCollectionsSetIteration();
        createEclipseCollectionsSetOf(valuesArray);
        createEclipseCollectionsSetIntegerCollection(valuesList);
        createEclipseCollectionsSetIntStream();

        System.out.println();
        System.out.println("Check value is contained");
        boolean c1 = containsInList(valuesList, 450_000, false);

        HashSet<Integer> valueSet = new HashSet<>(valuesList);
        boolean c2 = containsInSet(valueSet, 450_000, false);

        boolean c3 = containsInPrimitive(valuesArray, 450_000, false);
        boolean c4 = containsInPrimitiveIteration(valuesArray, 450_000, false);
        boolean c5 = containsInArrayBinarySearch(valuesArray, 450_000, false);

        MutableIntList valuesIntList = IntLists.mutable.of(Arrays.copyOf(valuesArray, valuesArray.length));
        boolean c6 = containsInMutableIntList(valuesIntList, 450_000, false);

        MutableIntSet valuesIntSet = IntSets.mutable.of(Arrays.copyOf(valuesArray, valuesArray.length));
        boolean c7 = containsInMutableIntSet(valuesIntSet, 450_000, false);

        if (!c1 || !c2 || !c3 || !c4 || !c5 || !c6 || !c7) {
            System.err.println("value not contained");
        }

        System.out.println();
        System.out.println("Check value is not contained");
        c1 = containsInList(valuesList, 2_000_000, false);
        c2 = containsInSet(valueSet, 2_000_000, false);
        c3 = containsInPrimitive(valuesArray, 2_000_000, false);
        c4 = containsInPrimitiveIteration(valuesArray, 2_000_000, false);
        c5 = containsInArrayBinarySearch(valuesArray, 2_000_000, false);
        c6 = containsInMutableIntList(valuesIntList, 2_000_000, false);
        c7 = containsInMutableIntSet(valuesIntSet, 2_000_000, false);

        if (c1 || c2 || c3 || c4 || c5 || c6 || c7) {
            System.err.println("value contained");
        }

        System.out.println();
        System.out.println("Check indexOf() 450_000");
        int i1 = indexOfInCollection(valuesList, 450_000, false);
        int i2 = indexOfInPrimitiveIteration(valuesArray, 450_000, false);
        int i3 = indexOfInMutableIntList(valuesIntList, 450_000, false);

        if ((i1 != i2) || (i2 != i3) || (i3 != 449_996)) {
            System.err.println("indexOf failed");
        }

        System.out.println();
        System.out.println("Check indexOf() 2_000_000");
        i1 = indexOfInCollection(valuesList, 2_000_000, false);
        i2 = indexOfInPrimitiveIteration(valuesArray, 2_000_000, false);
        i3 = indexOfInMutableIntList(valuesIntList, 2_000_000, false);

        if ((i1 != i2) || (i2 != i3) || (i3 != -1)) {
            System.err.println("indexOf failed");
        }

        System.out.println();
        System.out.println("Remove Performance Tests"); //$NON-NLS-1$

        int[] toRemove = new int[100_000];
        for (int i = 0; i < 100_000; i++) {
            toRemove[i] = i + 200_000;
        }

        // This one is really slow, so we disable it here
        int[] dataArray = IntStream.range(0, 1_000_000).unordered().toArray();
        // List<Integer> dataList = IntStream.range(0,
        // 1_000_000).unordered().boxed().collect(Collectors.toList());
        Set<Integer> dataSet = IntStream.range(0, 1_000_000).unordered().boxed().collect(Collectors.toSet());
        MutableIntList dataIntList = IntLists.mutable.ofAll(IntStream.range(0, 1_000_000).unordered());
        MutableIntSet dataIntSet = IntSets.mutable.ofAll(IntStream.range(0, 1_000_000).unordered());

        removeAllByStream(dataArray, toRemove, false);
        // removeAllByIterationList(dataList, toRemove, false);
        // removeAllList(dataList, toRemove, false);
        removeAllByIterationSet(dataSet, toRemove, false);
        removeAllSet(dataSet, toRemove, false);

        // This one is really slow, so we disable it here
        // removeAllByIterationMutableIntList(dataIntList, toRemove, false);
        removeAllMutableIntList(dataIntList, toRemove, false);

        removeAllByIterationMutableIntSet(dataIntSet, toRemove, false);
        removeAllMutableIntSet(dataIntSet, toRemove, false);

        System.out.println();
        boolean findByContains = findByContains(this.hidden, 100_000, false);
        boolean findByCollections = findByCollections(this.hidden, 100_000, false);

        if (findByContains || findByCollections) {
            System.err.println("non-existing value was found");
        }

        findByContains = findByContains(this.hidden, 450_000, false);
        findByCollections = findByCollections(this.hidden, 450_000, false);

        if (!findByContains || !findByCollections) {
            System.err.println("value was not found");
        }

        System.out.println();
        flattenByIterationSet(this.hidden, false);
        flattenByIterationList(this.hidden, false);

        System.out.println();
        System.out.println("Sum and max Performance Tests"); //$NON-NLS-1$
        int[] result1 = sumAndMaxByIteration(this.map, false);
        int[] result2 = sumAndMax(this.map, false);

        if (!Arrays.equals(result1, result2)) {
            System.out.println("result is not equal");
        }
    }

    private int[] createPrimitiveValuesArrayForEach() {
        int sum = 0;
        int[] values = null;
        for (int j = 0; j < ITERATIONS; j++) {
            long start = System.currentTimeMillis();
            values = new int[999_991];
            int index = 0;
            for (int i = 0; i < 1_000_000; i++) {
                if (i == 0 || i % 100_000 != 0) {
                    values[index] = i;
                    index++;
                }
            }
            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        System.out.println("collecting int[] via for-loop\t\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$

        return values;
    }

    private int[] createPrimitiveValuesArrayIntStream() {
        int sum = 0;
        int[] values = null;
        for (int j = 0; j < ITERATIONS; j++) {
            long start = System.currentTimeMillis();
            values = IntStream.range(0, 1_000_000)
                    .filter(i -> i == 0 || i % 100_000 != 0)
                    .toArray();
            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        System.out.println("collecting int[] via IntStream\t\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$

        return values;
    }

    private List<Integer> createWrapperValuesForEach() {
        int sum = 0;
        ArrayList<Integer> values = null;
        for (int j = 0; j < ITERATIONS; j++) {
            long start = System.currentTimeMillis();
            values = new ArrayList<>(999_991);
            for (int i = 0; i < 1_000_000; i++) {
                if (i == 0 || i % 100_000 != 0) {
                    values.add(i);
                }
            }
            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        System.out.println("collecting List<Integer> via for-loop\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$

        return values;
    }

    private List<Integer> createWrapperValuesIntStream() {
        int sum = 0;
        List<Integer> values = null;
        for (int j = 0; j < ITERATIONS; j++) {
            long start = System.currentTimeMillis();

            values = IntStream.range(0, 1_000_000)
                    .filter(i -> (i == 0 || i % 100_000 != 0))
                    .boxed()
                    .collect(Collectors.toList());

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        System.out.println("collecting List<Integer> via IntStream\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$

        return values;
    }

    private Set<Integer> createWrapperValueHashSetForEach() {
        int sum = 0;
        HashSet<Integer> values = null;
        for (int j = 0; j < ITERATIONS; j++) {
            long start = System.currentTimeMillis();
            values = new HashSet<>(999_991);
            for (int i = 0; i < 1_000_000; i++) {
                if (i == 0 || i % 100_000 != 0) {
                    values.add(i);
                }
            }
            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        System.out.println("collecting HashSet<Integer> via for-loop\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$

        return values;
    }

    private Set<Integer> createWrapperValueTreeSetForEach() {
        int sum = 0;
        TreeSet<Integer> values = null;
        for (int j = 0; j < ITERATIONS; j++) {
            long start = System.currentTimeMillis();
            values = new TreeSet<>();
            for (int i = 0; i < 1_000_000; i++) {
                if (i == 0 || i % 100_000 != 0) {
                    values.add(i);
                }
            }
            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        System.out.println("collecting TreeSet<Integer> via for-loop\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$

        return values;
    }

    private Set<Integer> createWrapperValueHashSetIntStream() {
        int sum = 0;
        Set<Integer> values = null;
        for (int j = 0; j < ITERATIONS; j++) {
            long start = System.currentTimeMillis();

            values = IntStream.range(0, 1_000_000)
                    .filter(i -> (i == 0 || i % 100_000 != 0))
                    .boxed()
                    .collect(Collectors.toSet());

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        System.out.println("collecting Set<Integer> via IntStream\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$

        return values;
    }

    private MutableIntList createEclipseCollectionsListIteration() {
        int sum = 0;
        MutableIntList values = null;
        for (int j = 0; j < ITERATIONS; j++) {
            long start = System.currentTimeMillis();
            values = IntLists.mutable.withInitialCapacity(999_991);
            for (int i = 0; i < 1_000_000; i++) {
                if (i == 0 || i % 100_000 != 0) {
                    values.add(i);
                }
            }
            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        System.out.println("creating MutableIntList via iteration\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$

        return values;
    }

    private MutableIntList createEclipseCollectionsListOf(int[] inputArray) {
        int sum = 0;
        MutableIntList values = null;
        for (int j = 0; j < ITERATIONS; j++) {
            long start = System.currentTimeMillis();
            values = IntLists.mutable.of(inputArray);
            // values = IntLists.mutable.of(inputArray).distinct().sortThis();
            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        System.out.println("creating MutableIntList of int[]\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$

        return values;
    }

    private MutableIntList createEclipseCollectionsListIntegerCollection(List<Integer> inputCollection) {
        int sum = 0;
        MutableIntList values = null;
        for (int j = 0; j < ITERATIONS; j++) {
            long start = System.currentTimeMillis();
            values = IntLists.mutable.ofAll(inputCollection);
            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        System.out.println("creating MutableIntList via Integer collection\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$

        return values;
    }

    private MutableIntList createEclipseCollectionsListIntStream() {
        int sum = 0;
        MutableIntList values = null;
        for (int j = 0; j < ITERATIONS; j++) {
            long start = System.currentTimeMillis();
            values = IntLists.mutable.ofAll(IntStream.range(0, 1_000_000).filter(i -> i == 0 || i % 100_000 != 0));
            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        System.out.println("creating MutableIntList via IntStream\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$

        return values;
    }

    private MutableIntSet createEclipseCollectionsSetIteration() {
        int sum = 0;
        MutableIntSet values = null;
        for (int j = 0; j < ITERATIONS; j++) {
            long start = System.currentTimeMillis();
            values = IntSets.mutable.withInitialCapacity(999_991);
            for (int i = 0; i < 1_000_000; i++) {
                if (i == 0 || i % 100_000 != 0) {
                    values.add(i);
                }
            }
            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        System.out.println("creating MutableIntSet via iteration\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$

        return values;
    }

    private MutableIntSet createEclipseCollectionsSetOf(int[] inputArray) {
        int sum = 0;
        MutableIntSet values = null;
        for (int j = 0; j < ITERATIONS; j++) {
            long start = System.currentTimeMillis();
            values = IntSets.mutable.of(inputArray);
            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        System.out.println("creating MutableIntSet of int[]\t\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$

        return values;
    }

    private MutableIntSet createEclipseCollectionsSetIntegerCollection(List<Integer> inputCollection) {
        int sum = 0;
        MutableIntSet values = null;
        for (int j = 0; j < ITERATIONS; j++) {
            long start = System.currentTimeMillis();
            values = IntSets.mutable.ofAll(inputCollection);
            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        System.out.println("creating MutableIntSet of Integer collection\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$

        return values;
    }

    private MutableIntSet createEclipseCollectionsSetIntStream() {
        int sum = 0;
        MutableIntSet values = null;
        for (int j = 0; j < ITERATIONS; j++) {
            long start = System.currentTimeMillis();
            values = IntSets.mutable.ofAll(IntStream.range(0, 1_000_000).filter(i -> (i == 0 || i % 100_000 != 0)));
            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        System.out.println("creating MutableIntSet via IntStream\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$

        return values;
    }

    public static boolean findByContains(MutableMap<String, MutableIntSet> hidden, int columnIndex, boolean rampUp) {
        int sum = 0;
        boolean result = false;
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            long start = System.currentTimeMillis();

            for (MutableIntSet indexes : hidden.values()) {
                if (indexes.contains(columnIndex)) {
                    result = true;
                    break;
                }
            }
            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("find via value iteration\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }

        return result;
    }

    public static boolean findByCollections(MutableMap<String, MutableIntSet> hidden, int columnIndex, boolean rampUp) {
        int sum = 0;
        boolean result = false;
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            long start = System.currentTimeMillis();

            MutableIntSet detect = hidden.detect(indexes -> indexes.contains(columnIndex));
            result = detect != null;
            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("find via detect()\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }

        return result;
    }

    public static boolean containsInList(List<Integer> values, int columnIndex, boolean rampUp) {
        int sum = 0;
        boolean result = false;
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            long start = System.currentTimeMillis();

            result = values.contains(Integer.valueOf(columnIndex));

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("contains in List\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }

        return result;
    }

    public static boolean containsInSet(Set<Integer> values, int columnIndex, boolean rampUp) {
        int sum = 0;
        boolean result = false;
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            long start = System.currentTimeMillis();

            result = values.contains(Integer.valueOf(columnIndex));

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("contains in Set\t\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }

        return result;
    }

    public static boolean containsInPrimitive(int[] values, int columnIndex, boolean rampUp) {
        int sum = 0;
        boolean result = false;
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            long start = System.currentTimeMillis();

            result = Arrays.stream(values).anyMatch(x -> x == columnIndex);

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("contains in int[] stream\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }

        return result;
    }

    public static boolean containsInArrayBinarySearch(int[] values, int columnIndex, boolean rampUp) {
        int sum = 0;
        boolean result = false;
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            long start = System.currentTimeMillis();

            result = Arrays.binarySearch(values, columnIndex) >= 0;

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("contains in int[] binary search\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }

        return result;
    }

    public static boolean containsInPrimitiveIteration(int[] values, int columnIndex, boolean rampUp) {
        int sum = 0;
        boolean result = false;
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            long start = System.currentTimeMillis();

            for (int i : values) {
                if (i == columnIndex) {
                    result = true;
                    break;
                }
            }

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("contains in int[] iteration\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }

        return result;
    }

    public boolean containsInMutableIntList(MutableIntList values, int columnIndex, boolean rampUp) {
        int sum = 0;
        boolean result = false;
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            long start = System.currentTimeMillis();

            result = values.contains(columnIndex);

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("contains in MutableIntList\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }

        return result;
    }

    public boolean containsInMutableIntSet(MutableIntSet values, int columnIndex, boolean rampUp) {
        int sum = 0;
        boolean result = false;
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            long start = System.currentTimeMillis();

            result = values.contains(columnIndex);

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("contains in MutableIntSet\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }

        return result;
    }

    public static int indexOfInCollection(List<Integer> values, int columnIndex, boolean rampUp) {
        int sum = 0;
        int result = -1;
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            long start = System.currentTimeMillis();

            result = values.indexOf(Integer.valueOf(columnIndex));

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("indexOf in collection\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }

        return result;
    }

    public static int indexOfInPrimitiveIteration(int[] values, int columnIndex, boolean rampUp) {
        int sum = 0;
        int result = -1;
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            long start = System.currentTimeMillis();

            for (int index = 0; index < values.length; index++) {
                int i = values[index];
                if (i == columnIndex) {
                    result = index;
                    break;
                }
            }

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("indexOf in int[] iteration\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }

        return result;
    }

    public int indexOfInMutableIntList(MutableIntList values, int columnIndex, boolean rampUp) {
        int sum = 0;
        int result = -1;
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            long start = System.currentTimeMillis();

            result = values.indexOf(columnIndex);

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("indexOf in MutableIntList\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }

        return result;
    }

    public static int[] flattenByIterationSet(MutableMap<String, MutableIntSet> hidden, boolean rampUp) {
        int sum = 0;
        int[] result = null;
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            long start = System.currentTimeMillis();

            MutableIntSet hiddenColumnIndexes = IntSets.mutable.empty();
            for (MutableIntSet indexes : hidden.values()) {
                hiddenColumnIndexes.addAll(indexes);
            }
            result = hiddenColumnIndexes.toSortedArray();

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("flatten by iteration MutableIntSet\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }

        return result;
    }

    public static int[] flattenByIterationList(MutableMap<String, MutableIntSet> hidden, boolean rampUp) {
        int sum = 0;
        int[] result = null;
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            long start = System.currentTimeMillis();

            MutableIntList hiddenColumnIndexes = IntLists.mutable.empty();
            for (MutableIntSet indexes : hidden.values()) {
                hiddenColumnIndexes.addAll(indexes);
            }
            result = hiddenColumnIndexes.distinct().toSortedArray();

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("flatten by iteration MutableIntList\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }

        return result;
    }

    public static void removeAllByStream(int[] values, int[] toRemove, boolean rampUp) {
        int sum = 0;
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            // create a copy so we really remove everytime
            long start = System.currentTimeMillis();

            int[] result = Arrays.stream(values).filter(v -> (Arrays.binarySearch(toRemove, v) < 0)).toArray();

            long end = System.currentTimeMillis();

            sum += (end - start);

            if (result.length != values.length - toRemove.length) {
                System.err.println("remove failed");
            }
        }

        if (!rampUp) {
            System.out.println("remove all by primitive stream\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }
    }

    public static void removeAllByIterationList(List<Integer> values, int[] toRemove, boolean rampUp) {
        int sum = 0;
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            // create a copy so we really remove everytime
            ArrayList<Integer> v = new ArrayList<>(values);

            long start = System.currentTimeMillis();

            for (Integer r : toRemove) {
                v.remove(r);
            }

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("remove all by iteration List\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }
    }

    public static void removeAllList(List<Integer> values, int[] toRemove, boolean rampUp) {
        List<Integer> asIntegerList = ArrayUtil.asIntegerList(toRemove);
        int sum = 0;
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            // create a copy so we really remove everytime
            ArrayList<Integer> v = new ArrayList<>(values);

            long start = System.currentTimeMillis();

            v.removeAll(asIntegerList);

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("remove all List\t\t\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }
    }

    public static void removeAllByIterationSet(Set<Integer> values, int[] toRemove, boolean rampUp) {
        int sum = 0;
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            // create a copy so we really remove everytime
            HashSet<Integer> v = new HashSet<>(values);

            long start = System.currentTimeMillis();

            for (Integer r : toRemove) {
                v.remove(r);
            }

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("remove all by iteration Set\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }
    }

    public static void removeAllSet(Set<Integer> values, int[] toRemove, boolean rampUp) {
        List<Integer> asIntegerList = ArrayUtil.asIntegerList(toRemove);
        int sum = 0;
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            // create a copy so we really remove everytime
            HashSet<Integer> v = new HashSet<>(values);

            long start = System.currentTimeMillis();

            v.removeAll(asIntegerList);

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("remove all Set\t\t\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }
    }

    public static void removeAllByIterationMutableIntList(MutableIntList values, int[] toRemove, boolean rampUp) {
        int sum = 0;
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            // create a copy so we really remove everytime
            MutableIntList v = values.toList();

            long start = System.currentTimeMillis();

            for (int r : toRemove) {
                v.remove(r);
            }

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("remove all by iteration MutableIntList\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }
    }

    public static void removeAllMutableIntList(MutableIntList values, int[] toRemove, boolean rampUp) {
        int sum = 0;
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            // create a copy so we really remove everytime
            MutableIntList v = values.toList();

            long start = System.currentTimeMillis();

            v.removeAll(toRemove);

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("remove all MutableIntList\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }
    }

    public static void removeAllByIterationMutableIntSet(MutableIntSet values, int[] toRemove, boolean rampUp) {
        int sum = 0;
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            // create a copy so we really remove everytime
            MutableIntSet v = values.toSet();

            long start = System.currentTimeMillis();

            for (int r : toRemove) {
                v.remove(r);
            }

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("remove all by iteration MutableIntSet\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }
    }

    public static void removeAllMutableIntSet(MutableIntSet values, int[] toRemove, boolean rampUp) {
        int sum = 0;
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            // create a copy so we really remove everytime
            MutableIntSet v = values.toSet();

            long start = System.currentTimeMillis();

            v.removeAll(toRemove);

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("remove all MutableIntSet\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }
    }

    public static int[] sumAndMaxByIteration(MutableIntIntMap map, boolean rampUp) {
        int sum = 0;
        int[] result = new int[2];
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            long start = System.currentTimeMillis();

            int valueSum = 0;
            int lastPos = -1;
            for (IntIntPair entry : map.keyValuesView().toSortedList()) {
                valueSum += entry.getTwo();
                lastPos = Math.max(lastPos, entry.getOne());
            }

            result[0] = valueSum;
            result[1] = lastPos;

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("sum and max by iteration\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }

        return result;
    }

    public static int[] sumAndMax(MutableIntIntMap map, boolean rampUp) {
        int sum = 0;
        int[] result = new int[2];
        for (int j = 0; j < (rampUp ? 1 : ITERATIONS); j++) {
            long start = System.currentTimeMillis();

            result[0] = (int) map.values().sum();
            result[1] = map.keySet().max();

            long end = System.currentTimeMillis();

            sum += (end - start);
        }

        if (!rampUp) {
            System.out.println("sum and max\t\t\t\t" + (sum / ITERATIONS) + " ms"); //$NON-NLS-1$ //$NON-NLS-2$
        }

        return result;
    }
}