/*
 * Copyright (C) 2010 The Guava Authors
 *
 * 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.common.collect;

import static com.google.common.base.Preconditions.checkNotNull;

import com.google.common.collect.Lists;
import com.google.common.collect.Sets;

import java.util.Collections;
import java.util.List;
import java.util.Set;

/**
 * Package up sample data for common collections benchmarking.
 * 
 * @author Nicholaus Shupe
 */
class CollectionBenchmarkSampleData {
  private final boolean isUserTypeFast;
  private final SpecialRandom random;
  private final double hitRate;
  private final int size;
  
  private final Set<Element> valuesInSet;
  private final Element[] queries;
  
  CollectionBenchmarkSampleData(
      boolean isUserTypeFast,
      SpecialRandom random,
      double hitRate,
      int size) {
    this.isUserTypeFast = isUserTypeFast;
    this.random = checkNotNull(random);
    this.hitRate = hitRate;
    this.size = size;
    
    this.valuesInSet = createData();
    this.queries = createQueries(valuesInSet, 1024);
  }
  
  Set<Element> getValuesInSet() {
    return valuesInSet;
  }
  
  Element[] getQueries() {
    return queries;
  }

  private Element[] createQueries(Set<Element> elementsInSet, int numQueries) {
    List<Element> queryList = Lists.newArrayListWithCapacity(numQueries);

    int numGoodQueries = (int) (numQueries * hitRate + 0.5);

    // add good queries
    int size = elementsInSet.size();
    int minCopiesOfEachGoodQuery = numGoodQueries / size;
    int extras = numGoodQueries % size;

    for (int i = 0; i < minCopiesOfEachGoodQuery; i++) {
      queryList.addAll(elementsInSet);
    }
    List<Element> tmp = Lists.newArrayList(elementsInSet);
    Collections.shuffle(tmp, random);
    queryList.addAll(tmp.subList(0, extras));

    // now add bad queries
    while (queryList.size() < numQueries) {
      Element candidate = newElement();
      if (!elementsInSet.contains(candidate)) {
        queryList.add(candidate);
      }
    }
    Collections.shuffle(queryList, random);
    return queryList.toArray(new Element[0]);
  }

  private Set<Element> createData() {
    Set<Element> set = Sets.newHashSetWithExpectedSize(size);
    while (set.size() < size) {
      set.add(newElement());
    }
    return set;
  }

  private Element newElement() {
    int value = random.nextInt();
    return isUserTypeFast
        ? new Element(value)
        : new SlowElement(value);
  }
  
  static class Element implements Comparable<Element> {
    final int hash;
    Element(int hash) {
      this.hash = hash;
    }
    @Override public boolean equals(Object obj) {
      return this == obj
          || (obj instanceof Element && ((Element) obj).hash == hash);
    }
    @Override public int hashCode() {
      return hash;
    }
    @Override
    public int compareTo(Element that) {
      return (hash < that.hash) ? -1 : (hash > that.hash) ? 1 : 0;
    }
    @Override public String toString() {
      return String.valueOf(hash);
    }
  }

  static class SlowElement extends Element {
    SlowElement(int hash) {
      super(hash);
    }
    @Override public boolean equals(Object obj) {
      return slowItDown() != 1 && super.equals(obj);
    }
    @Override public int hashCode() {
      return slowItDown() + hash;
    }
    @Override public int compareTo(Element e) {
      int x = slowItDown();
      return x + super.compareTo(e) - x; // silly attempt to prevent opt
    }
    static int slowItDown() {
      int result = 0;
      for (int i = 1; i <= 1000; i++) {
        result += i;
      }
      return result;
    }
  }  
}