sclass RealmCopy {
  O dest = mc(); // destination realm
  new IdentityHashMap seen;
  new HashMap<Class> classMap;
  new HashMap<Class, L<Field>> fieldsForClass;
  //IF1<S, Class> classFinder = toIF1(_defaultClassFinder());
  bool fullCopy; // descend into objects even when they have the same type
  bool nonTransientOnly; // skip transient fields?
  bool handleEnclosingInstancesProperly; // if false, set enclosing instance to null initially
  
  VStack.Computable copyComputation(O o) {
    ret new CopyObject(o);
  }
  
  O copy(O o) {
    ret evalInVStack(copyComputation(o));
  }
  
  noeq record CopyObject(O o) extends VStackComputableWithStep {
    void step(VStack stack) {
      // null and simple types
      
      if (o == null || o instanceof String || o instanceof Number) {
        ifdef RealmCopy_debug
          print("Simple object: " + o);
        endifdef
        ret with stack.ret(o);
      }
      
      // seen object

      O oo = seen.get(o);
      if (oo != null) stack.ret(oo);
      
      dispatchByType(stack, o);
    }
  }

  void dispatchByType(VStack stack, O o) {  
    if (o cast O[])
      ret with stack.replace(new CopyObjectArray(o));
      
    if (o cast Cl)
      if (!overrideCollectionOrMapCopy(o))
        ret with stack.replace(new CopyCollection(o));
      
    if (o cast Map)
      if (!overrideCollectionOrMapCopy(o))
        ret with stack.replace(new CopyMap(o));
      
    ret with stack.replace(new CopyObjectFieldByField(o));
  }
  
  noeq record CopyObjectArray(O[] o) extends VStackComputableWithStep {
    O[] out;
    int i;
    
    void step(VStack stack) {
      if (step == 0) {
        out = newObjectArrayOfSameType(o);
        seen.put(o, out);
        ++step;
      }
      
      if (stack.hasSubResult())
        out[i++] = stack.subResult();

      if (i >= o.length)
        ret with stack.ret(out);
        
      stack.call(new CopyObject(o[i]));
    }
  }

  noeq record CopyCollection(Cl o) extends VStackComputableWithStep {
    Cl out;
    Iterator it;
    
    void step(VStack stack) {
      if (step == 0) {
        out = similarEmptyCollection(o);
        seen.put(o, out);
        it = iterator(o);
        ++step;
      }
      
      if (stack.hasSubResult())
        out.add(stack.subResult());

      if (!it.hasNext())
        ret with stack.ret(out);
        
      stack.call(new CopyObject(it.next()));
    }
  }

  noeq record CopyMap(Map o) extends VStackComputableWithStep {
    Map out;
    Iterator<Map.Entry> it;
    Map.Entry entry;
    O copiedKey;
    
    void step(VStack stack) {
      if (step == 0) {
        out = similarEmptyMap(o);
        seen.put(o, out);
        it = iterator(o.entrySet());
        ++step;
      }
      
      if (stack.hasSubResult()) {
        if (step == 1) {
          // got the copied key
          copiedKey = stack.subResult();
          // now copy the value
          stack.call(new CopyObject(entry.getValue()));
          ret with ++step;
        } else {
          // got the copied value - can put into map
          out.put(copiedKey, stack.subResult());
          step = 1;
        }
      }

      if (!it.hasNext())
        ret with stack.ret(out);
        
      entry = it.next();
      stack.call(new CopyObject(entry.getKey()));
    }
  }

  noeq record CopyObjectFieldByField(O o) extends VStackComputableWithStep {
    S className;
    Class c, destClass;
    O out;
    O enclosing;
    L<Field> fields;
    Iterator<Field> itField;
    Field field;
    Field[] enclosingFields;
    
    void step(VStack stack) {
      if (step == 0) {
        c = o.getClass();
        
        destClass = classMap.get(c);
        if (destClass == null) {
          destClass = findDestClass(c);
          classMap.put(c, destClass);
        }

        if (destClass == c && !fullCopy)
          ret with stack.ret(o); // short cut unless deep copying
        
        // take care of enclosing instance
        
        enclosingFields = thisDollarOneFields(c);
        if (handleEnclosingInstancesProperly
          && nempty(enclosingFields))
          stack.push(new CopyObject(fieldGet(first(enclosingFields), o)));

        ret with step = 1;
      } else if (step == 1) {
        // create new object
        
        try {
          if (stack.hasSubResult())
            out = unlisted_gen(destClass, stack.subResult());
          else if (nempty(enclosingFields))
            out = unlisted_gen(destClass, (O) null);
          else
            out = unlisted_gen(destClass);
        } on fail {
          printVars_str(+c, +destClass, +enclosingFields);
        }
        seen.put(o, out);
          
        fields = getOrCreate(fieldsForClass, c, () -> 
          nonTransientOnly
            ? nonStaticNonTransientFieldObjects(o)
            : nonStaticFieldObjects(o));
        itField = iterator(fields);
        
        ret with ++step;
      }
      
      if (stack.hasSubResult()) {
        ifdef RealmCopy_debug
          printFunctionCall setOpt(out, field.getName(), stack.subResult());
        endifdef
        setOpt(out, field.getName(), stack.subResult());
      }
        
      if (!itField.hasNext())
        ret with stack.ret(out);
        
      field = itField.next();
      stack.push(new CopyObject(fieldGet(field, o));
    }
  }
  
  Class findDestClass(Class c) {
    Class destClass = null;
    S className = c.getName();
    className = loadableUtilsClassNameToMain(className);
    if (!isAnonymousClassName(className))
      destClass = getClass_vmName_withLoadableUtils(dest, className);
    ret or(destClass, c);
  }

  // set to true if you want to copy a map or collection field-by-field
  swappable bool overrideCollectionOrMapCopy(O o) { false; }
}