import java.nio.ByteOrder as NioByteOrder

typealias Cnt = Int
typealias Idx = Int
typealias IdxRange = IntRange
typealias Buffer = ByteArray

infix fun IdxRange.untilSize(size: Cnt): IdxRange = this until (this+size) //0 until (0+10): 0..9
inline val IdxRange.size: Cnt get() = (last - first).inc() //0..0: (0-0)+1

typealias Nat8 = Int
typealias Nat16 = Int
typealias Char16 = Char

typealias Int8 = Byte
typealias Int16 = Short
typealias Int32 = Byte
typealias Int64 = Byte

typealias Rat32 = Float
typealias Rat64 = Double

interface MarkReset { fun mark() fun reset() }
fun <R> MarkReset.positional(op: Producer<R>): R
fun positionalTask(): Closeable //JVM

interaface ReadControl: MarkReset, Closeable {
  val position: Cnt; val estimate: Cnt
  fun skip(n: Cnt)
}
override tailrec fun seek(n: LongCnt) {
  if (n == 0L) return //EOS
  val skipped = this.skip(n)
  if (skipped != 0L) seek(n - skipped)
} // for JVM InputStream
override var position: Idx = 0
  protected set // for JVM InputStream

interface WriteControl: Flushable, Closeable

interface ByteReader {
  fun readByte(): Byte
  fun readTo(destination: Buffer, indices: IdxRange)
  fun readToFill(destination: Buffer)
  fun takeBytes(count: Cnt): Buffer
}
interface ByteWriter {
  fun writeByte(b: Byte)
  fun writeFrom(source: Buffer, indices: IdxRange)
  fun writeAllFrom(source: Buffer)
}

interface DataReader {
  fun readNat8():Nat8 fun readNat16():Nat16
  fun readChar16():Char16
  fun readInt8():Int8 fun readInt16():Int16
  fun readInt32():Int32 fun readInt64():Int64
  fun readRat32():Rat32 fun readRat64():Rat64
}
interface DataWriter {
  fun writeNat8(x:Nat8) fun writeNat16(x:Nat16)
  fun writeChar16(x:Char16)
  fun writeInt8(x:Int8) fun writeInt16(x:Int16)
  fun writeInt32(x:Int32) fun writeInt64(x:Int64)
  fun writeRat32(x:Rat32) fun writeRat64(x:Rat64)
}

enum class ByteOrder { LittleEndian, BigEndian }
interface ByteOrdered { var byteOrder: ByteOrder }
fun systemOrder(): ByteOrder = when (NioByteOrder.nativeOrder()) {
  NioByteOrder.LITTLE_ENDIAN -> ByteOrder.Little
  NioByteOrder.Big_ENDIAN -> ByteOrder.Big
}

abstract class BaseDataReader(private val sourceOrder: ByteOrder): ByteOrdered, DataReader {
  protected val shouldSwap get() = byteOrder != sourceOrder
}

interface Reader: DataReader, ByteReader, ReadControl, ByterOrdered
interface Writer: DataWriter, ByteWriter, WriteControl, ByterOrdered

typealias Shift<I> = I.(Cnt) -> I
typealias ByteSelect<I> = I.(I) -> Byte
typealias ByteUnion<I> = I.(Byte) -> I

1234 -> 1,2,3,4
^popleft(shl(8*n)&and)

inline fun <I> integralToBytes(n: Cnt, byte_left: Byte,
  crossinline shl: Shift<I>, crossinline and: ByteSelect<I>, i: I): Sequence<Byte> = sequence {
  var accumulator = i
  for (_t in 1..n) {
    yield(accumulator.and(byte_left))
    accumulator = accumulator.shl(Byte.SIZE_BITS)
  }
}

1,2,3,4 -> 1234:
(shl&or...&or)^pushright

1,2,3,4 -> 0(zero: I)
1,2,3,4 -> 0 shl 8 or 1
2,3,4 -> 1 shl 8 or 2
3,4 -> 12 shl 8 or 3
...

inline fun <I> bytesToIntegral(zero: I,
  crossinline shl: Shift<I>, crossinline or: ByteUnion<I>, bytes: ByteIterator): I {
  var accumulator = zero
  for (byte in bytes) {
    accumulator = accumulator.shl(Byte.SIZE_BITS).or(byte)
  }
  return accumulator
}

[1,2,3]
mark()
next() //1
next() //2
reset()
next() //1

1,2,3
mark() //[0]
mark() //[0,0]
next() //1
next() //2
reset() //pos=0, [0]
next() // 1
reset() //pos=0, [0]
next() //1

ArrayBuffer(length: Int)

fun getUint32(
    byteOffset: Int,
    littleEndian: Boolean = definedExternally
): Int

  final override var position: Cnt = 0
    private set