// We use big-endian as DataOutputStream does
sclass ByteHead /*is DataOutput*/ is AutoCloseable {
  settable bool readMode;
  settable bool writeMode;
  gettable InputStream inputStream;
  gettable OutputStream outputStream;
  settable long byteCounter;
  gettable bool eof;
  
  *() {}
  *(InputStream inputStream) { inputStream(inputStream); }
  *(OutputStream outputStream) { outputStream(outputStream); }
  
  selfType inputStream(InputStream inputStream) { this.inputStream = inputStream; readMode(true); this; }
  selfType outputStream(OutputStream outputStream) { this.outputStream = outputStream; writeMode(true); this; }
  
  void write(byte[] data) ctex {
    ensureWriteMode();
    outputStream?.write(data);
    byteCounter += data.length;
  }
  
  void writeFloat(float f) {
    writeInt(Float.floatToIntBits(f));
  }
  
  void writeLong(long l) {
    writeInt((int) (l >> 32));
    writeInt((int) l);
  }
  
  void writeInt(int i) {
    write(i >> 24);
    write(i >> 16);
    write(i >> 8);
    write(i);
  }
  
  void writeShort(int i) {
    write(i >> 8);
    write(i);
  }
  
  void writeByte aka write(int i) ctex {
    ensureWriteMode();
    outputStream?.write(i);
    byteCounter++;
  }
  
  void writeASCII(char c) {
    write(toASCII(c));
  }
  
  void writeASCII(S s) {
    write(toASCII(s));
  }
  
  // write/verify constant ASCII text
  void exchangeASCII(S s) {
    exchangeConstantBytes(toASCII(s));
  }
  
  void exchangeConstantBytes(byte[] data) {
    for i over data:
      exchangeByte(data[i]);
  }
  
  long readLong() {
    long i = ((long) readInt()) << 32;
    ret i | (readInt() & 0xFFFFFFFFL);
  }
  
  float readFloat() {
    ret Float.intBitsToFloat(readInt());
  }
  
  int readInt() {
    int i = read() << 24;
    i |= read() << 16;
    i |= read() << 8;
    ret i | read();
  }
  
  short readShort() {
    int i = read() << 8;
    ret (short) (i | read());
  }
  
  byte[] readBytes(int n) {
    byte[] data = new[n];
    for i to n: {
      int b = read();
      if (b < 0)
        fail("EOF");
      data[i] = (byte) b; 
    }
    ret data;
  }
  
  S readString() {
    int n = readInt();
    if (eof()) null;
    ret fromUtf8(readBytes(n));
  }
  
  // null is written as empty string
  // writes UTF8 length (4 bytes) plus string as UTF8
  void writeString(S s) {
    byte[] utf8 = toUtf8(unnull(s));
    writeInt(l(utf8));
    write(utf8);
  }
  
  // -1 for EOF
  int readByte aka read() ctex {
    ensureReadMode();
    ++byteCounter;
    int b = inputStream.read();
    if (b < 0) eof = true;
    ret b;
  }
  
  void ensureReadMode {
    if (!readMode) fail("Not in read mode");
  }
  
  void ensureWriteMode {
    if (!writeMode) fail("Not in write mode");
  }
  
  // exchange = read or write depending on mode
  
  void exchangeByte(byte getter, IVF1<Byte> setter) {
    exchangeByte(-> getter, setter);
  }
  
  void exchangeByte(IF0<Byte> getter, IVF1<Byte> setter) {
    if (writeMode())
      writeByte(getter!);
    
    if (readMode())
      setter.get(toUByte(readByte()));
  }
  
  void exchangeShort(IF0<Short> getter, IVF1<Short> setter) {
    if (writeMode())
      writeShort(getter!);
    
    if (readMode())
      setter.get(readShort());
  }
  
  void exchangeLong(IVar<Long> var) {
    exchangeLong(var.getter(), var.setter());
  }
  
  void exchangeLong(IF0<Long> getter, IVF1<Long> setter) {
    if (writeMode())
      writeLong(getter!);

    if (readMode())
      setter.get(readLong());
  }
  
  void exchangeByte(byte i) {
    exchangeByte(-> i, j -> assertEquals(i, j));
  }
  
  void exchangeInt(int i) {
    exchangeInt(-> i, j -> assertEquals(i, j));
  }
  
  void exchangeInt(IF0<Int> getter, IVF1<Int> setter) {
    if (writeMode())
      writeInt(getter!);

    if (readMode())
      setter.get(readInt());
  }
  
  void exchange(ByteIO writable) {
    if (writable != null) writable.readWrite(this);
  }
  
  void exchangeAll(Iterable<? extends ByteIO> writables) {  
    if (writables != null)
      for (writable : writables)
        exchange(writable);
  }
  
  // write size in bytes of element first (as int),
  // then the element itself.
  // upon reading, size is actually ignored.
  void exchangeWithSize(ByteIO writable) {
    if (writeMode()) {
      byte[] data = writable.saveToByteArray();
      writeInt(l(data));
      write(data);
    }
    
    if (readMode()) {
      int n = readInt();
      writable.readWrite(this);
    }
  }
  
  void finish {}
  
  public void close() {
    main close(inputStream);
    main close(outputStream);
    finish();
  }
}