/*
    * 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.commons.vfs2.provider.ram;
  
  import java.io.ByteArrayOutputStream;
  import java.io.DataInputStream;
  import java.io.DataOutputStream;
  import java.io.EOFException;
  import java.io.IOException;
  import java.io.InputStream;
  import java.nio.charset.Charset;
  import java.util.Objects;
  
  import org.apache.commons.vfs2.RandomAccessContent;
  import org.apache.commons.vfs2.util.RandomAccessMode;
  
  /**
   * RAM File Random Access Content.
   */
  public class RamFileRandomAccessContent implements RandomAccessContent {
  
      private static final int BYTE_VALUE_MASK = 0xFF;
  
      /**
       * Build an 8-byte array from a long. No check is performed on the array length.
       *
       * @param n The number to convert.
       * @param b The array to fill.
       * @return A byte[].
       */
      public static byte[] toBytes(long n, final byte[] b) {
          b[7] = (byte) n;
          n >>>= 8;
          b[6] = (byte) n;
          n >>>= 8;
          b[5] = (byte) n;
          n >>>= 8;
          b[4] = (byte) n;
          n >>>= 8;
          b[3] = (byte) n;
          n >>>= 8;
          b[2] = (byte) n;
          n >>>= 8;
          b[1] = (byte) n;
          n >>>= 8;
          b[0] = (byte) n;
          return b;
      }
  
      /**
       * Build a long from first 8 bytes of the array.
       *
       * @param b The byte[] to convert.
       * @return A long.
       */
      public static long toLong(final byte[] b) {
          return ((long) b[7] & BYTE_VALUE_MASK) + (((long) b[6] & BYTE_VALUE_MASK) << 8) + (((long) b[5] & BYTE_VALUE_MASK) << 16)
                  + (((long) b[4] & BYTE_VALUE_MASK) << 24) + (((long) b[3] & BYTE_VALUE_MASK) << 32) + (((long) b[2] & BYTE_VALUE_MASK) << 40)
                  + (((long) b[1] & BYTE_VALUE_MASK) << 48) + (((long) b[0] & BYTE_VALUE_MASK) << 56);
      }
  
      /**
       * Build a short from first 2 bytes of the array.
       *
       * @param b The byte[] to convert.
       * @return A short.
       */
      public static short toShort(final byte[] b) {
          return (short) toUnsignedShort(b);
      }
  
      /**
       * Build a short from first 2 bytes of the array.
       *
       * @param b The byte[] to convert.
       * @return A short.
       */
      public static int toUnsignedShort(final byte[] b) {
          return (b[1] & BYTE_VALUE_MASK) + ((b[0] & BYTE_VALUE_MASK) << 8);
      }
  
      /**
       * File Pointer
       */
      protected int filePointer;
 
     /**
      * Buffer
      */
     private byte[] buf;
 
     /**
      * buffer
      */
     private final byte[] buffer8 = new byte[8];
 
     /**
      * buffer
      */
     private final byte[] buffer4 = new byte[4];
 
     /**
      * buffer
      */
     private final byte[] buffer2 = new byte[2];
 
     /**
      * buffer
      */
     private final byte[] buffer1 = new byte[1];
 
     /**
      * File
      */
     private final RamFileObject file;
 
     private final InputStream rafis;
 
     /**
      * Constructs a new instance.
      *
      * @param file The file to access.
      * @param mode The access mode.
      */
     public RamFileRandomAccessContent(final RamFileObject file, final RandomAccessMode mode) {
         Objects.requireNonNull(file, "file");
         Objects.requireNonNull(mode, "mode");
         buf = file.getData().getContent();
         this.file = file;
 
         rafis = new InputStream() {
             @Override
             public int available() throws IOException {
                 return getLeftBytes();
             }
 
             @Override
             public void close() throws IOException {
             }
 
             @Override
             public int read() throws IOException {
                 try {
                     return readByte() & BYTE_VALUE_MASK;
                 } catch (final EOFException e) {
                     return -1;
                 }
             }
 
             @Override
             public int read(final byte[] b) throws IOException {
                 return read(b, 0, b.length);
             }
 
             @Override
             public int read(final byte[] b, final int off, final int len) throws IOException {
                 int retLen = -1;
                 final int left = getLeftBytes();
                 if (left > 0) {
                     retLen = Math.min(len, left);
                     RamFileRandomAccessContent.this.readFully(b, off, retLen);
                 }
                 return retLen;
             }
 
             @Override
             public long skip(final long n) throws IOException {
                 seek(getFilePointer() + n);
                 return n;
             }
         };
     }
 
     /*
      * (non-Javadoc)
      *
      * @see org.apache.commons.vfs2.RandomAccessContent#close()
      */
     @Override
     public void close() throws IOException {
 
     }
 
     /*
      * (non-Javadoc)
      *
      * @see org.apache.commons.vfs2.RandomAccessContent#getFilePointer()
      */
     @Override
     public long getFilePointer() throws IOException {
         return filePointer;
     }
 
     @Override
     public InputStream getInputStream() throws IOException {
         return rafis;
     }
 
     private int getLeftBytes() {
         return buf.length - filePointer;
     }
 
     /*
      * (non-Javadoc)
      *
      * @see org.apache.commons.vfs2.RandomAccessContent#length()
      */
     @Override
     public long length() throws IOException {
         return buf.length;
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataInput#readBoolean()
      */
     @Override
     public boolean readBoolean() throws IOException {
         return readUnsignedByte() != 0;
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataInput#readByte()
      */
     @Override
     public byte readByte() throws IOException {
         return (byte) readUnsignedByte();
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataInput#readChar()
      */
     @Override
     public char readChar() throws IOException {
         final int ch1 = readUnsignedByte();
         final int ch2 = readUnsignedByte();
         return (char) ((ch1 << 8) + (ch2 << 0));
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataInput#readDouble()
      */
     @Override
     public double readDouble() throws IOException {
         return Double.longBitsToDouble(readLong());
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataInput#readFloat()
      */
     @Override
     public float readFloat() throws IOException {
         return Float.intBitsToFloat(readInt());
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataInput#readFully(byte[])
      */
     @Override
     public void readFully(final byte[] b) throws IOException {
         this.readFully(b, 0, b.length);
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataInput#readFully(byte[], int, int)
      */
     @Override
     public void readFully(final byte[] b, final int off, final int len) throws IOException {
         if (len < 0) {
             throw new IndexOutOfBoundsException("Length is lower than 0");
         }
 
         if (len > getLeftBytes()) {
             throw new IndexOutOfBoundsException(
                     "Read length (" + len + ") is higher than buffer left bytes (" + getLeftBytes() + ") ");
         }
 
         System.arraycopy(buf, filePointer, b, off, len);
 
         filePointer += len;
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataInput#readInt()
      */
     @Override
     public int readInt() throws IOException {
         return readUnsignedByte() << 24 | readUnsignedByte() << 16 | readUnsignedByte() << 8 | readUnsignedByte();
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataInput#readLine()
      */
     @Override
     public String readLine() throws IOException {
         throw new UnsupportedOperationException("deprecated");
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataInput#readLong()
      */
     @Override
     public long readLong() throws IOException {
         this.readFully(buffer8);
         return toLong(buffer8);
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataInput#readShort()
      */
     @Override
     public short readShort() throws IOException {
         this.readFully(buffer2);
         return toShort(buffer2);
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataInput#readUnsignedByte()
      */
     @Override
     public int readUnsignedByte() throws IOException {
         if (filePointer < buf.length) {
             return buf[filePointer++] & BYTE_VALUE_MASK;
         }
         throw new EOFException();
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataInput#readUnsignedShort()
      */
     @Override
     public int readUnsignedShort() throws IOException {
         this.readFully(buffer2);
         return toUnsignedShort(buffer2);
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataInput#readUTF()
      */
     @Override
     public String readUTF() throws IOException {
         return DataInputStream.readUTF(this);
     }
 
     /*
      * (non-Javadoc)
      *
      * @see org.apache.commons.vfs2.RandomAccessContent#seek(long)
      */
     @Override
     public void seek(final long pos) throws IOException {
         if (pos < 0) {
             throw new IOException("Attempt to position before the start of the file");
         }
         filePointer = (int) pos;
     }
 
     @Override
     public void setLength(final long newLength) throws IOException {
         file.resize(newLength);
         buf = file.getData().getContent();
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataInput#skipBytes(int)
      */
     @Override
     public int skipBytes(final int n) throws IOException {
         if (n < 0) {
             throw new IndexOutOfBoundsException("The skip number can't be negative");
         }
 
         final long newPos = filePointer + n;
 
         if (newPos > buf.length) {
             throw new IndexOutOfBoundsException("Tyring to skip too much bytes");
         }
 
         seek(newPos);
 
         return n;
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataOutput#write(byte[])
      */
     @Override
     public void write(final byte[] b) throws IOException {
         this.write(b, 0, b.length);
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataOutput#write(byte[], int, int)
      */
     @Override
     public void write(final byte[] b, final int off, final int len) throws IOException {
         if (getLeftBytes() < len) {
             final int newSize = buf.length + len - getLeftBytes();
             file.resize(newSize);
             buf = file.getData().getContent();
         }
         System.arraycopy(b, off, buf, filePointer, len);
         filePointer += len;
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataOutput#write(int)
      */
     @Override
     public void write(final int b) throws IOException {
         buffer1[0] = (byte) b;
         this.write(buffer1);
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataOutput#writeBoolean(boolean)
      */
     @Override
     public void writeBoolean(final boolean v) throws IOException {
         this.write(v ? 1 : 0);
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataOutput#writeByte(int)
      */
     @Override
     public void writeByte(final int i) throws IOException {
         this.write(i);
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataOutput#writeBytes(String)
      */
     @Override
     public void writeBytes(final String s) throws IOException {
         write(s.getBytes(Charset.defaultCharset()));
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataOutput#writeChar(int)
      */
     @Override
     public void writeChar(final int v) throws IOException {
         buffer2[0] = (byte) (v >>> 8 & BYTE_VALUE_MASK);
         buffer2[1] = (byte) (v >>> 0 & BYTE_VALUE_MASK);
         write(buffer2);
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataOutput#writeChars(String)
      */
     @Override
     public void writeChars(final String s) throws IOException {
         final int len = s.length();
         for (int i = 0; i < len; i++) {
             writeChar(s.charAt(i));
         }
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataOutput#writeDouble(double)
      */
     @Override
     public void writeDouble(final double v) throws IOException {
         writeLong(Double.doubleToLongBits(v));
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataOutput#writeFloat(float)
      */
     @Override
     public void writeFloat(final float v) throws IOException {
         writeInt(Float.floatToIntBits(v));
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataOutput#writeInt(int)
      */
     @Override
     public void writeInt(final int v) throws IOException {
         buffer4[0] = (byte) (v >>> 24 & BYTE_VALUE_MASK);
         buffer4[1] = (byte) (v >>> 16 & BYTE_VALUE_MASK);
         buffer4[2] = (byte) (v >>> 8 & BYTE_VALUE_MASK);
         buffer4[3] = (byte) (v & BYTE_VALUE_MASK);
         write(buffer4);
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataOutput#writeLong(long)
      */
     @Override
     public void writeLong(final long v) throws IOException {
         write(toBytes(v, buffer8));
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataOutput#writeShort(int)
      */
     @Override
     public void writeShort(final int v) throws IOException {
         buffer2[0] = (byte) (v >>> 8 & BYTE_VALUE_MASK);
         buffer2[1] = (byte) (v & BYTE_VALUE_MASK);
         write(buffer2);
     }
 
     /*
      * (non-Javadoc)
      *
      * @see java.io.DataOutput#writeUTF(String)
      */
     @Override
     public void writeUTF(final String str) throws IOException {
         final ByteArrayOutputStream out = new ByteArrayOutputStream(str.length());
         final DataOutputStream dataOut = new DataOutputStream(out);
         dataOut.writeUTF(str);
         dataOut.flush();
         dataOut.close();
         final byte[] b = out.toByteArray();
         write(b);
     }
 }