/*

  * 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.utils;

 import java.io.DataOutput;

 import java.io.IOException;

 import java.nio.ByteOrder;

 import io.netty.buffer.Unpooled;

 import io.netty.buffer.ByteBuf;

 /**

  * Special output stream that can grow as needed and dumps to a

  * DynamicChannelBuffer.

  */

 public class DynamicChannelBufferOutputStream implements DataOutput {

   /** Internal dynamic channel buffer */

   private ByteBuf buffer;

   /**

    * Constructor

    *

    * @param estimatedLength Estimated length of the buffer

    */

   public DynamicChannelBufferOutputStream(int estimatedLength) {

     buffer = Unpooled.unreleasableBuffer(Unpooled.buffer(estimatedLength))

         .order(ByteOrder.LITTLE_ENDIAN);

     // -- TODO unresolved what are benefits of using releasable?

     // currently nit because it is just used in 1 test file

   }

   /**

    * Constructor with the buffer to use

    *

    * @param buffer Buffer to be written to (cleared before use)

    */

   public DynamicChannelBufferOutputStream(ByteBuf buffer) {

     this.buffer = buffer;

     buffer.clear();

   }

   /**

    * Get the dynamic channel buffer

    *

    * @return dynamic channel buffer (not a copy)

    */

   public ByteBuf getDynamicChannelBuffer() {

     return buffer;

   }

   @Override

   public void write(int b) throws IOException {

     buffer.writeByte(b);

   }

   @Override

   public void write(byte[] b) throws IOException {

     buffer.writeBytes(b);

   }

   @Override

   public void write(byte[] b, int off, int len) throws IOException {

     buffer.writeBytes(b, off, len);

   }

   @Override

   public void writeBoolean(boolean v) throws IOException {

     buffer.writeByte(v ? 1 : 0);

   }

   @Override

   public void writeByte(int v) throws IOException {

     buffer.writeByte(v);

   }

   @Override

   public void writeShort(int v) throws IOException {

     buffer.writeShort(v);

   }

   @Override

   public void writeChar(int v) throws IOException {

     buffer.writeChar(v);

   }

   @Override

   public void writeInt(int v) throws IOException {

     buffer.writeInt(v);

   }

   @Override

   public void writeLong(long v) throws IOException {

     buffer.writeLong(v);

   }

   @Override

   public void writeFloat(float v) throws IOException {

     buffer.writeFloat(v);

   }

   @Override

   public void writeDouble(double v) throws IOException {

     buffer.writeDouble(v);

   }

   @Override

   public void writeBytes(String s) throws IOException {

     // Note that this code is mostly copied from DataOutputStream

     int len = s.length();

     for (int i = 0; i < len; i++) {

       buffer.writeByte((byte) s.charAt(i));

     }

   }

   @Override

   public void writeChars(String s) throws IOException {

     // Note that this code is mostly copied from DataOutputStream

     int len = s.length();

     for (int i = 0; i < len; i++) {

       int v = s.charAt(i);

       buffer.writeByte((v >>> 8) & 0xFF);

       buffer.writeByte((v >>> 0) & 0xFF);

     }

   }

   @Override

   public void writeUTF(String s) throws IOException {

     // Note that this code is mostly copied from DataOutputStream

     int strlen = s.length();

     int utflen = 0;

     int c;

     /* use charAt instead of copying String to char array */

     for (int i = 0; i < strlen; i++) {

       c = s.charAt(i);

       if ((c >= 0x0001) && (c <= 0x007F)) {

         utflen++;

       } else if (c > 0x07FF) {

         utflen += 3;

       } else {

         utflen += 2;

       }

     }

     buffer.writeByte((byte) ((utflen >>> 8) & 0xFF));

     buffer.writeByte((byte) ((utflen >>> 0) & 0xFF));

     int i = 0;

     for (i = 0; i < strlen; i++) {

       c = s.charAt(i);

       if (!((c >= 0x0001) && (c <= 0x007F))) {

         break;

       }

       buffer.writeByte((byte) c);

     }

     for (; i < strlen; i++) {

       c = s.charAt(i);

       if ((c >= 0x0001) && (c <= 0x007F)) {

         buffer.writeByte((byte) c);

       } else if (c > 0x07FF) {

         buffer.writeByte((byte) (0xE0 | ((c >> 12) & 0x0F)));

         buffer.writeByte((byte) (0x80 | ((c >>  6) & 0x3F)));

         buffer.writeByte((byte) (0x80 | ((c >>  0) & 0x3F)));

       } else {

         buffer.writeByte((byte) (0xC0 | ((c >>  6) & 0x1F)));

         buffer.writeByte((byte) (0x80 | ((c >>  0) & 0x3F)));

       }

     }

   }

 }