package net.logAnalyzer.utils;
   
   import java.io.DataInput;
   import java.io.DataInputStream;
   import java.io.EOFException;
   import java.io.File;
   import java.io.FileNotFoundException;
   import java.io.IOException;
   import java.io.RandomAccessFile;
  
  /***
   * This class is a wrapper is used to read a set of files. This implementation
   * acts as a wrapper supporting a small number of methods of the class
   * {@link java.io.RandomAccessFile}.
   * 
   * @author Karim REFEYTON
   * @version 0.1
   */
  public final class FilesSetReader implements DataInput {
  
      /***
       * Current file index.
       */
      private int currentFile = 0;
  
      /***
       * Files length.
       */
      private long[] filesLength = null;
  
      /***
       * Sum of the length of the previous files.
       */
      private long previousFilesLength = 0;
  
      /***
       * RandomAccesFiles.
       */
      private RandomAccessFile[] raFiles = null;
  
      /***
       * Total files length.
       */
      private long totalLength = 0;
  
      /***
       * Default construtor. Constructs an empty file set.
       */
      public FilesSetReader() {
          currentFile = 0;
          filesLength = new long[] {};
          previousFilesLength = 0;
          raFiles = new RandomAccessFile[] {};
          totalLength = 0;
      }
  
      /***
       * Returns the current offset in this log file.
       * 
       * @return The offset from the beginning of the file, in bytes, at which the
       *         next read or write occurs.
       * @throws IOException
       *             If an I/O error occurs.
       * @see RandomAccessFile#getFilePointer()
       */
      public long getFilePointer() throws IOException {
          return previousFilesLength + raFiles[currentFile].getFilePointer();
      }
  
      /***
       * Opens each input file as a new {@link RandomAccessFile} with mode "r".
       * 
       * @param inputFiles
       *            Files to read.
       * @throws FileNotFoundException
       *             If one or more files exist but is a directory rather than
       *             regular files, or cannot be opened or created for any other
       *             reason.
       * @see RandomAccessFile#RandomAccessFile(java.io.File, java.lang.String)
       */
      public void setFiles(File[] inputFiles) throws FileNotFoundException {
          filesLength = new long[inputFiles.length];
          raFiles = new RandomAccessFile[inputFiles.length];
          for (int i = 0; i < raFiles.length; i++) {
              filesLength[i] = inputFiles[i].length();
              totalLength += filesLength[i];
              raFiles[i] = new RandomAccessFile(inputFiles[i], "r");
          }
      }
  
      /***
       * Closes this random access file stream and releases any system resources
       * associated with the stream.
       * 
       * @throws IOException
       *             If an I/O error occurs.
       * @see java.io.Closeable#close()
       */
      public void close() throws IOException {
         for (int i = 0; i < raFiles.length; i++) {
             raFiles[i].close();
         }
     }
 
     /***
      * Returns the total length of files in the set.
      * 
      * @return Total length of files in the set.
      */
     public long length() {
         return totalLength;
     }
 
     /***
      * Reads a byte of data from this file using {@link RandomAccessFile#read()}
      * on the current file of the set of files. If the end of current file is
      * reached and the set contains more than one file, tries to read from the
      * next file.
      * 
      * @return the next byte of data, or <code>-1</code> if the end of the
      *         file has been reached.
      * @throws IOException
      *             if an I/O error occurs. Not thrown if end-of-file has been
      *             reached.
      * @see RandomAccessFile#read()
      */
     public int read() throws IOException {
         int ch = raFiles[currentFile].read();
         // If the end of the current file is reached...
         if (ch < 0 && currentFile < raFiles.length - 1) {
             // Resets the pointer
             previousFilesLength += filesLength[currentFile];
             // Changes to the next file
             currentFile++;
             // Reads the first line of the new current file
             return read();
         } else {
             return ch;
         }
     }
 
     /***
      * Reads one input byte using {@link #read()} and returns <code>true</code>
      * if that byte is nonzero, <code>false</code> if that byte is zero.
      * 
      * @return the <code>boolean</code> value read.
      * @throws EOFException
      *             if this file has reached the end.
      * @throws IOException
      *             if an I/O error occurs.
      * @see java.io.DataInput#readBoolean()
      */
     public boolean readBoolean() throws IOException {
         int ch = read();
         if (ch < 0) {
             throw new EOFException();
         }
         return (ch != 0);
     }
 
     /***
      * Reads one input byte using {@link #read()} and casts it to
      * <code>byte</code>.
      * 
      * @return the <code>byte</code> value read.
      * @throws EOFException
      *             if this file has reached the end.
      * @throws IOException
      *             if an I/O error occurs.
      * @see java.io.DataInput#readByte()
      */
     public byte readByte() throws IOException {
         int ch = read();
         if (ch < 0) {
             throw new EOFException();
         }
         return (byte) ch;
     }
 
     /***
      * Reads an unsigned short using {@link #readUnsignedShort()} and casts it
      * to <code>char</code>.
      * 
      * @return the <code>char</code> value read.
      * @throws EOFException
      *             if this file has reached the end.
      * @throws IOException
      *             if an I/O error occurs.
      * @see java.io.DataInput#readChar()
      */
     public char readChar() throws IOException {
         return (char) readUnsignedShort();
     }
 
     /***
      * Reads a <code>double</code> from this file. This method reads a
      * <code>long</code> value, starting at the current file pointer, as if by
      * the <code>readLong</code> method and then converts that
      * <code>long</code> to a <code>double</code> using
      * {@link Double#longBitsToDouble(long)}.
      * 
      * @return the <code>double</code> value read.
      * @throws IOException
      *             if an I/O error occurs.
      * @see java.io.DataInput#readDouble()
      */
     public double readDouble() throws IOException {
         return Double.longBitsToDouble(readLong());
     }
 
     /***
      * Reads a <code>float</code> from this file. This method reads a
      * <code>long</code> value, starting at the current file pointer, as if by
      * the <code>readLong</code> method and then converts that
      * <code>long</code> to a <code>float</code> using
      * {@link Float#intBitsToFloat(int)}.
      * 
      * @return the <code>float</code> value read.
      * @throws IOException
      *             if an I/O error occurs.
      * @see java.io.DataInput#readFloat()
      */
     public float readFloat() throws IOException {
         return Float.intBitsToFloat(readInt());
     }
 
     /***
      * Reads exactly <code>len</code> bytes from this file into the byte array
      * unsing {@link  #readByte()}, starting at the current file pointer. This
      * method reads repeatedly from the file until the requested number of bytes
      * are read. This method blocks until the requested number of bytes are
      * read, the end of the stream is detected, or an exception is thrown.
      * 
      * @param b
      *            the buffer into which the data is read.
      * @param off
      *            the start offset of the data.
      * @param len
      *            the number of bytes to read.
      * @throws EOFException
      *             if this file reaches the end before reading all the bytes.
      * @throws IOException
      *             if an I/O error occurs.
      * @see DataInput#readFully(byte[], int, int)
      */
     public void readFully(byte[] b, int off, int len) throws IOException {
         skipBytes(off);
         int n = 0;
         do {
             b[n++] = readByte();
         } while (n < len);
     }
 
     /***
      * Reads <code>b.length</code> bytes from this file into the byte array
      * using {@link #readFully(byte[], int, int)}, starting at the current file
      * pointer.
      * 
      * @param b
      *            the buffer into which the data is read.
      * @throws EOFException
      *             if this file reaches the end before reading all the bytes.
      * @throws IOException
      *             if an I/O error occurs.
      * @see DataInput#readFully(byte[])
      */
     public void readFully(byte[] b) throws IOException {
         readFully(b, 0, b.length);
     }
 
     /***
      * Reads four input bytes using {@link #read()} and combines them to
      * <code>int</code>.
      * 
      * @return the <code>int</code> value read.
      * @throws EOFException
      *             if this file has reached the end.
      * @throws IOException
      *             if an I/O error occurs.
      * 
      * @see DataInput#readInt()
      */
     public int readInt() throws IOException {
         int ch1 = read();
         int ch2 = read();
         int ch3 = read();
         int ch4 = read();
         if ((ch1 | ch2 | ch3 | ch4) < 0) {
             throw new EOFException();
         }
         return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0));
     }
 
     /***
      * Reads the next line of text from this file. If the end of current file is
      * reached and the set contains more than one file, tries to read from the
      * next file.
      * 
      * @return The next line of text from this file, or null if end of file is
      *         encountered before even one byte is read.
      * @throws IOException
      *             If an I/O error occurs.
      * @see DataInput#readLine()
      */
     public String readLine() throws IOException {
         String line = raFiles[currentFile].readLine();
         // If the end of the current file is reached...
         if (line == null && currentFile < raFiles.length - 1) {
             // Resets the pointer
             previousFilesLength += filesLength[currentFile];
             // Changes to the next file
             currentFile++;
             // Reads the first line of the new current file
             return readLine();
         } else {
             return line;
         }
     }
 
     /***
      * Reads eight input bytes using {@link #read()} twice and combines them to
      * <code>long</code>.
      * 
      * @return the <code>long</code> value read.
      * @throws EOFException
      *             if this file has reached the end.
      * @throws IOException
      *             if an I/O error occurs.
      * 
      * @see DataInput#readLong()
      */
     public long readLong() throws IOException {
         return ((long) (readInt()) << 32) + (readInt() & 0xFFFFFFFFL);
     }
 
     /***
      * Reads an unsigned short using {@link #readUnsignedShort()} and casts it
      * to <code>short</code>.
      * 
      * @return the <code>short</code> value read.
      * @throws EOFException
      *             if this file has reached the end.
      * @throws IOException
      *             if an I/O error occurs.
      * 
      * @see DataInput#readShort()
      */
     public short readShort() throws IOException {
         return (short) readUnsignedShort();
     }
 
     /***
      * Reads a single input byte using {@link #read()} and returns it.
      * 
      * @return the <code>int</code> value read.
      * @throws EOFException
      *             if this file has reached the end.
      * @throws IOException
      *             if an I/O error occurs.
      * 
      * @see DataInput#readUnsignedByte()
      */
     public int readUnsignedByte() throws IOException {
         int ch = read();
         if (ch < 0) {
             throw new EOFException();
         }
         return ch;
     }
 
     /***
      * Reads two input bytes using {@link #read()} and combines them to
      * <code>int</code> as an unsigned short.
      * 
      * @return the <code>int</code> value read.
      * @throws EOFException
      *             if this file has reached the end.
      * @throws IOException
      *             if an I/O error occurs.
      * 
      * @see DataInput#readUnsignedShort()
      */
     public int readUnsignedShort() throws IOException {
         int ch1 = read();
         int ch2 = read();
         if ((ch1 | ch2) < 0) {
             throw new EOFException();
         }
         return (ch1 << 8) + (ch2 << 0);
     }
 
     /***
      * Reads in a string that has been encoded using a <a
      * href="#modified-utf-8">modified UTF-8</a> format.
      * 
      * @see DataInput#readUTF()
      */
     public String readUTF() throws IOException {
         return DataInputStream.readUTF(this);
     }
 
     /***
      * Sets the file-pointer offset, measured from the beginning of this file,
      * at which the next read or write occurs.
      * 
      * @param pos
      *            The offset position, measured in bytes from the beginning of
      *            the file, at which to set the file pointer.
      * @throws IOException
      *             If an I/O error occurs.
      * @see RandomAccessFile#seek(long)
      */
     public void seek(long pos) throws IOException {
         if (pos < previousFilesLength) {
             if (currentFile > 0) {
                 // The position is in a previous file
                 currentFile--;
                 previousFilesLength -= filesLength[currentFile];
                 seek(pos);
             } else {
                 // The position is in the first file
                 raFiles[0].seek(pos);
             }
         } else if (pos > previousFilesLength + filesLength[currentFile]) {
             if (currentFile < raFiles.length - 1) {
                 // The position is in the next file
                 previousFilesLength += filesLength[currentFile];
                 currentFile++;
                 seek(pos);
             } else {
                 // The position is over the last file
                 raFiles[currentFile].seek(pos - previousFilesLength);
             }
         } else {
             // The position is in the current file
             raFiles[currentFile].seek(pos - previousFilesLength);
         }
     }
 
     /***
      * Attempts to skip over <code>n</code> bytes of input discarding the
      * skipped bytes.
      * 
      * @param n
      *            the number of bytes to be skipped.
      * @return the actual number of bytes skipped.
      * @exception IOException
      *                if an I/O error occurs.
      * @see DataInput#skipBytes(int)
      */
     public int skipBytes(int n) throws IOException {
         if (n <= 0) {
             return 0;
         }
         long oldpos = getFilePointer();
         long newpos = oldpos + n;
         if (newpos > length()) {
             newpos = length();
         }
         seek(newpos);
 
         // Returns the number of skipped bytes
         return (int) (newpos - oldpos);
     }
 }