fn pub static from_pointer(pointer: Pointer[UInt8]) -> String {
  inko_string_from_pointer(_INKO.state, pointer)
}

fn pub static join[T: ToString, I: Iter[T]](
  iter: move I,
  with: String,
) -> String {
  let result = iter.reduce(StringBuffer.new, fn (buff, val) {
    if buff.size > 0 { buff.push(with) }

    buff.push(val.to_string)
    buff
  })

  result.to_string
}

fn pub !=(other: T) -> Bool {
  (self == other).false?
}

fn pub +(other: ref String) -> String {
  _INKO.string_concat(self, other)
}

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

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

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

  if size != other.size { return false }

  let mut idx = 0

  while idx < size {
    if byte_unchecked(idx) != other.byte_unchecked(idx) { return false }

    idx += 1
  }

  true
}

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

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

fn pub byte(index: Int) -> Int {
  bounds_check(index, size)
  byte_unchecked(index)
}

fn pub byte_index(of: String, 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 = of.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 byte(a + b) == of.byte(b) { b += 1 }

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

    a += 1
  }

  Option.None
}

fn pub bytes -> Stream[Int] {
  let mut idx = 0
  let max = size

  Stream.new(fn move {
    if idx < max { Option.Some(byte(idx := idx + 1)) } else { Option.None }
  })
}

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

fn pub 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: ref String) -> Bool {
  byte_index(of: value, starting_at: 0).some?
}

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

fn pub ends_with?(suffix: String) -> Bool {
  byte_index(of: suffix, starting_at: size - suffix.size).some?
}

fn pub escaped -> String {
  let buff = ByteArray.new
  let max = ESCAPE_TABLE.size

  bytes.each(fn (byte) {
    if byte >= max {
      buff.push(byte)
      return
    }

    match ESCAPE_TABLE.get(byte) {
      case -1 -> buff.push(byte)
      case 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 hash[H: mut + Hasher](hasher: mut H) {
  let mut index = 0

  while index < size {
    hasher.write(byte_unchecked(index))
    index += 1
  }
}

fn pub move into_byte_array -> ByteArray {
  to_byte_array
}

fn pub 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 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 byte_index(string, start) {
      case Some(i) -> {
        if i > last { slice_into(buf, start: last, size: i - last) }

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

        break
      }
    }
  }

  buf.into_string
}

fn pub size -> Int {
  @size as Int
}

fn pub slice(start: Int, size: Int) -> ByteArray {
  let bytes = ByteArray.new

  slice_into(bytes, start, size)
  bytes
}

fn pub slice_into(bytes: mut ByteArray, start: Int, size: Int) {
  inko_string_slice_bytes_into(self, bytes, start, size)
}

fn pub split(separator: String) -> Stream[String] {
  let mut offset = 0

  Stream.new(fn move {
    match byte_index(of: separator, starting_at: offset) {
      case Some(at) -> {
        let start = offset := at + separator.size

        Option.Some(slice(start: start, size: at - start).into_string)
      }
      case _ if offset < size -> {
        # No separator found, but we haven't reached the end of the String
        # yet. In this case we return the remaining String.
        let at = offset := size

        Option.Some(slice(start: at, size: size - at).into_string)
      }
      case _ -> Option.None
    }
  })
}

fn pub starts_with?(prefix: String) -> Bool {
  match byte_index(of: prefix, starting_at: 0) {
    case Some(idx) -> idx == 0
    case _ -> false
  }
}

fn pub strip_prefix(prefix: String) -> String {
  if starts_with?(prefix).false? { return clone }

  slice(start: prefix.size, size: size - prefix.size).into_string
}

fn pub strip_suffix(suffix: String) -> String {
  if ends_with?(suffix).false? { return clone }

  slice(start: 0, size: size - suffix.size).into_string
}

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

  self.chars.each_with_index(fn (index, char) {
    if index >= start and buff.size < chars { buff.push(char) }
  })

  buff.into_string
}

fn pub to_byte_array -> ByteArray {
  inko_string_to_byte_array(_INKO.state, self)
}

fn pub to_lower -> String {
  inko_string_to_lower(_INKO.state, self)
}

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

fn pub to_pointer -> Pointer[UInt8] {
  @bytes
}

fn pub to_string -> String {
  clone
}

fn pub to_upper -> String {
  inko_string_to_upper(_INKO.state, self)
}

fn pub trim -> String {
  let max = size
  let mut start = 0
  let mut end = max - 1

  while start < max {
    if whitespace?(byte(start)) { start += 1 } else { break }
  }

  while end >= 0 {
    if whitespace?(byte(end)) { end -= 1 } else { break }
  }

  slice(start: start, size: end + 1 - start).into_string
}

fn pub trim_end -> String {
  let mut index = size - 1

  while index >= 0 {
    if whitespace?(byte(index)) { index -= 1 } else { break }
  }

  slice(start: 0, size: index + 1).into_string
}

fn pub trim_start -> String {
  let mut index = 0
  let max = size

  while index < max {
    if whitespace?(byte(index)) { index += 1 } else { break }
  }

  slice(start: index, size: size - index).into_string
}