///|
priv struct PatchHeap {
  objects : Array[Bytes]
  data : Bytes
}

///|
fn patch_unique_heap_objects(
  values : Array[Bytes],
) -> Array[Bytes] raise Hdf5Error {
  let objects : Array[Bytes] = []
  for item in values {
    if item.length() > 0 && !objects.contains(item) {
      guard objects.length() < 65535 else {
        raise UnsupportedFeature(
          "variable-length values have too many heap objects",
        )
      }
      objects.push(item)
    }
  }
  objects
}

///|
fn encode_patch_heap(
  objects : Array[Bytes],
  length_size : Int32,
) -> PatchHeap raise Hdf5Error {
  if objects.length() == 0 {
    return { objects, data: b"", }
  }
  guard length_size >= 1 && length_size <= 8 else {
    raise UnsupportedFeature("unsupported global heap length size")
  }
  let header_size = 8 + length_size
  let object_header_size = 8 + length_size
  let mut used_size = header_size
  for item in objects {
    let length = item.length()
    guard length >= 0 && length <= 0x7FFFFFFF else {
      raise InvalidField("variable-length heap object is too large")
    }
    guard used_size <=
      0x7FFFFFFF - object_header_size - round_up_to_eight(length) else {
      raise UnsupportedFeature("variable-length heap is too large")
    }
    used_size = used_size + object_header_size + round_up_to_eight(length)
  }
  guard used_size.to_int64() + object_header_size.to_int64() <=
    0x7FFFFFFFL - 4095L else {
    raise UnsupportedFeature("variable-length heap is too large")
  }
  let collection_size = (used_size + object_header_size + 4095) / 4096 * 4096
  let buffer = @buffer.Buffer::Buffer(size_hint=collection_size)
  writer_write_bytes(buffer, b"GCOL")
  buffer.write_byte(b'\x01')
  writer_write_zeros(buffer, 3)
  write_uint_width(buffer, collection_size.to_uint64(), length_size)
  let mut object_index = 0
  for item in objects {
    object_index = object_index + 1
    buffer.write_uint16_le(object_index.to_uint16())
    buffer.write_uint16_le(0)
    buffer.write_uint_le(0U)
    write_uint_width(buffer, item.length().to_uint64(), length_size)
    writer_write_bytes(buffer, item)
    writer_write_zeros(buffer, round_up_to_eight(item.length()) - item.length())
  }
  buffer.write_uint16_le(0)
  buffer.write_uint16_le(0)
  buffer.write_uint_le(0U)
  write_uint_width(
    buffer,
    (collection_size - used_size).to_uint64(),
    length_size,
  )
  writer_write_zeros(buffer, collection_size - buffer.length())
  guard buffer.length() == collection_size else {
    raise InvalidField("variable-length heap size mismatch")
  }
  { objects, data: buffer.to_bytes(), }
}

///|
fn patch_vlen_string_charset_valid(value : String, charset : Int32) -> Bool {
  let encoded = @utf8.encode(value)
  if charset == 0 {
    for index in 0..= 128 {
        return false
      }
    }
  }
  true
}

///|
fn Hdf5File::encode_patch_vlen_values(
  self : Hdf5File,
  values : Hdf5WriteValues,
  datatype : Datatype,
  offset_size : Int32,
  length_size : Int32,
  base_address : UInt64,
  file_length : Int32,
  tail : @buffer.Buffer,
  purpose : String,
) -> Bytes raise Hdf5Error {
  guard datatype.class == 9 else {
    raise UnsupportedFeature("only variable-length values can be patched")
  }
  let items : Array[DatasetValue] = if datatype.vlen_is_string {
    let strings = match values {
      VariableStringValues(items) => items
      _ =>
        raise InvalidArgument("patched values must be variable-length strings")
    }
    let converted : Array[DatasetValue] = []
    for item in strings {
      converted.push(Text(item))
    }
    converted
  } else {
    match values {
      StructuredValues(_, items) => items
      _ =>
        raise InvalidArgument(
          "patched values must be variable-length sequences",
        )
    }
  }
  let heap_start = next_aligned_tail_start(file_length, tail.length(), purpose)
  let heap_address = file_offset_to_stored_address(heap_start, base_address)
  let heap : PatchHeap = { objects: [], data: b"", }
  let payload = @buffer.Buffer::Buffer(size_hint=items.length() * datatype.size)
  for item in items {
    writer_write_bytes(
      payload,
      self.encode_patch_structured_reference_value(
        datatype, item, heap, heap_address, offset_size, 0,
      ),
    )
  }
  let bytes = payload.to_bytes()
  guard bytes.length() == items.length() * datatype.size else {
    raise InvalidField("variable-length payload size mismatch")
  }
  let encoded_heap = encode_patch_heap(heap.objects, length_size)
  if encoded_heap.data.length() > 0 {
    let start = append_aligned_bytes_to_tail(
      tail,
      file_length,
      encoded_heap.data,
      purpose,
    )
    guard start == heap_start else {
      raise InvalidField("variable-length heap address changed while encoding")
    }
  }
  bytes
}