// all sizes+addresses are in ints (4 bytes)

// For a full persistent solution, see PersistentManagedObjects_v1

// TODO:

//   -during GC collection, forbid writes from all users except GC itself

//   -during GC compaction, forbid reads and writes from all users except GC

sclass ManagedIntObjects_v1 implements IIntMemory {

  replace Addr with int.

  replace BoxedAddr with Int.

  int[] mem = new int[0];

  new FreeList freeList;

  bool collecting, compacting; // GC phases

  *() {

    assertEquals(0, alloc(reservedSpaceAtBeginning())); // so 0 is usable as the null pointer

  }

  *(int[] *mem) {}

  // 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");

    print("New memory size: " + newSize);

    mem = resizeIntArray(mem, newSize);

    free(size, newSize-size);

    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) {

      print("No free space for length " + length + " - growing");

      growMemory();

    }

    freeList.remove(IntRange(r.start, r.start+length));

    ret r.start;

  }

  void free(int start, int length) {

    if (length == 0) ret;

    deb()?.print("Freeing " + start + " (l=" + length + ")");

    freeList.add(IntRange(start, start+length));

    fillMem(start, start+length, 0);

  }

  void fillMem(int start, int end, int value) {

    Arrays.fill(mem, start, end, value);

  }

  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) {

    deb()?.printVars("newIntArray", +size);

    Addr a = alloc(size+1);

    set(a, size);

    ret a;

  }

  void freePointerArray aka freeIntArray(Addr a) {

    if (a == 0) ret;

    deb()?.print("freePointerArray at " + a);

    free(a, read(a)+1);

  }

  Addr newIntArray(int[] array) {

    if (array == null) ret 0;

    int n = l(array);

    deb()?.printVars("newIntArray", +n);

    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) {

    deb()?.printVars("resizePointerArray", +a, +newSize);

    if (a == 0) ret newPointerArray(newSize);

    int oldSize = get(a);

    if (oldSize == newSize) ret a;

    Addr a2 = realloc(a, oldSize+1, newSize+1);

    set(a2, newSize);

    ret a2;

  }

  // a can be nullPtr(), then we just make a new array

  Addr realloc(Addr a, int oldSize, int newSize) {

    deb()?.printVars("realloc", +a, +oldSize, +newSize);

    if (a == 0) ret alloc(newSize);

    if (oldSize == newSize) ret a;

    if (oldSize > newSize) {

      free(a+newSize, oldSize-newSize);

      ret a;

    }

    // newSize is bigger than oldSize

    // Try growing.

    IntRange r = new(a+oldSize, a+newSize);

    if (freeList.canRemove(r)) {

      // Great! Grow it and we're done

      deb()?.print("Chunk grown");

      freeList.remove(r);

      ret a;

    }

    // We have to move the whole thing

    deb()?.printVars("realloc copy", +newSize);

    Addr a2 = alloc(newSize);

    memCopy(a, a2, oldSize);

    deb()?.printVars("realloc free old, returning", +a2);

    free(a, oldSize);

    ret a2;

  }

  void memCopy(int src, int dest, int n) {

    arraycopy(mem, src, mem, dest, n);

  }

  // 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 copyReservedArea(int[] newMem) { newMem[0] = get(0); }

  void collectAndCompact(IManagedObject rootObject, ManagedIntObjects_v1_Collector collector default new ManagedIntObjects_v1_Collector(this)) {

    collecting = true;

    if (rootObject != null)

      rootObject.scanForCollection(collector);

    compacting = true;

    collector.collectAndCompact();

    compacting = false;

    collecting = false;

  }

  bool collecting() { ret collecting; }

  bool compacting() { ret compacting; }

  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;

  }

  Addr newString(S s) {

    if (s == null) ret 0;

    byte[] array = toUtf8(s);

    int[] ints = intArrayFromBytes_littleEndian_flexLength(array);

    Addr ptr = alloc(l(ints)+1);

    for i over ints:

      set(ptr+1+i, ints[i]);

    set(ptr, l(array)^0x80000000);

    ret ptr;

  }

  S readString(Addr addr) {

    if (addr == 0) null;

    int n = get(addr) ^ 0x80000000;

    int[] ints = new[(n+3)/4];

    for i over ints:

      ints[i] = get(addr+1+i);

    byte[] bytes = intArrayToBytes_littleEndian_flexLength(ints, n);

    ret fromUtf8(bytes);

  }

  // cycle from "disk" (memory)

  selfType rotate() {

    ret new ManagedIntObjects_v1(mem);

  }

}