fn pub static from_pointer(pointer: Pointer[UInt8]) -> String {
  if pointer as Int == 0 { return '' }

  from_primitive(inko_string_from_pointer(pointer))
}

fn pub static join[T: ToString, I: Iter[T]](
  iter: move I,
  with: String,
) -> String {
  let buf = StringBuffer.new

  for (idx, val) in iter.with_index {
    if idx > 0 { buf.push(with) }

    buf.push(val.to_string)
  }

  buf.into_string
}

fn pub static try_from_bytes[B: Bytes](bytes: ref B) -> Option[String] {
  let len = bytes.size

  if len == 0 { return Option.Some('') }

  let prim = inko_string_try_from_bytes(bytes.pointer, len)

  if prim.size > -1 {
    Option.Some(from_borrowed_primitive(prim))
  } else {
    Option.None
  }
}

fn pub !=(other: ref Self) -> Bool {
  !(self == other)
}

fn pub inline +(other: String) -> String {
  let tot = size + other.size
  let new = alloc.allocate(tot + 1)

  alloc.copy(from: pointer, to: new, size: size)
  alloc.copy(from: other.pointer, to: ptr.add(new, size), size: other.size)
  alloc.write(byte: 0, to: ptr.add(new, tot), size: 1)
  String(size: tot, ptr: new)
}

fn pub <(other: ref Self) -> Bool {
  match cmp(other) {
    case Less -> true
    case _ -> false
  }
}

fn pub <=(other: ref Self) -> Bool {
  match cmp(other) {
    case Less or Equal -> true
    case _ -> false
  }
}

fn pub ==(other: String) -> Bool {
  let lsize = self.size

  if lsize == other.size { ptr.equal(@ptr, other.ptr, lsize) } else { false }
}

fn pub >(other: ref Self) -> Bool {
  match cmp(other) {
    case Greater -> true
    case _ -> false
  }
}

fn pub >=(other: ref Self) -> Bool {
  match cmp(other) {
    case Greater or Equal -> true
    case _ -> false
  }
}

fn pub bytes -> Iter[ref Self] {
  Iter(source: self, index: 0)
}

fn pub inline chars -> Chars {
  Chars(string: self, iter: inko_string_chars(to_primitive))
}

fn pub inline clone -> String {
  self
}

fn pub cmp(other: String) -> Ordering {
  let mut max = min(size, other.size)
  let mut idx = 0

  while idx < max {
    match byte_unchecked(idx).cmp(other.byte_unchecked(idx)) {
      case Equal -> idx += 1
      case ord -> return ord
    }
  }

  size.cmp(other.size)
}

fn pub contains?(value: String) -> Bool {
  contains_bytes?(value)
}

fn pub contains_bytes?[B: Bytes](bytes: ref B) -> Bool {
  index_of(bytes, starting_at: 0).some?
}

fn pub empty? -> Bool {
  size == 0
}

fn pub ends_with?[T: Bytes](suffix: ref T) -> Bool {
  ptr.ends_with?(pointer, size, suffix.pointer, suffix.size)
}

fn pub equals?[O: Bytes](other: ref O) -> Bool {
  let len = size

  len == other.size and (len == 0 or ptr.equal(pointer, other.pointer, len))
}

fn pub equals_while_ignoring_case?[O: Bytes](other: ref O) -> Bool {
  let len = size

  if len == 0 { return true }

  if len != other.size { return false }

  let lhs = pointer
  let rhs = other.pointer
  let mut idx = 0

  # Since we have to convert ASCII bytes to lowercase (when necessary) we
  # can't use a more efficient comparison and instead have to compare the data
  # byte by byte.
  while idx < len {
    let mut a = ptr.add(lhs, idx).0 as Int
    let mut b = ptr.add(rhs, idx).0 as Int

    if upper?(a) { a = to_lower(a) }

    if upper?(b) { b = to_lower(b) }

    if a != b { return false }

    idx += 1
  }

  true
}

fn pub escaped -> String {
  # If the String doesn't contain any special characters then we can/should
  # avoid the allocations that take place below.
  if !escape? { return self }

  let buff = ByteArray.new
  let mut i = 0

  while i < size {
    let byte = byte_unchecked(i := i + 1)

    match ESCAPE_TABLE.get(byte) {
      case Ok(-1) or Error(_) -> buff.push(byte)
      case Ok(byte) -> {
        buff.push(BSLASH)
        buff.push(byte)
      }
    }
  }

  buff.into_string
}

fn pub fmt(formatter: mut Formatter) {
  formatter.write('"')
  formatter.write(escaped)
  formatter.write('"')
}

fn pub inline get(index: Int) -> Result[Int, OutOfBounds] {
  try check_bounds(index, size)
  Result.Ok(byte_unchecked(index))
}

fn pub hash[H: mut + Hasher](hasher: mut H) {
  hash_bytes(self, hasher)
}

fn pub index_of[B: Bytes](value: ref B, starting_at: Int) -> Option[Int] {
  # This is a naive string searching algorithm (see
  # https://en.wikipedia.org/wiki/String-searching_algorithm) for more details
  # on the various algorithms.
  #
  # We're using the naive algorithm because:
  #
  # 1. It's easy to implement
  # 2. It doesn't require any pre-processing
  # 3. At the time of writing there was no need for something more performant
  let find_size = value.size

  if find_size == 0 or size == 0 or find_size > size { return Option.None }

  let mut a = starting_at
  let max = size - find_size

  while a <= max {
    let mut b = 0

    while b < find_size and get(a + b) == value.get(b) { b += 1 }

    if b == find_size { return Option.Some(a) }

    a += 1
  }

  Option.None
}

fn pub inline move into_byte_array -> ByteArray {
  to_byte_array
}

fn pub inline move into_string -> String {
  self
}

fn pub pad_end(with: String, chars: Int) -> String {
  self + padding(with, chars: self.chars.count, pad_to: chars)
}

fn pub pad_start(with: String, chars: Int) -> String {
  padding(with, chars: self.chars.count, pad_to: chars) + self
}

fn pub inline pointer -> Pointer[UInt8] {
  @ptr
}

fn pub repeat(times: Int) -> String {
  match times {
    case 0 -> ''
    case 1 -> self
    case _ -> {
      let buf = StringBuffer.new

      times.times(fn (_) { buf.push(clone) })
      buf.into_string
    }
  }
}

fn pub replace(string: String, with: String) -> String {
  # Different languages handle the pattern being empty differently. For
  # example, Javascript and Node only match the start of the string if the
  # pattern is empty. Other languages such as Ruby and Python appear to inject
  # the replacement in between every character, such that
  # `'AB'.replace('', ',')` results in `,A,B,`.
  #
  # We make the decision to just _not_ do any replacements in this case, as
  # replacing an empty string is nonsensical to begin with.
  if string.size == 0 { return self }

  let buf = ByteArray.new
  let mut start = 0
  let mut last = 0

  loop {
    match index_of(string, start) {
      case Some(i) -> {
        if i > last { buf.append(slice(start: last, end: i)) }

        buf.append(with.slice(start: 0, end: with.size))
        start = i + string.size
        last = start
      }
      case _ -> {
        if start < size { buf.append(slice(start: start, end: size)) }

        break
      }
    }
  }

  buf.into_string
}

fn pub inline scalars -> Scalars[Self] {
  Scalars.new(self)
}

fn pub inline size -> Int {
  @size
}

fn pub slice(start: Int, end: Int) -> Slice[Self] {
  Slice.checked(self, start, end)
}

fn pub split(separator: String) -> Stream[Slice[String]] {
  Slice.new(self, 0, size).split(separator)
}

fn pub split_once(
  separator: String,
) -> Option[(Slice[String], Slice[String])] {
  Slice.new(self, 0, size).split_once(separator)
}

fn pub starts_with?[T: Bytes](prefix: ref T) -> Bool {
  ptr.starts_with?(pointer, size, prefix.pointer, prefix.size)
}

fn pub strip_prefix(prefix: String) -> Option[String] {
  if !starts_with?(prefix) { return Option.None }

  if size == prefix.size {
    Option.Some('')
  } else {
    Option.Some(slice(start: prefix.size, end: size).to_string)
  }
}

fn pub strip_suffix(suffix: String) -> Option[String] {
  if !ends_with?(suffix) { return Option.None }

  Option.Some(slice(start: 0, end: size - suffix.size).to_string)
}

fn pub substring(start: Int, end: Int) -> String {
  let buff = StringBuffer.new

  for (index, char) in self.chars.with_index {
    if index >= end { break } else if index >= start { buff.push(char) }
  }

  buff.into_string
}

fn pub inline to_byte_array -> ByteArray {
  let bytes = ByteArray.new
  let _ = bytes.append(self)

  bytes
}

fn pub inline to_lower -> String {
  String.from_primitive(inko_string_to_lower(to_primitive))
}

fn pub inline to_path -> Path {
  Path.new(self)
}

fn pub to_slice -> Slice[Self] {
  Slice.new(self, 0, size)
}

fn pub inline to_string -> String {
  clone
}

fn pub inline to_upper -> String {
  String.from_primitive(inko_string_to_upper(to_primitive))
}

fn pub trim -> String {
  Slice.new(self, 0, size).trim.to_string
}

fn pub trim_end -> String {
  Slice.new(self, 0, size).trim_end.to_string
}

fn pub trim_start -> String {
  Slice.new(self, 0, size).trim_start.to_string
}