/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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 org.apache.carbondata.core.cache.dictionary;

import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.carbondata.core.constants.CarbonCommonConstants;
import org.apache.carbondata.core.util.CarbonProperties;

import net.jpountz.xxhash.XXHash32;
import net.jpountz.xxhash.XXHashFactory;

/**
 * class that implements methods specific for dictionary data look up
 */
public class ColumnReverseDictionaryInfo extends AbstractColumnDictionaryInfo {

  /**
   * Map which will maintain mapping of byte array to surrogate key
   */
  private Map<DictionaryByteArrayWrapper, Integer> dictionaryByteArrayToSurrogateKeyMap;

  /**
   * hashing algorithm to calculate hash code
   */
  private XXHash32 xxHash32;

  /**
   * check and initialize xxHash32 if enabled
   */
  public ColumnReverseDictionaryInfo() {
    boolean useXXHash = Boolean.valueOf(CarbonProperties.getInstance()
        .getProperty(CarbonCommonConstants.ENABLE_XXHASH,
            CarbonCommonConstants.ENABLE_XXHASH_DEFAULT));
    if (useXXHash) {
      xxHash32 = XXHashFactory.fastestInstance().hash32();
    }
  }

  /**
   * This method will find and return the surrogate key for a given dictionary value
   * Applicable scenario:
   * 1. Incremental data load : Dictionary will not be generated for existing values. For
   * that values have to be looked up in the existing dictionary cache.
   * 2. Filter scenarios where from value surrogate key has to be found.
   *
   * @param value dictionary value as byte array. It will be treated as key here
   * @return if found returns key else INVALID_SURROGATE_KEY
   */
  @Override
  public int getSurrogateKey(byte[] value) {
    DictionaryByteArrayWrapper dictionaryByteArrayWrapper =
        new DictionaryByteArrayWrapper(value, xxHash32);
    Integer surrogateKeyInMap =
        dictionaryByteArrayToSurrogateKeyMap.get(dictionaryByteArrayWrapper);
    if (null == surrogateKeyInMap) {
      return CarbonCommonConstants.INVALID_SURROGATE_KEY;
    }
    return surrogateKeyInMap;
  }

  /**
   * This method will add a new dictionary chunk to existing list of dictionary chunks
   *
   * @param dictionaryChunk
   */
  @Override
  public void addDictionaryChunk(List<byte[]> dictionaryChunk) {
    dictionaryChunks.add(dictionaryChunk);
    if (null == dictionaryByteArrayToSurrogateKeyMap) {
      createDictionaryByteArrayToSurrogateKeyMap(dictionaryChunk.size());
    }
    addDataToDictionaryMap();
  }

  /**
   * This method will add the new dictionary data to map
   */
  private void addDataToDictionaryMap() {
    int surrogateKey = dictionaryByteArrayToSurrogateKeyMap.size();
    List<byte[]> oneDictionaryChunk = dictionaryChunks.get(dictionaryChunks.size() - 1);
    for (int i = 0; i < oneDictionaryChunk.size(); i++) {
      // create a wrapper class that will calculate hash code for byte array
      DictionaryByteArrayWrapper dictionaryByteArrayWrapper =
          new DictionaryByteArrayWrapper(oneDictionaryChunk.get(i), xxHash32);
      dictionaryByteArrayToSurrogateKeyMap.put(dictionaryByteArrayWrapper, ++surrogateKey);
    }
  }

  /**
   * This method will create the dictionary map. First time it will
   * create dictionary map with capacity equal to list of byte arrays
   *
   * @param initialMapSize capacity to which map is to be instantiated
   */
  private void createDictionaryByteArrayToSurrogateKeyMap(int initialMapSize) {
    dictionaryByteArrayToSurrogateKeyMap = new ConcurrentHashMap<>(initialMapSize);
  }

  /**
   * This method will set the sort order index of a dictionary column.
   * Sort order index if the index of dictionary values after they are sorted.
   *
   * @param sortOrderIndex
   */
  @Override
  public void setSortOrderIndex(List<Integer> sortOrderIndex) {
  }

  /**
   * This method will set the sort reverse index of a dictionary column.
   * Sort reverse index is the index of dictionary values before they are sorted.
   *
   * @param sortReverseOrderIndex
   */
  @Override
  public void setSortReverseOrderIndex(List<Integer> sortReverseOrderIndex) {
  }
}