/*
    * 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.block_app.migration;
  
  import java.io.DataInput;
  import java.io.DataOutput;
  import java.io.IOException;
  import java.util.Iterator;
  
  import org.apache.giraph.block_app.framework.api.BlockWorkerSendApi;
  import org.apache.giraph.conf.TypesHolder;
  import org.apache.giraph.edge.Edge;
  import org.apache.giraph.edge.OutEdges;
  import org.apache.giraph.graph.Vertex;
  import org.apache.giraph.worker.WorkerAggregatorDelegator;
  import org.apache.giraph.worker.WorkerGlobalCommUsage;
  import org.apache.hadoop.io.Writable;
  import org.apache.hadoop.io.WritableComparable;
  
  /**
   * Replacement for AbstractComputation when migrating to
   * Blocks Framework, disallowing functions that are tied to
   * execution order.
   *
   * @param <I> Vertex ID
   * @param <V> Vertex Value
   * @param <E> Edge Value
   * @param <M1> Incoming Message Value
   * @param <M2> Outgoing Message Value
   */
  @SuppressWarnings("rawtypes")
  public class MigrationAbstractComputation<I extends WritableComparable,
      V extends Writable, E extends Writable, M1 extends Writable,
      M2 extends Writable> extends WorkerAggregatorDelegator<I, V, E>
      implements TypesHolder<I, V, E, M1, M2>, Writable {
    private BlockWorkerSendApi<I, V, E, M2> api;
    private MigrationWorkerContext workerContext;
    private long superstep;
  
    final void init(
        BlockWorkerSendApi<I, V, E, M2> workerApi,
        MigrationWorkerContext workerContext,
        long superstep) {
      this.api = workerApi;
      this.workerContext = workerContext;
      this.superstep = superstep;
      setWorkerGlobalCommUsage((WorkerGlobalCommUsage) workerApi);
      setConf(workerApi.getConf());
    }
  
    public void compute(Vertex<I, V, E> vertex,
        Iterable<M1> messages) throws IOException {
    }
  
    @Override
    public void readFields(DataInput in) throws IOException {
    }
  
    @Override
    public void write(DataOutput out) throws IOException {
    }
  
    public void preSuperstep() {
    }
  
    public void postSuperstep() {
    }
  
    @SuppressWarnings("deprecation")
    public long getTotalNumVertices() {
      return api.getTotalNumVertices();
    }
  
    @SuppressWarnings("deprecation")
    public long getTotalNumEdges() {
      return api.getTotalNumEdges();
    }
  
    public void sendMessage(I id, M2 message) {
      api.sendMessage(id, message);
    }
  
    public final void sendMessageToAllEdges(Vertex<I, V, E> vertex, M2 message) {
      api.sendMessageToAllEdges(vertex, message);
   }
 
   public final void sendMessageToMultipleEdges(
       Iterator<I> vertexIdIterator, M2 message) {
     api.sendMessageToMultipleEdges(vertexIdIterator, message);
   }
 
   public final void addVertexRequest(I id, V value,
       OutEdges<I, E> edges) throws IOException {
     api.addVertexRequest(id, value, edges);
   }
 
   public final void addVertexRequest(I id, V value) throws IOException {
     api.addVertexRequest(id, value);
   }
 
   public final void removeVertexRequest(I vertexId) throws IOException {
     api.removeVertexRequest(vertexId);
   }
 
   public final void addEdgeRequest(I sourceVertexId,
       Edge<I, E> edge) throws IOException {
     api.addEdgeRequest(sourceVertexId, edge);
   }
 
   public final void removeEdgesRequest(I sourceVertexId,
       I targetVertexId) throws IOException {
     api.removeEdgesRequest(sourceVertexId, targetVertexId);
   }
 
   @SuppressWarnings("unchecked")
   public <W extends MigrationWorkerContext> W getWorkerContext() {
     return (W) workerContext;
   }
 
   /**
    * Drop-in replacement for BasicComputation when migrating to
    * Blocks Framework, disallowing functions that are tied to
    * execution order.
    *
    * @param <I> Vertex ID
    * @param <V> Vertex Value
    * @param <E> Edge Value
    * @param <M> Message type
    */
   public static class MigrationBasicComputation<I extends WritableComparable,
       V extends Writable, E extends Writable, M extends Writable>
       extends MigrationAbstractComputation<I, V, E, M, M> {
   }
 
   /**
    * Drop-in replacement for AbstractComputation when migrating to
    * Blocks Framework.
    *
    * @param <I> Vertex ID
    * @param <V> Vertex Value
    * @param <E> Edge Value
    * @param <M1> Incoming Message Value
    * @param <M2> Outgoing Message Value
    */
   public static class MigrationFullAbstractComputation
       <I extends WritableComparable, V extends Writable, E extends Writable,
       M1 extends Writable, M2 extends Writable>
       extends MigrationAbstractComputation<I, V, E, M1, M2> {
     public long getSuperstep() {
       return super.superstep;
     }
   }
 
   /**
    * Drop-in replacement for BasicComputation when migrating to
    * Blocks Framework.
    *
    * @param <I> Vertex ID
    * @param <V> Vertex Value
    * @param <E> Edge Value
    * @param <M> Message type
    */
   public static class MigrationFullBasicComputation
       <I extends WritableComparable, V extends Writable, E extends Writable,
       M extends Writable>
       extends MigrationFullAbstractComputation<I, V, E, M, M> {
   }
 }