fn pub static new -> Values {
  Values(Map.new)
}

fn pub static parse[B: Bytes](input: ref B) -> Option[Values] {
  let map = Values.new

  for chunk in Slice.new(input, 0, input.size).split('&') {
    if chunk.empty? { next }

    match chunk.split_once('=') {
      case Some((lhs, rhs)) -> {
        let key = try parse_query(lhs)
        let val = try parse_query(rhs)

        map.add(key.into_string, val)
      }
      case _ -> {
        let key = try parse_query(chunk)

        map.add(key.into_string, ByteArray.new)
      }
    }
  }

  Option.Some(map)
}

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

fn pub ==(other: ref Values) -> Bool {
  @map == other.map
}

fn pub mut add[B: Bytes](name: String, value: ref B) {
  let value = value.to_byte_array

  match @map.try_set(name, QueryValue.Single(value)) {
    case Error((name, Single(_), Single(new))) -> {
      let ex = match @map.remove(name) {
        case Ok(Single(v)) -> v
        case _ -> panic('unreachable')
      }

      @map.set(name, QueryValue.Multiple([ex, new]))
    }
    case Error((_, Multiple(ex), Single(new))) -> ex.push(new)
    case _ -> {}
  }
}

fn pub mut clear {
  @map.clear
}

fn pub clone -> Self {
  Self(@map.clone)
}

fn pub encode(into: mut ByteArray) {
  let mut pairs = 0

  for (key, val) in @map.iter {
    match val {
      case Single(v) -> {
        if pairs > 0 { into.push(AMP) }

        encode_query_pair_into(key, v, into)
        pairs += 1
      }
      case Multiple(vals) -> {
        for val in vals.iter {
          if pairs > 0 { into.push(AMP) }

          encode_query_pair_into(key, val, into)
          pairs += 1
        }
      }
    }
  }
}

fn pub fmt(formatter: mut Formatter) {
  formatter.object('Values').field('map', @map).finish
}

fn pub get(name: String) -> Result[ref ByteArray, MissingKey[String]] {
  match value(name) {
    case Ok(Single(v)) -> Result.Ok(v)
    case Ok(Multiple(v)) -> Result.Ok(v.get(0).or_panic)
    case _ -> Result.Error(MissingKey.new(name))
  }
}

fn pub get_all(name: String) -> Stream[ref ByteArray] {
  match @map.get(name) {
    case Ok(Single(v)) -> {
      let mut done = false

      Stream.new(fn move {
        if done := true { Option.None } else { Option.Some(v) }
      })
    }
    case Ok(Multiple(v)) -> v.iter
    case _ -> Stream.new(fn move { Option.None })
  }
}

fn pub keys -> Stream[String] {
  @map.keys
}

fn pub mut remove[B: Bytes](name: String, value: ref B) {
  let rm = match @map.get_mut(name) {
    case Ok(Single(v)) -> v.equals?(value)
    case Ok(Multiple(v)) -> {
      v.remove_if(fn (v) { v.equals?(value) })
      v.empty?
    }
    case _ -> false
  }

  if rm { @map.remove(name) }
}

fn pub mut remove_all(name: String) {
  @map.remove(name)
}

fn pub inline size -> Int {
  @map.size
}

fn pub string(name: String) -> Result[String, MissingKey[String]] {
  match get(name) {
    case Ok(v) -> Result.Ok(v.to_string)
    case Error(e) -> Result.Error(e)
  }
}

fn pub to_query -> Query {
  Query(to_string)
}

fn pub to_string -> String {
  let buf = ByteArray.new

  encode(buf)
  buf.into_string
}

fn pub value(name: String) -> Result[ref QueryValue, MissingKey[String]] {
  @map.get(name)
}