package stdlib;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLConnection;

/* ***********************************************************************
 *  Compilation:  javac BinaryIn.java
 *  Execution:    java BinaryIn input output
 *
 *  This library is for reading binary data from an input stream.
 *
 *  % java BinaryIn http://introcs.cs.princeton.edu/cover.jpg output.jpg
 *
 *************************************************************************/

/**
 *  <i>Binary input</i>. This class provides methods for reading
 *  in bits from a binary input stream, either
 *  one bit at a time (as a {@code boolean}),
 *  8 bits at a time (as a {@code byte} or {@code char}),
 *  16 bits at a time (as a {@code short}),
 *  32 bits at a time (as an {@code int} or {@code float}), or
 *  64 bits at a time (as a {@code double} or {@code long}).
 *  <p>
 *  The binary input stream can be from standard input, a filename,
 *  a URL name, a Socket, or an InputStream.
 *  <p>
 *  All primitive types are assumed to be represented using their
 *  standard Java representations, in big-endian (most significant
 *  byte first) order.
 *  <p>
 *  The client should not intermix calls to {@code BinaryIn} with calls
 *  to {@code In}; otherwise unexpected behavior will result.
 */
public final class BinaryIn {
  private static final int EOF = -1;   // end of file

  private BufferedInputStream in;      // the input stream
  private int buffer;                  // one character buffer
  private int N;                       // number of bits left in buffer

  /**
   * Create a binary input stream from standard input.
   */
  public BinaryIn() {
    in = new BufferedInputStream(System.in);
    fillBuffer();
  }

  /**
   * Create a binary input stream from an InputStream.
   */
  public BinaryIn(InputStream is) {
    in = new BufferedInputStream(is);
    fillBuffer();
  }

  /**
   * Create a binary input stream from a socket.
   */
  public BinaryIn(Socket socket) {
    try {
      InputStream is = socket.getInputStream();
      in = new BufferedInputStream(is);
      fillBuffer();
    }
    catch (IOException ioe) {
      System.err.println("Could not open " + socket);
    }
  }

  /**
   * Create a binary input stream from a URL.
   */
  public BinaryIn(URL url) {
    try {
      URLConnection site = url.openConnection();
      InputStream is     = site.getInputStream();
      in = new BufferedInputStream(is);
      fillBuffer();
    }
    catch (IOException ioe) {
      System.err.println("Could not open " + url);
    }
  }

  /**
   * Create a binary input stream from a filename or URL name.
   */
  public BinaryIn(String s) {

    try {
      // first try to read file from local file system
      File file = new File(s);
      if (file.exists()) {
        FileInputStream fis = new FileInputStream(file);
        in = new BufferedInputStream(fis);
        fillBuffer();
        return;
      }

      // next try for files included in jar
      URL url = getClass().getResource(s);

      // or URL from web
      if (url == null) { url = new java.net.URI(s).toURL(); }

      URLConnection site = url.openConnection();
      InputStream is     = site.getInputStream();
      in = new BufferedInputStream(is);
      fillBuffer();
    }
    catch (IOException ioe) {
      System.err.println("Could not open " + s);
    } catch (URISyntaxException e) {
      System.err.println("Could not open " + s);
    }
  }

  private void fillBuffer() {
    try { buffer = in.read(); N = 8; }
    catch (IOException e) { System.err.println("EOF"); buffer = EOF; N = -1; }
  }

  /**
   * Does the binary input stream exist?
   */
  public boolean exists()  {
    return in != null;
  }

  /**
   * Returns true if the binary input stream is empty.
   * @return true if and only if the binary input stream is empty
   */
  public boolean isEmpty() {
    return buffer == EOF;
  }

  /**
   * Read the next bit of data from the binary input stream and return as a boolean.
   * @return the next bit of data from the binary input stream as a {@code boolean}
   * @throws RuntimeException if the input stream is empty
   */
  public boolean readBoolean() {
    if (isEmpty()) throw new RuntimeException("Reading from empty input stream");
    N--;
    boolean bit = ((buffer >> N) & 1) == 1;
    if (N == 0) fillBuffer();
    return bit;
  }

  /**
   * Read the next 8 bits from the binary input stream and return as an 8-bit char.
   * @return the next 8 bits of data from the binary input stream as a {@code char}
   * @throws RuntimeException if there are fewer than 8 bits available
   */
  public char readChar() {
    if (isEmpty()) throw new RuntimeException("Reading from empty input stream");

    // special case when aligned byte
    if (N == 8) {
      int x = buffer;
      fillBuffer();
      return (char) (x & 0xff);
    }

    // combine last N bits of current buffer with first 8-N bits of new buffer
    int x = buffer;
    x <<= (8-N);
    int oldN = N;
    fillBuffer();
    if (isEmpty()) throw new RuntimeException("Reading from empty input stream");
    N = oldN;
    x |= (buffer >>> N);
    return (char) (x & 0xff);
    // the above code doesn't quite work for the last character if N = 8
    // because buffer will be -1
  }


  /**
   * Read the next r bits from the binary input stream and return as an r-bit character.
   * @param r number of bits to read.
   * @return the next r bits of data from the binary input streamt as a {@code char}
   * @throws RuntimeException if there are fewer than r bits available
   */
  public char readChar(int r) {
    if (r < 1 || r > 16) throw new RuntimeException("Illegal value of r = " + r);

    // optimize r = 8 case
    if (r == 8) return readChar();

    char x = 0;
    for (int i = 0; i < r; i++) {
      x <<= 1;
      boolean bit = readBoolean();
      if (bit) x |= 1;
    }
    return x;
  }


  /**
   * Read the remaining bytes of data from the binary input stream and return as a string.
   * @return the remaining bytes of data from the binary input stream as a {@code String}
   * @throws RuntimeException if the input stream is empty or if the number of bits
   * available is not a multiple of 8 (byte-aligned)
   */
  public String readString() {
    if (isEmpty()) throw new RuntimeException("Reading from empty input stream");

    StringBuilder sb = new StringBuilder();
    while (!isEmpty()) {
      char c = readChar();
      sb.append(c);
    }
    return sb.toString();
  }


  /**
   * Read the next 16 bits from the binary input stream and return as a 16-bit short.
   * @return the next 16 bits of data from the binary standard input as a {@code short}
   * @throws RuntimeException if there are fewer than 16 bits available
   */
  public short readShort() {
    short x = 0;
    for (int i = 0; i < 2; i++) {
      char c = readChar();
      x <<= 8;
      x |= c;
    }
    return x;
  }

  /**
   * Read the next 32 bits from the binary input stream and return as a 32-bit int.
   * @return the next 32 bits of data from the binary input stream as a {@code int}
   * @throws RuntimeException if there are fewer than 32 bits available
   */
  public int readInt() {
    int x = 0;
    for (int i = 0; i < 4; i++) {
      char c = readChar();
      x <<= 8;
      x |= c;
    }
    return x;
  }

  /**
   * Read the next r bits from the binary input stream return as an r-bit int.
   * @param r number of bits to read.
   * @return the next r bits of data from the binary input stream as a {@code int}
   * @throws RuntimeException if there are fewer than r bits available on standard input
   */
  public int readInt(int r) {
    if (r < 1 || r > 32) throw new RuntimeException("Illegal value of r = " + r);

    // optimize r = 32 case
    if (r == 32) return readInt();

    int x = 0;
    for (int i = 0; i < r; i++) {
      x <<= 1;
      boolean bit = readBoolean();
      if (bit) x |= 1;
    }
    return x;
  }

  /**
   * Read the next 64 bits from the binary input stream and return as a 64-bit long.
   * @return the next 64 bits of data from the binary input stream as a {@code long}
   * @throws RuntimeException if there are fewer than 64 bits available
   */
  public long readLong() {
    long x = 0;
    for (int i = 0; i < 8; i++) {
      char c = readChar();
      x <<= 8;
      x |= c;
    }
    return x;
  }

  /**
   * Read the next 64 bits from the binary input stream and return as a 64-bit double.
   * @return the next 64 bits of data from the binary input stream as a {@code double}
   * @throws RuntimeException if there are fewer than 64 bits available
   */
  public double readDouble() {
    return Double.longBitsToDouble(readLong());
  }

  /**
   * Read the next 32 bits from standard input and return as a 32-bit float.
   * @return the next 32 bits of data from standard input as a {@code float}
   * @throws RuntimeException if there are fewer than 32 bits available on standard input
   */
  public float readFloat() {
    return Float.intBitsToFloat(readInt());
  }


  /**
   * Read the next 8 bits from the binary input stream and return as an 8-bit byte.
   * @return the next 8 bits of data from the binary input stream as a {@code byte}
   * @throws RuntimeException if there are fewer than 8 bits available
   */
  public byte readByte() {
    char c = readChar();
    byte x = (byte) (c & 0xff);
    return x;
  }

  /**
   * Test client. Reads in the name of a file or url (first command-line
   * argument) and writes it to a file (second command-line argument).
   */
  public static void main(String[] args) {
    BinaryIn  in  = new BinaryIn(args[0]);
    BinaryOut out = new BinaryOut(args[1]);

    // read one 8-bit char at a time
    while (!in.isEmpty()) {
      char c = in.readChar();
      out.write(c);
    }
    out.flush();
  }
}