/*
    * 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.giraph.ooc.persistence;
  
  import java.util.ArrayList;
  import java.util.List;
  
  /**
   * Index chain used in out-of-core data accessor object (DAO) to access
   * serialized data.
   */
  public class DataIndex {
    /** Chain of data indices */
    private final List<DataIndexEntry> indexList = new ArrayList<>(5);
  
    /**
     * Add an index to the index chain
     *
     * @param entry the entry to add to the chain
     * @return the index chain itself
     */
    public DataIndex addIndex(DataIndexEntry entry) {
      indexList.add(entry);
      return this;
    }
  
    /**
     * Remove/Pop the last index in the index chain
     *
     * @return the index chain itself
     */
    public DataIndex removeLastIndex() {
      indexList.remove(indexList.size() - 1);
      return this;
    }
  
    /**
     * Create a copy of the existing DataIndex
     *
     * @return a copy of the existing index chain
     */
    public DataIndex copy() {
      DataIndex index = new DataIndex();
      for (DataIndexEntry entry : indexList) {
        index.indexList.add(entry);
      }
      return index;
    }
  
    @Override
    public boolean equals(Object obj) {
      if (!(obj instanceof DataIndex)) {
        return false;
      }
      DataIndex dataIndex = (DataIndex) obj;
      return indexList.equals(dataIndex.indexList);
    }
  
    @Override
    public int hashCode() {
      return indexList.hashCode();
    }
  
    @Override
    public String toString() {
      StringBuffer sb = new StringBuffer();
      for (DataIndexEntry entry : indexList) {
        sb.append(entry);
      }
      return sb.toString();
    }
  
    /** Interface to unify different types of entries used as index chain */
    public interface DataIndexEntry { }
  
    /**
     * Different static types of index chain entry
     */
    public enum TypeIndexEntry implements DataIndexEntry {
      /** The whole partition */
      PARTITION("_partition"),
      /** Partition vertices */
      PARTITION_VERTICES("_vertices"),
     /** Partition edges */
     PARTITION_EDGES("_edges"),
     /** Partition messages */
     MESSAGE("_messages"),
     /** Edges stored in edge store for a partition */
     EDGE_STORE("_edge_store"),
     /** Raw data buffer (refer to DiskBackedDataStore) */
     BUFFER("_buffer");
 
     /** String realization of entry type */
     private final String name;
 
     /**
      * Constructor
      *
      * @param name name of the type
      */
     TypeIndexEntry(String name) {
       this.name = name;
     }
 
     public String getName() {
       return name;
     }
 
     @Override
     public String toString() {
       return name;
     }
   }
 
   /**
    * Class representing any index chain that depends on something with id.
    * Generally this is used for identifying indices in two types:
    *  - Index entry based on superstep id ('S' and the superstep number)
    *  - Index entry based on partition id ('P' and the partition id)
    */
   public static final class NumericIndexEntry implements DataIndexEntry {
     /** Type of index */
     private final char type;
     /** Id of the index associated with the specified type */
     private final long id;
 
     /**
      * Constructor
      *
      * @param type type of index (for now 'S' for superstep, or 'P' for
      *             partition)
      * @param id id of the index associated with the given type
      */
     private NumericIndexEntry(char type, long id) {
       this.type = type;
       this.id = id;
     }
 
     @Override
     public boolean equals(Object obj) {
       if (!(obj instanceof NumericIndexEntry)) {
         return false;
       }
       NumericIndexEntry index = (NumericIndexEntry) obj;
       return index.type == type && index.id == id;
     }
 
     @Override
     public int hashCode() {
       int result = 17;
       result = result * 37 + type;
       result = result * 37 + (int) id;
       result = result * 37 + (int) (id >> 32);
       return result;
     }
 
     @Override
     public String toString() {
       return String.format("_%c%d", type, id);
     }
 
     /**
      * Create a data index entry for a given partition
      *
      * @param partitionId id of the partition
      * @return data index entry for a given partition
      */
     public static NumericIndexEntry createPartitionEntry(int partitionId) {
       return new NumericIndexEntry('P', partitionId);
     }
 
     /**
      * Create a data index entry for a given superstep
      *
      * @param superstep the superstep number
      * @return data index entry for a given superstep
      */
     public static NumericIndexEntry createSuperstepEntry(long superstep) {
       return new NumericIndexEntry('S', superstep);
     }
   }
 }