// all sizes+addresses are in ints (4 bytes)
// To make this a real persistent solution, TODO:
// -save pointer to "root object" (in address 0?)
// -persist freeList
sclass ManagedIntObjects_v1 implements IIntMemory {
  replace Addr with int.
  replace BoxedAddr with Int.
  
  int[] mem = new int[0];
  new FreeList freeList;
  Addr rootPtrLocation; // always 0
  
  *() {
    rootPtrLocation = alloc(reservedSpaceAtBeginning()); // so 0 is usable as the null pointer
  }
  
  // overridable
  public long size() { ret mem.length; }
  public int get(Addr i) { ret mem[i]; }
  public void set(Addr i, int val) { mem[i] = val; }
  
  swappable void onMemorySizeChanged() {}
  
  void ensureCapacity(int size) {
    if (memorySize() < size)
      setMemorySize(roundUpToPowerOfTwo(size));
  }
  
  void setMemorySize(int newSize) {
    int size = memorySize();
    if (newSize == size) ret;
    if (newSize < size) unimplemented("Shrinking memory");
    freeList.add(IntRange(size, newSize));
    mem = resizeIntArray(mem, newSize);
    onMemorySizeChanged();
  }
  
  void growMemory() {
    setMemorySize(max(1, memorySize()*2));
  }
  
  // all allocated ranges are filled with zero
  int alloc(int length) {
    IntRange r;
    while ((r = freeList.findFreeSpace(length)) == null)
      growMemory();
    
    freeList.remove(IntRange(r.start, r.start+length));
    ret r.start;
  }
  
  void free(int start, int length) {
    if (length == 0) ret;
    freeList.add(IntRange(start, start+length));
    Arrays.fill(mem, start, start+length, 0);
  }
  
  final int memorySize() { ret mem.length; }
  final public int read(Addr i) { ret get(i); }
  final void write(Addr i, int val) { set(i, val); }
  
  // words a pointer requires
  int sizeOfPointer() { ret 1; }
  int wordSizeInBytes() { ret 4; }
  
  public Addr nullPtr() { ret 0; }
  
  // convenience pointer array handling (memory layout: length + data)
  
  L<BoxedAddr> pointerArray(Addr addr) {
    if (addr == 0) null;
    int size = get(addr);
    ret new RandomAccessAbstractList<BoxedAddr>() {
      public int size() { ret size; }
      public BoxedAddr get(int i) { rangeCheck(i, size); ret read(addr+1+i); }
      public Int set(int i, Int val) { rangeCheck(i, size); Int old = get(i); write(addr+1+i, val); ret old; }
    };
  }
  
  Addr newPointerArray(int size) {
    Addr a = alloc(size+1);
    set(a, size);
    ret a;
  }
  
  void freePointerArray aka freeIntArray(Addr a) {
    if (a != 0) free(a, read(a)+1);
  }
  
  Addr newIntArray(int[] array) {
    if (array == null) ret 0;
    int n = l(array);
    Addr ptr = alloc(n+1);
    set(ptr, n);
    for i to n:
      set(ptr+1+i, array[i]);
    ret ptr;
  }
  
  // a can be nullPtr(), then we just make a new array
  Addr resizePointerArray(Addr a, int newSize) {
    ifdef ManagedIntObjects_v1_debug
    printFunctionCall resizePointerArray(a, newSize);
    endifdef
    if (a == 0) ret newPointerArray(newSize);
    int oldSize = get(a);
    if (oldSize == newSize) ret a;
    Addr a2 = newPointerArray(newSize);
    arraycopy(mem, a+1, mem, a2+1, min(oldSize, newSize));
    ret a2;
  }
  
  // even more convenient typed object array handling as List
  
  <A extends AbstractManagedObject> L<A> objectArray(Addr addr,
    IF1<BoxedAddr, A> wrapPointer) {
    ret convertListElementsBothWays(
      wrapPointer,
      element -> element.addr,
      pointerArray(addr));
  }
  
  int totalFree() { ret freeList.totalFree(); }
  
  int reservedSpaceAtBeginning() { ret 1; }
  
  void collectAndCompact(IManagedObject rootObject) {
    ManagedIntObjects_v1_Collector collector = new(this);
    if (rootObject != null)
      rootObject.scanForCollection(collector);
    collector.collectAndCompact();
  }
  
  void printStats {
    print("Managed memory size: " + toM(size()*(long) wordSizeInBytes()) + " MB, free: " + ratioToIntPercent(freeList.totalFree(), size()) + "%");
  }
  
  // +1, actually
  int highestUsedWord() {
    IntRange r = freeList.highestFreeRange();
    ret r != null && r.end == size() ? r.start : (int) size();
  }
  
  void saveToFile(File f) {
    // only save used part
    stream2file(IntArrayInputStream_littleEndian(mem, 0, highestUsedWord()), f);
    printFileInfo(f);
  }
  
  // we use the reserved int for a user-defined value to bootstrap
  // the system
  void setRootField(int val) {
    set(0, val);
  }
  
  int getRootField() {
    ret get(0);
  }
  
  int[] readIntArray(BoxedAddr ptr) {
    if (ptr == 0) null;
    int n = mem[ptr++];
    int[] a = new[n];
    arraycopy(mem, ptr, a, 0, n);
    ret a;
  }
}