!include once #1027304 // Eclipse Collections

// Note: Pointers can't point _inside_ of objects

sclass ManagedIntObjects_v1_Collector implements IManagedObjectCollector {
  ManagedIntObjects_v1 mem;
  CompactTreeSet<IntRange> objects = new(intRangeComparatorByStart());
  new IntHashSet pointers;
  new LongHashSet pointerRanges; // IntRanges as longs
  new IntIntHashMap relocationMap;
  int[] newMem;
  int startAddress; // 1 normally, 0 for PersistentManagedObjects_v1
  
  // if object at key moves, send new address to the callbacks
  new MultiMap<Int, IVF1<Int>> relocationCallbacks;

  bool discardFreeListEarly; // saves memory, but ironically makes original memory unusable when compacting fails because of OOM
  bool verbose = true;
  
  *(ManagedIntObjects_v1 *mem) {}
  
  // notify collector that there is an object in a location
  public void noteObject(int start, int size, IVF1<Int> updateAddress default null) {
    deb()?.printVars("noteObject", +start, +size);
    objects.add(intRange(start, start+size));
    if (updateAddress != null)
      relocationCallbacks.put(start, updateAddress);
  }
  
  // notify collector that there is a pointer in a location
  public void notePointer(int addr, IVF1<Int> updateAddress) {
    if (addr != 0) {
      pointers.add(addr);
      int target = mem.get(addr);
      if (target != 0 && updateAddress != null)
        relocationCallbacks.put(target, updateAddress);
    }
  }
  
  public void noteRootPointer(int addr) {
    deb()?.printVars("noteRootPointer", +addr, pointingTo := mem.get(addr));
    pointers.add(addr);
  }
  
  // notify collector that there is a pointer array in a location
  public void notePointerArray(int start) {
    if (start == 0) ret;
    int n = mem.get(start);
    noteObject(start, n+1);
    notePointerRange(IntRange(start+1, start+1+n));
  }
  
  // notify collector that there is an int array in a location
  public void noteIntArray(int start) {
    if (start == 0) ret;
    int n = mem.get(start);
    noteObject(start, n+1);
  }
  
  void notePointerRange(IntRange r) {
    pointerRanges.add(intRangeToLong(r));
  }
  
  int sizeNeeded() {
    ret mem.reservedSpaceAtBeginning()+totalIntRangesLength_int(objects);
  }
  
  void collectAndCompact() {
    int sizeNeeded = sizeNeeded();
    if (mem.size() == sizeNeeded) ret;
    
    if (discardFreeListEarly) mem.freeList.clear();
    
    // reserve new memory
    print("Reserving " + toM(sizeNeeded*(long) mem.wordSizeInBytes()) + " MB");
    newMem = new int[sizeNeeded];

    // copy all the objects, fill relocationMap
    print("Copying " + nObjects(objects) + " (" + n2(l(relocationCallbacks), "callback") + ")");
    int freePtr = startAddress;
    
    for (IntRange r : objects) {
      int oldObjectStart = r.start, newObjectStart = freePtr;
      if (oldObjectStart != newObjectStart) {
        relocationMap.put(oldObjectStart, newObjectStart);
        L<IVF1<Int>> callbacks = relocationCallbacks.get(oldObjectStart);
        deb()?.printVars("Moving object", +r, +oldObjectStart, +newObjectStart, +callbacks);
        callFAll(callbacks, newObjectStart);
      } else {
        //printVars("Keeping object", +r);
      }
      arraycopy(mem.mem, oldObjectStart, newMem, newObjectStart, r.length());
      freePtr += r.length();
    }
    relocationCallbacks.clear();
    
    // update the pointers
    print("Updating " + n2(pointers.size(), "pointer"));
    IntIterator itPointers = pointers.intIterator();
    while (itPointers.hasNext())
      movePointer(itPointers.next());
      
    print("Updating " + n2(pointerRanges.size(), "pointer range"));
    var itPointerRanges = pointerRanges.longIterator();
    while (itPointerRanges.hasNext()) {
      IntRange r = longToIntRange(itPointerRanges.next());
      for (int i = r.start; i < r.end; i++)
        movePointer(i);
    }

    print("Managed GC done");
    mem.mem = newMem;
    if (!discardFreeListEarly) mem.freeList.clear();
  }
  
  // call after collectAndCompact to get new location of objects
  public int getNewLocation(int addr) {
    ret relocationMap.getIfAbsent(addr, addr);
  }
  
  void movePointer(int pointerAddr) {
    // find enclosing object
    IntRange obj = objects.floor(IntRange(pointerAddr, pointerAddr));
    if (obj == null) ret with print("Pointer without object: " + pointerAddr);
    
    int newObjAddr = relocationMap.getIfAbsent(obj.start, obj.start);
    int newPointerAddr = newObjAddr-obj.start+pointerAddr;
    
    // find target, update pointer
    int target = mem.get(pointerAddr);
    deb()?.printVars("movePointer", +pointerAddr, +obj, +newObjAddr, +newPointerAddr, +target);
    if (target == 0) ret;
    
    int newTarget = relocationMap.getIfAbsent(target, -1);
    deb()?.printVars("movePointer", +newTarget);
    if (newTarget >= 0)
      newMem[newPointerAddr] = newTarget;
  }
  
  public void noteString(int addr, IVF1<Int> updateAddress default null) {
    if (addr == 0) ret;
    int n = ((mem.get(addr)^0x80000000)+3)/4;
    noteObject(addr, n+1, updateAddress);
  }
}