fn pub static new(reader: T) -> BufferedReader[T] {
  with_capacity(reader, READ_BUFFER_SIZE)
}

fn pub static with_capacity(reader: T, size: Int) -> BufferedReader[T] {
  if size <= 0 { invalid_buffer_size(size) }

  BufferedReader(
    reader: reader,
    buffer: ByteArray.new,
    capacity: size,
    offset: 0,
  )
}

fn pub mut bytes -> Stream[Result[Int, Error]] {
  Stream.new(fn move {
    match read_byte {
      case Ok(Some(num)) -> Option.Some(Result.Ok(num))
      case Ok(None) -> Option.None
      case Error(err) -> Option.Some(Result.Error(err))
    }
  })
}

fn pub mut peek -> Result[Option[Int], Error] {
  match try fill_buffer {
    case 0 -> Result.Ok(Option.None)
    case _ -> Result.Ok(Option.Some(@buffer.get(@offset)))
  }
}

fn pub mut read(into: mut ByteArray, size: Int) -> Result[Int, Error] {
  let mut total = 0

  # If the read size is larger than our buffer, there's no point in buffering
  # as we can just read all data at once (of course taking account the bytes
  # still in the buffer).
  if size > @capacity {
    if @offset < @capacity and @buffer.size > 0 {
      total += read_buffer(into, size)
    }

    return match size - total {
      case 0 -> Result.Ok(total)
      case n -> Result.Ok(total + try @reader.read(into, size: n))
    }
  }

  while total < size {
    if (try fill_buffer) == 0 { break }

    match read_buffer(into, size - total) {
      case 0 -> break
      case n -> total += n
    }
  }

  Result.Ok(total)
}

fn pub mut read_all(bytes: mut ByteArray) -> Result[Int, Error] {
  let mut total = 0
  let mut read_size = INITIAL_READ_ALL_SIZE

  loop {
    match read(into: bytes, size: read_size) {
      case Ok(0) -> return Result.Ok(total)
      case Ok(n) -> {
        total += n

        # To reduce the number of calls to `Reader.read` when there's lots of
        # input to consume, we increase the read size if deemed beneficial.
        if read_size < MAX_READ_ALL_SIZE and n == read_size { read_size *= 2 }
      }
      case Error(e) -> throw e
    }
  }
}

fn pub mut read_byte -> Result[Option[Int], Error] {
  match try fill_buffer {
    case 0 -> Result.Ok(Option.None)
    case _ -> Result.Ok(Option.Some(@buffer.get(@offset := @offset + 1)))
  }
}

fn pub mut read_exact(into: mut ByteArray, size: Int) -> Result[Nil, Error] {
  let mut pending = size

  while pending > 0 {
    match read(into, pending) {
      case Ok(0) if pending > 0 -> throw Error.EndOfInput
      case Ok(n) -> pending -= n
      case Error(e) -> throw e
    }
  }

  Result.Ok(nil)
}

fn pub mut read_line(
  into: mut ByteArray,
  inclusive: Bool,
) -> Result[Int, Error] {
  read_until(byte: 0xA, into: into, inclusive: inclusive)
}

fn pub mut read_until(
  byte: Int,
  into: mut ByteArray,
  inclusive: Bool,
) -> Result[Int, Error] {
  let mut total = 0

  loop {
    match try read_byte {
      case Some(val) if byte == val -> {
        if inclusive { into.push(val) }

        total += 1
        break
      }
      case Some(val) -> {
        total += 1
        into.push(val)
      }
      case _ -> break
    }
  }

  Result.Ok(total)
}