sclass SimpleCRUD_v2<A extends Concept> extends JConceptsTable<A> {
  JPanel buttons, panel;
  Set<S> unshownFields; // not shown in table or form
  Set<S> excludeFieldsFromEditing;
  S modifiedField; // field to hold last-modified timestamp
  TableSearcher tableSearcher;
  Set<S> multiLineFields; // string fields that should be shown as text areas
  Set<S> dontDuplicateFields;
  int formFixer = 12; // stupid value to make submit button appear
  bool showBackRefs;
  int maxRefsToShow = 3;
  bool showClassNameSelectors;
  bool allowNewFields;
  int newFieldsToShow = 3;
  bool emptyStringsToNull; // convert all empty string values to nulls (also means dropping the field if it's dynamic)
  int formLabelsWidth = 100; // just another bug fixer
  settable bool showSearchBar = true;
  settable bool showAddButton = true;
  settable bool showEditButton = true;
  settable bool showDeleteButton = true;
  settable bool showDuplicateButton = true;
  settable bool iconButtons;
  settable bool editWindowScrollable;
  settable bool scrollableButtons; // if you have a lot of them
  
  // put a component in here to fill the space left of the buttons
  SingleComponentPanel scpButtonFiller;
  
  JComponent wrappedButtonBar;
  
  // After user has submitted edit/create window
  event conceptSaved(A concept);

  *(Class<A> conceptClass) { super(conceptClass); }
  *(Concepts concepts, Class<A> conceptClass) { super(concepts, conceptClass); }
  
  SimpleCRUD_v2<A> show(S frameTitle) {
    make();
    showFrame(frameTitle, panel);
    this;
  }
  
  SimpleCRUD_v2<A> show() {
    ret show(entityNamePlural());
  }
  
  SimpleCRUD_v2<A> showMaximized() { show(); maximizeFrame(panel); ret this; }
  
  JPanel makePanel() { ret make(); }
  JPanel make() {
    db();
    framesBot();
    ret make_dontStartBots();
  }
  
  swappable MapSO itemToMap_inner(A a) {
    ret super.itemToMap_base(a);
  }
  
  MapSO itemToMap_base(A a) {
    MapSO map = itemToMap_inner(a);
    if (map == null) null;
    ret putAll(map, moreSpecialFieldsForItem(a));
  }
  
  // shown on the right (usually)
  swappable MapSO moreSpecialFieldsForItem(A a) {
    MapSO map = litorderedmap();
    if (showBackRefs) {
      Cl<Concept> refs = allBackRefs(a);
      if (nempty(refs)) {
        refs = sortedByConceptID(refs);
        int more = l(refs)-maxRefsToShow;
        map.put("Referenced by",
          joinWithComma(takeFirst(maxRefsToShow, refs))
        + (more > 0 ? ", " + more + " more" : ""));
      }
    }
    ret map;
  }
  
  public JPanel make_dontStartBots() { ret (JPanel) visualize(); }
  
  cachedVisualize {
    dropFields = asList(unshownFields);
    makeTable();
    swing {
      JButton deleteButton = !showDeleteButton ? null
        : tableDependButton(table, makeDeleteButton(r {
          L<A> l = selectedConcepts();
          withDBLock(concepts, r { for (A c : l) c.delete() });
        }));

      buttons = jRightAlignedLine(flattenToList(
        !showAddButton ? null : makeAddButton(r newConcept),
        !showEditButton || !showDuplicateButton ? null : tableDependButton(table, makeDuplicateButton(r {
          duplicateConcept(selectedConcept())
        })),
        !showEditButton ? null : tableDependButton(table, makeEditButton(r {
          editConcept(selectedConcept())
        })),
        deleteButton,
      ));
      
      wrappedButtonBar = wrapButtonBar(centerAndEastWithMargin(scpButtonFiller = singleComponentPanel(), buttons));
      
      if (showSearchBar) {
        tableSearcher = tableWithSearcher2(table, withMargin := true);
        panel = centerAndSouthWithMargin(tableSearcher.panel, wrappedButtonBar);
      } else
        panel = centerAndSouthWithMargin(table, wrappedButtonBar);
      
      var fEdit = voidfunc(int row) {
        editConcept(getItem(row))
      };
      tablePopupMenuItem(table, "Edit", fEdit);
      onDoubleClick(table, fEdit);
      tablePopupMenuFirst(table, (menu, row) -> {
        Concept c = getItem(row);
        if (c != null)
          addMenuItem(menu, "Delete " + quote(shorten(str(c))), rThread {
            deleteConcept(c);
          });
      });
    } // end of swing
    ret panel;
  }
  
  swappable JComponent wrapButtonBar(JComponent buttonBar) {
    if (scrollableButtons)
      ret jBorderlessHigherHorizontalScrollPane(vstack(buttonBar));
    ret buttonBar;
  }    

  swappable void newConcept() {
    duplicateConcept(null);
  }
  
  swappable A createDuplicate(A c) {
    A clone = (A) unlisted(_getClass(c));
    ccopyFieldsExcept(c, clone, dontDuplicateFields);
    ret clone;
  }
    
  void duplicateConcept(A oldConcept) {
    new EditWindow ew;
    if (oldConcept == null)
      ew.item = unlisted(conceptClass);
    else
      ew.item = createDuplicate(oldConcept);

    csetAll(ew.item, filters);
    makeComponents(ew);
    
    // save action
    F0<Bool> r = func -> bool {
      try {
        selectAfterUpdate(ew.item);
        concepts.register(ew.item);
        saveData(ew);
      } catch print e {
        infoBox(e);
        false;
      }
      true;
    };
    temp tempSetMCOpt(formLayouter1_fixer2 := formFixer);
    S title = "New " + entityName();
    title += appendBracketed(javaClassDescForItem(ew.item));
    
    renameSubmitButton("Create", showAForm(title,
      toObjectArray(listPlus(ew.matrix, r))));
  }

  void editConcept(A c) {
    if (c == null) ret;
    new EditWindow ew;
    ew.item = c;
    makeComponents(ew);
    F0<Bool> r = func -> bool {
      try {
        // concept class was changed, replace object
        if (ew.item != c) {
          print("Replacing object: " + c + " => " + ew.item);
          replaceConceptAndUpdateRefs(c, ew.item);
        }
        saveData(ew);
      } catch print e {
        infoBox(e);
        false;
      }
      true;
    };
    temp tempSetMCOpt(formLayouter1_fixer2 := formFixer);
    renameSubmitButton("Save", showAForm("Edit " + entityName() + " #" + c.id,
      toObjectArray(listPlus(ew.matrix, r))));
  }
  
  JComponent fieldComponent(A c, S field) {
    Class type = getFieldType(c.getClass(), field);
    Type genericType = genericFieldType(conceptClass, field);
    if (type == Concept.Ref.class)
      type = getTypeArgumentAsClass(genericType);
    
    O value = cget(c, field);
    if (type == null) type = _getClass(value);
    //print("Field type: " + field + " => " + type);
    if (type == bool.class)
      ret jCenteredCheckBox(isTrue(value));
    else if (contains(multiLineFields, field) || containsNewLines(optCast S(value)))
      ret makeTextArea((S) value);
    else if (isSubtype(type, Concept))
      ret jcomboboxFromConcepts_str(concepts, type, (Concept) value);
    ifclass SecretValue
    else if (type == SecretValue.class)
      ret jpassword(strOrEmpty(getVar(value/SecretValue)));
    endif
    else if (isUneditableFieldType(type))
      ret jlabel(structureOrText_crud(value));
    else try {
      ret autoComboBox(structureOrText_crud(value), new TreeSet<S>(map structureOrText_crud(collect(list(concepts, conceptClass), field))));
    } catch e {
      printException(e);
      ret jTextField(structureOrText_crud(value));
    }
  }
  
  void saveComponent(A c, S field, JComponent comp) {
    comp = unwrap(comp);
    ifdef SimpleCRUD_v2_debug
      printVars_str("saveComponent", +field, +comp);
    endifdef
    
    Class type = fieldType(c, field);
    Type genericType = genericFieldType(conceptClass, field);
    if (type == Concept.Ref.class)
      type = getTypeArgumentAsClass(genericType);
      
    ifclass SecretValue
      if (type == SecretValue.class) {
        S text = getTextTrim((JPasswordField) comp);
        cset(c, field, empty(text) ? null : SecretValue(text));
      } else
    endif
    if (comp instanceof JTextComponent) {
      S text = trimIf(!comp instanceof JTextArea, getText((JTextComponent) comp));
      O value = postProcessValue(text);
      O converted = convertToField(value, c.getClass(), field);
      ifdef SimpleCRUD_v2_debug
        printVars_str("saveComponent", +field, +text, +value, +converted);
      endifdef
      cset(c, field, converted);
    }
    else if (comp cast JComboBox) {
      S text = getTextTrim(comp);
      if (isSubtype(type, Concept))
        cset(c, field, getConcept(concepts, parseFirstLong(text)));
      else {
        O value = postProcessValue(text);
        cset(c, field, convertToField(value, c.getClass(), field));
      }
    } else if (comp instanceof JCheckBox)
      cset(c, field, isChecked((JCheckBox) comp));
    ifclass ImageChooser
      else if (comp instanceof ImageChooser)
        cUpdatePNGFile(c, field, comp/ImageChooser.getImage(), false);
    endif
  }
  
  swappable Cl<S> editableFieldsForItem(A c) {
    if (excludeFieldsFromEditing != null && modifiedField != null) excludeFieldsFromEditing.add(modifiedField);
    ret listWithoutSet(
      conceptFieldsInOrder(c),
      joinSets(excludeFieldsFromEditing, unshownFields, keys(filters)));
  }
  
  void excludeFieldsFromEditing(S... fields) {
    excludeFieldsFromEditing = setPlus(excludeFieldsFromEditing, fields);
  }
  
  
  Cl<Class<? extends A>> possibleClasses() {
    ret (Cl) moveItemFirst(conceptClass, dropTypeParameter(sortClassesByNameIC(myNonAbstractClassesImplementing(conceptClass))));
  }
  
  JComboBox<Class<? extends A>> classSelectorComponent(A c) {
    ret setComboBoxRenderer(jTypedComboBox(possibleClasses(), _getClass(c)),
      customToStringListCellRenderer shortClassName());
  }
  
  class NewField {
    JTextField tfName = jtextfield();
    JTextField tfValue = jtextfield();
    JComboBox cbRef = jcomboboxFromConcepts_str(concepts, conceptClass);
    JComboBox cbType = jcombobox("String", "Reference");
    SingleComponentPanel scpValue = singleComponentPanel();
    
    JPanel panel() {
      onChangeAndNow(cbType, r updateSCP);
      ret jhgridWithSpacing(
        withToolTip("Name for new field", withLabel("Name", tfName)),
        withLabel("Value", westAndCenterWithMargin(cbType, scpValue)));
    }
    
    S typeStr() { ret getText(cbType); }
    
    void updateSCP {
      scpValue.setComponent(eqic(typeStr(), "Reference")
        ? cbRef
        : withToolTip("Contents of new field", tfValue));
    }
    
    S field() { ret gtt(tfName); }
    O value() {
      ret eqic(typeStr(), "Reference")
        ? getConcept(concepts, parseFirstLong(getText(cbRef)))
        : gtt(tfValue);
    }
  }
  
  class EditWindow {
    A item;
    Map<S, JComponent> componentsByField = litorderedmap();
    new L matrix; // label, component, label, component, ...
    JComboBox<Class<? extends A>> classSelector;
    new L<NewField> newFields;
  }
  
  // override the following two methods to customize edit window
  
  void makeComponents(EditWindow ew) {
    // class selector
    
    if (showClassNameSelectors) {
      addAll(ew.matrix, makeLabel("Java Class"), ew.classSelector = classSelectorComponent(ew.item));
      onChange(ew.classSelector, r {
        Class<? extends A> oldClass = _getClass(ew.item);
        Class<? extends A> newClass = getSelectedItem_typed(ew.classSelector);
        if (oldClass == newClass) ret;
        A oldItem = ew.item;
        ew.item = unlisted(newClass);
        ccopyFields(oldItem, ew.item);
      });
    }
      
    // regular fields
    
    for (S field : editableFieldsForItem(ew.item)) {
      JComponent c = fieldComponent(ew.item, field);
      ew.componentsByField.put(field, c);
      addAll(ew.matrix, makeLabel(field), c);
    }
      
    // new fields
    
    if (allowNewFields && newFieldsToShow > 0) {
      addAll(ew.matrix, " ", jlabel()); // spacing
      for i to newFieldsToShow: {
        new NewField nf;
        ew.newFields.add(nf);
        addAll(ew.matrix, makeLabel(""/*"New field"*/), nf.panel());
      }
    }
  }
  
  void saveData(EditWindow ew) {
    // save regular fields
    
    for (S field, JComponent component : ew.componentsByField)
      if (isIdentifier(field))
        saveComponent(ew.item, field, component);
        
    // save new fields
    
    for (NewField nf : ew.newFields) {
      S field = nf.field();
      O value = nf.value();
      if (nempty(field) && notNullOrEmptyString(value))
        cset(ew.item, field, value);
    }
        
    if (modifiedField != null) cset(ew.item, modifiedField, now());
    
    conceptSaved(ew.item);
  }
  
  O postProcessValue(O o) {
    if (emptyStringsToNull && eq(o, "")) null;
    ret o;
  }
  
  // labels on left hand side of form
  JComponent makeLabel(S label) {
    ret jMinWidthAtLeast(formLabelsWidth, jlabel(label));
  }
  
  swappable JComponent showAForm(S title, O... parts) {
    JForm form = JForm(parts).disposeFrameOnSubmit();
    var panel = form.visualize();
    showFrame(title, editWindowScrollable ? jscroll_vertical(panel) : panel);
    ret panel;
  }
  
  bool isUneditableFieldType(Class type) {
    ret isSubclassOfAny(type, Map, Cl, Pair);
  }
  
  void hideField(S field) { hideFields(field); }
  void hideFields(S... fields) {
    unshownFields = createOrAddToSet(unshownFields, fields);
  }
  
  selfType entityName(S name) { entityName = if0_const(name); this; }
  
  swappable S entityName() { ret shortClassName(conceptClass); }
  swappable S entityNamePlural() { ret plural(entityName()); }
  swappable S entityNameLower() { ret firstToLower(entityName()); }
  swappable S entityNamePluralLower() { ret firstToLower(entityNamePlural()); }
  
  JPanel buttons() { visualize(); ret buttons; }
  
  void addButtonInFront(S text, Runnable r) {
    addButtonInFront(jbutton(text, r));
  }
  
  void addButton(S text, Runnable r) {
    addButton(jbutton(text, r));
  }
  
  void addButton(JComponent c) {
    buttons().add(c);
  }
  
  void addButtonInFront(JComponent c) {
    addComponentInFront(buttons(), c);
  }
  
  JButton makeAddButton(Runnable r) { ret makeButton(
    "Add...", "Create a new " + entityNameLower(), #1103069, r); }
  JButton makeDeleteButton(Runnable r) { ret makeButton(
    "Delete", "Delete selected " + entityNamePluralLower(), #1103067, r); }
  JButton makeEditButton(Runnable r) { ret makeButton(
    "Edit...", "Edit selected " + entityNameLower(), #1103068, r); }
  JButton makeDuplicateButton(Runnable r) { ret makeButton(
    "Duplicate...", "Duplicate selected " + entityNameLower(), #1103070, r); }
  
  JButton makeButton(S text, S toolTip default null, S iconID, Runnable r) {
    if (iconButtons)
      ret toolTip(or2(toolTip, text), jimageButtonScaledToWidth(16, iconID, text, r));
    else
      ret toolTip(toolTip, jbutton(text, r));
  }
  
  void multiLineField(S field) {
    multiLineFields = addOrCreate(multiLineFields, field);
  }
  
  swappable JComponent makeTextArea(S text) {
    ret typeWriterTextArea(text);
  }
  
  void setButtonFiller(JComponent c) {
    scpButtonFiller.set(c);
  }
  
  TableSearcher tableSearcher() {
    visualize();
    ret tableSearcher;
  }
} // end of SimpleCRUD_v2