sinterface IBEAReactor {
  BEAObject uniqResult(Class<? extends BEAObject> c, O... params);
}

extend BEAObject {
  bool canReactWith(BEAObject o) {
    ret isInstanceOfAny(o, (Cl) reactableWithClasses());
  }
  
  Cl<Class<? extends BEAObject>> reactableWithClasses() {
    ret (Cl) collectFirstMethodArguments(findMethodsNamed_nonSynthetic(this, "reactWith"));
  }
}

beaConcept BReactor {}

concept Reactable {
  BEAObject a, b;
}

asclass DynBEAReactor > DynCRUD_v2<BEAObject> {
  S input, output;
  switchable int maxObjects = 1000;
  
  transient new BEAUtils beaUtils;
  transient new Concepts reactableConcepts;
  transient ReliableSingleThread rstUpdateReactables = dm_rstWithDelay(this, 100, r updateReactables);
  transient JTabbedPane bottomTabs;

  { tableFontSize = 15; }

  start {
    ensureConceptClassIsIndexed(BEAObject);
    crud.humanizeFieldNames = false;
    crud.showBackRefs = true;
    crud.specialFieldsForItem = a -> {
      MapSO map = litorderedmap(crud.hID, str(a.id));
      S j = crud.javaClassDescForItem(a);
      mapPut(map, "Class/Type", joinUniqueNemptiesCI("/", j, a.type()));
      ret map;
    };
    crud.itemToMap_inner = a -> {
      MapSO map = crud.itemToMap_inner_base(a);
      map.remove("type");
      ret map;
    };
    
    onConceptChangesAndNow(rstUpdateReactables);
    
    thread {
      createInitialObjects();
    }
  }
  
  void createInitialObjects {}
  
  visualize {
    JConceptsTable<Reactable> tblReactables = new(reactableConcepts, Reactable);
    JComponent c = jvsplit(0.75, 100,
        jCenteredSection("Objects", super.visualize()),
        bottomTabs = jtabs("Reactables",
          withRightAlignedButtons(
            tblReactables,
            "React all", rThreadEnter reactAll,
            "React until output", rThreadEnter reactUntilOutput,
            jPopDownButton_noText("Update reactables", rstUpdateReactables))));
            
    tablePopupMenuFirst(tblReactables.table(), (menu, row) -> {
      Reactable r = tblReactables.getItem(row);
      printVars_str(+row, +r);
      ret if r == null;
      addMenuItem(menu, "React", rThreadEnter {
        BEAReactor reactor = new("Manually triggered reaction");
        reactor.react(r.a, r.b);
      });
    });

    tablePopupMenuFirst(table(), (menu, row) -> {
      BEAObject o = getItem(row);
      print("Item: " + o);
      if (o == null) ret;
      
      pcall {
        L<BEAObject> partners = filter(list(BEAObject),
          partner -> o.canReactWith(partner));
        if (nempty(partners))
          addScrollingSubMenu(menu, "React with", menu2 -> {
            for (BEAObject p : partners)
              addMenuItem(menu2, str(p), rThread {
                new BEAReactor("User reacts " + o + " with " + p).react(o, p);
              });
          });
      }
    });
    
    addButton("Delete reactors", rThreadEnter deleteReactors);
    
    addButton(jPopDownButton_noText(popDownButtonEntries()));
    
    ret c;
  } // end of visualize
  
  O[] popDownButtonEntries() {
    ret litobjectarray(
      "Export all objects", rThreadEnter exportAllObjects,
      "Import objects [TODO]", rThread importObjects,
    );
  }

  void exportAllObjects {
    S text = indentStructureString(dm_mainConceptsStructWithExplicitMarkers());
    //dm_showExtraFrame("Export all objects", withCenteredButtons(jTextArea_wordWrap(text)));
    dm_showTextInCodeEditor(text);
  }
  
  void importObjects {
    dm_showExtraFrame("Import objects",
      withCenteredButtons(jTextArea_wordWrap()));
  }
  
  class BEAReactor {
    BReactor reactorConcept;
    
    *(S purpose) {
      reactorConcept = cnew BReactor(+purpose);
    }
    
    void react(BEAObject a, BEAObject b) {
      call(a, 'reactWith, b, new IBEAReactor {
        public BEAObject uniqResult(Class<? extends BEAObject> c, O... params) {
          BEAObject product = cnew(c, paramsPlus(params,
            _fromReaction := ll(a, b),
            _reactor := reactorConcept));
          product = beaUtils.autoMigrate(product);
          BEAObject existing = findExisting(product);
          print("Existing for " + product + ": " + existing);
          if (existing != null) {
            cdelete(product);
            ret existing;
          } else {
            onReactionProduct(product);
            ret product;
          }
        }
      });
    }
  }
  
  // find an existing reactor-made object with the same values
  BEAObject findExisting(BEAObject o) {
    MapSO map = allConceptFieldsAsMap(o);
    removeAll(map, "_reactor", "globalID");
    //print(+map);
    ret firstThat(conceptsWhere(o.getClass(), mapToParams(map)),
      a -> a.getClass() == o.getClass() && a != o && cget _reactor(a) != null);
  }
  
  void onReactionProduct(BEAObject a) pcall {
    if (a.typeIs("output"))
      setField(output := getStringOpt text(a));
  }
  
  void deleteReactors {
    deleteConcepts(BEAObject,
      o -> cget _reactor(o) != null || o.typeIs("reactor"));
  }
  
  void updateReactables {
    deleteConcepts(reactableConcepts);
    L<BEAObject> objects = list(BEAObject);
    for (BEAObject a : objects)
      for (BEAObject b : filter(objects, b -> a.canReactWith(b)))
        cnew(reactableConcepts, Reactable, +a, +b);
  }
  
  BEAReactor reactAll() {
    Cl<Reactable> l = list(reactableConcepts, Reactable);
    if (empty(l)) null;
    
    BEAReactor reactor = new("User clicked \"react all\"");

    for (Reactable r : l) pcall {
      reactor.react(r.a, r.b);
    }
    
    ret reactor;
  }
  
  bool hasOutput() { false; }
  
  void reactUntilOutput {
    while (!hasOutput() && countConcepts(BEAObject) < maxObjects) {
      rstUpdateReactables.waitUntilDone();
      int count = countConcepts(BEAObject);
      BEAReactor reactor = reactAll();
      if (countConcepts(BEAObject) <= count+oneIf(reactor != null)) break; // +1 because of reactor
    }
  }
}