/*
 * Copyright 2008 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.benchmarks.java.util;

import com.google.gwt.benchmarks.client.Benchmark;
import com.google.gwt.benchmarks.client.IntRange;
import com.google.gwt.benchmarks.client.Operator;
import com.google.gwt.benchmarks.client.RangeEnum;
import com.google.gwt.benchmarks.client.RangeField;
import com.google.gwt.benchmarks.client.Setup;

import java.util.Arrays;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.SortedMap;

/**
 * Benchmarks common operations on {@link SortedMap SortedMaps}. This test covers
 * appends, inserts, and removes for various sizes and positions.
 * 
 */
public abstract class SortedMapBenchmark extends Benchmark {

  /*
   * TODO(rovrevik) Add more tests such as iteration, non-sequential random
   * access, and sublists.
   */

  /**
   * The various positions that data can be inserted into a list.
   */
  protected enum Position {

    BEGIN("at the beginning"), EXPLICIT_END("explicitly at the end"), IMPLICIT_END(
        "implicitly at the end"), VARIED("in varied locations");

    private String label;

    /**
     * Constructor for <code>Position</code>.
     * 
     * @param label a not <code>null</code> label describing this
     *          <code>Position</code>.
     */
    Position(String label) {
      this.label = label;
    }

    /**
     * Returns the textual description for the position.
     * 
     * @return a not <code>null</code> description.
     */
    @Override
    public String toString() {
      return label;
    }
  }

  private static final int PRIME = 3001;

  protected final IntRange baseRange = new IntRange(512, Integer.MAX_VALUE,
      Operator.MULTIPLY, 2);

  protected final List<Position> explicitPositions = Arrays.asList(
      Position.BEGIN, Position.EXPLICIT_END, Position.VARIED);

  protected final IntRange insertRemoveRange = new IntRange(64,
      Integer.MAX_VALUE, Operator.MULTIPLY, 2);

  int index = 0;

  SortedMap<Integer, String> sortedMap;

  @Override
  public String getModuleName() {
    return "com.google.gwt.emultest.EmulSuiteBenchmarks";
  }

  // Required for JUnit
  public void testSortedMapGets() {
  }

  /**
   * Performs <code>size</code> gets on a {@code SortedMap} of size,
   * <code>size</code>.
   * 
   * @param size the size of the {@code SortedMap}
   */
  @Setup("beginSortedMapGets")
  public void testSortedMapGets(@RangeField("baseRange")
  Integer size) {
    int num = size.intValue();
    for (int i = 0; i < num; i++) {
      sortedMap.get(i);
    }
  }

  // Required for JUnit
  public void testSortedMapInserts() {
  }

  /**
   * Performs <code>size</code> inserts at position, <code>where</code>, on
   * an empty <code>SortedMap</code>.
   * 
   * @param where Where the inserts happen
   * @param size The size of the <code>SortedMap</code>
   * 
   */
  @Setup("beginSortedMapInserts")
  public void testSortedMapInserts(@RangeEnum(Position.class)
  Position where, @RangeField("insertRemoveRange")
  Integer size) {
    insertIntoCollection(size, where, sortedMap);
  }

  // Required for JUnit
  public void testSortedMapPuts() {
  }

  /**
   * Appends <code>size</code> items to an empty {@code SortedMap}.
   * 
   * @param size the size of the {@code SortedMap}
   */
  @Setup("beginSortedMapPuts")
  public void testSortedMapPuts(@RangeField("baseRange")
  Integer size) {
    int num = size.intValue();
    for (int i = 0; i < num; i++) {
      sortedMap.put(i, "hello");
    }
  }

  // Required for JUnit
  public void testSortedMapRemoves() {
  }

  /**
   * Performs <code>size</code> removes at position, <code>where</code>, on
   * an TreeMap of size, <code>size</code>.
   * 
   * @param where Where the inserts happen
   * @param size The size of the <code>SortedMap</code>
   */
  @Setup("beginSortedMapRemoves")
  public void testSortedMapRemoves(@RangeField("explicitPositions")
  Position where, @RangeField("insertRemoveRange")
  Integer size) {
    removeFromCollection(size, where, sortedMap);
  }

  /**
   * Creates a new empty SortedMap.
   * 
   * @return a not <code>null</code>, empty SortedMap
   */
  protected abstract SortedMap<Integer, String> newSortedMap();

  void beginSortedMapGets(Integer size) {
    createSortedMap(size);
  }

  void beginSortedMapInserts(Position where, Integer size) {
    sortedMap = newSortedMap();
    index = 0;
  }

  void beginSortedMapPuts(Integer size) {
    sortedMap = newSortedMap();
  }

  void beginSortedMapRemoves(Position where, Integer size) {
    beginSortedMapInserts(where, size);
    testSortedMapInserts(where, size);
  }

  private void createSortedMap(Integer size) {
    beginSortedMapPuts(size);
    testSortedMapPuts(size);
  }

  private void insertIntoCollection(Integer size, Position where,
      SortedMap<Integer, String> m) {
    int num = size.intValue();
    for (int i = 0; i < num; i++) {
      if (where == Position.IMPLICIT_END) {
        Integer key;
        try {
          key = m.lastKey();
        } catch (NoSuchElementException e) {
          key = Integer.valueOf(0);
        }
        m.put((key.intValue() + 1), "hello");
      } else if (where == Position.BEGIN) {
        m.put(0, "hello");
      } else if (where == Position.EXPLICIT_END) {
        m.put(m.size(), "hello");
      } else if (where == Position.VARIED) {
        m.put(index, "hello");
        index += PRIME;
        index %= m.size();
      }
    }
  }

  private int removeFromCollection(Integer size, Position where,
      SortedMap<Integer, String> m) {
    int num = size.intValue();
    for (int i = 0; i < num; i++) {
      if (where == Position.IMPLICIT_END) {
        throw new RuntimeException("cannot remove from the end implicitly");
      } else if (where == Position.BEGIN) {
        m.remove(0);
      } else if (where == Position.EXPLICIT_END) {
        m.remove(m.size() - 1);
      } else if (where == Position.VARIED) {
        m.remove(index);
        index += PRIME;
        int currentSize = m.size();
        if (currentSize > 0) {
          index %= m.size();
        }
      }
    }
    return index;
  }
}