#import "LibC.core"

Array :: struct($T: Type)
  data: *T
  len: int
  cap: int

Pop :: (a: *Array($T)): T
  if a.len > 0
    a.len -= 1
    return a.data[a.len]
  // @reproduction: c compile error, probably because of compound expression (Array){}
  // return {}

  result: T
  return result

Contains :: (a: *Array($T), item: *T): bool
  result := item >= a.data && item < a.data + a.len
  return result

Free :: (a: *Array($T))
  free(a.data)
  a.cap = 0; a.len = 0; a.data = 0

Reset :: (a: *Array($T))
  a.len = 0

GetIndex :: (a: *Array($T), item: *T): int
  Assert(a.len > 0)
  Assert(item >= a.data && item < a.data + a.len)

  // @reproduction: compiler hangs
  // index := (item - a.data)->*void->size_t
  index := (item - a.data)->int
  Assert(index >= 0 && index < a.len)
  return index

UnorderedRemove :: (a: *Array($T), item: *T)
  Assert(a.len > 0)
  Assert(item >= a.data && item < a.data + a.len)

  *item = a.data[--a.len]

OrderedRemove :: (a: *Array($T), item: *T)
  index := GetIndex(a, item)
  if index == a.len - 1
    Pop(a)
    return

  length_right_of_item := (a.len - index - 1)->size_t
  memmove(a.data + index, a.data + index + 1, length_right_of_item * SizeOf(T))
  a.len -= 1


TryGrowing :: (a: *Array($T))
  if a.cap == 0
    a.cap = 16
    a.data = malloc(SizeOf(T) * a.cap->size_t)
  if a.len + 1 > a.cap
    a.cap *= 2
    a.data = realloc(a.data, SizeOf(T) * a.cap->size_t)


Add :: (a: *Array($T), item: T)
  TryGrowing(a)
  a.data[a.len++] = item

Reserve :: (a: *Array($T), size: int)
  Assert(size > a.cap)
  a.cap = size
  p := realloc(a.data, SizeOf(T) * a.cap->size_t)
  Assert(p != 0)
  a.data = p