// one instance should only be used for one page at a time
sclass HCRUD extends HAbstractRenderable {
  HCRUD_Data data; // normally an instance of HCRUD_Concepts (#1026002)
  
  // yeah these fields are a mess...
  bool mutationRights = true;
  bool allowCreateOrDelete = true;
  bool allowCreate = true;
  bool allowEdit = true;
  bool singleton;
  
  bool cmdsLeft; // put commands on the left instead of the right
  bool showEntryCountInTitle;
  bool allowFieldRenaming;
  int defaultTextFieldCols = 80;
  int valueDisplayLength = 1000;
  S tableClass; // CSS class for table
  S formTableClass; // CSS class for form
  S checkBoxClass = "crud_chkbox";
  S customTitle;
  bool showTextFieldsAsAutoExpandingTextAreas;
  Set<S> unshownFields; // not shown in table or form
  Set<S> uneditableFields; // not shown in form
  Set<S> unlistedFields; // not shown in table
  bool showCheckBoxes;
  bool cleanItemIDs;
  
  bool haveJQuery, haveSelectizeJS, haveSelectizeClickable;
  bool needsJQuery; // unused
  bool paginate;
  bool sortable;
  bool buttonsOnTop, buttonsOnBottom = true;
  bool duplicateInNewTab;
  S formID = "crudForm";
  bool showQuickSaveButton; // needs hnotificationPopups()
  bool enableMultiSelect = true; // enables shift+click on check boxes. needs haveJQuery
  bool cellColumnToolTips; // give each table cell a tooltip showing its column name
  bool showSearchField;
  S searchQuery;
  
  SS params;
  new HTMLPaginator paginator;
  
  // sort options
  S sortByField = "id";
  S sortParameter = "sort";
  bool descending;
  
  int flexibleLengthListLeeway = 5; // how many empty rows to display at the end of each flexible length list
  
  // set internally after update/create or from "selectObj" param to highlight an item in the list (or show only that item)
  O objectIDToHighlight;
  bool showOnlySelected;
  
  S fieldPrefix = "f_";
  
  int entryCount;
  
  *() {}
  *(HCRUD_Data *data) {}
  *(S *baseLink, HCRUD_Data *data) {}
  
  S newLink() { ret appendQueryToURL(baseLink, cmd := "new"); }
  S deleteLink(O id) { ret appendQueryToURL(baseLink, "delete_" + id, 1); }
  S editLink(O id) { ret appendQueryToURL(baseLink, edit := id); }
  S duplicateLink(O id) { ret appendQueryToURL(baseLink, duplicate := id); }
  
  void setParams(SS params) {
    this.params = params;
    
    if (objectIDToHighlight == null) objectIDToHighlight = params.get("selectObj");
    if (eq("1", params.get("showOnlySelected")))
      set showOnlySelected;
  }
  
  // also handles commands if withCmds=true
  // you probably want to call renderPage() instead to handle all commands
  S render(bool withCmds, SS params) {
    //print("HCRUD render");
    setParams(params);
    
    if (!withCmds) ret renderTable(false);
    
    try answer handleCommands(params);
    
    ret renderMsgs(params)
      + divUnlessEmpty(nav())
      + renderTable(withCmds);
  }
  
  swappable S nav() {
    new LS l;
    if (actuallyAllowCreate())
      l.add(ahref(newLink(), "New " + itemName()));
    if (showSearchField)
      l.add(hInlineSearchForm("search", searchQuery, ""));
    ret joinWithVBar(l);
  }

  S handleCommands(SS params) {
    new LS msgs;
    
    if (eqGet(params, "action", "create")) {
      if (!actuallyAllowCreate()) fail("Creating objects not allowed");
      processRenames(params);
      O id = data.createObject(preprocessUpdateParams(params), fieldPrefix);
      msgs.add(itemName() + " created (ID: " + id + ")");
      objectIDToHighlight = id;
    }
    
    if (eqGet(params, "action", "update")) {
      if (!actuallyAllowEdit()) fail("Editing objects not allowed");
      S id = params.get("id");
      processRenames(params);
      msgs.add(data.updateObject(id, preprocessUpdateParams(params), fieldPrefix));
      objectIDToHighlight = id;
    }

    LS toDeleteList = keysDeprefixNemptyValue(params, "delete_");
    if (eq(params.get("bulkAction"), "deleteSelected"))
      toDeleteList.addAll(keysDeprefixNemptyValue(params, "obj_"));
      
    for (S toDelete : toDeleteList) {
      if (!actuallyAllowDelete()) fail("Deleting objects not allowed");
      msgs.add(data.deleteObject(toDelete));
    }

    ret empty(msgs) ? "" : refreshAfterCommand(params, msgs);
  }
  
  swappable S refreshAfterCommand(SS params, LS msgs) {
    S redirectAfterSave = mapGet(params, "redirectAfterSave");
    if (nempty(redirectAfterSave)) ret hrefresh(redirectAfterSave);
    
    ret refreshWithMsgs(msgs,
      anchor := objectIDToHighlight == null ? null : "obj" + objectIDToHighlight,
      params := objectIDToHighlight == null ? null : litmap(selectObj := objectIDToHighlight));
  }
  
  S encodeField(S s) {
    ret or(data.fieldNameToHTML(s), s);
  }
  
  // in table
  swappable S renderValue(S field, O value) {
    if (value cast HTML) ret value.html;
    value = deref(value);
    if (value cast SecretValue)
      ret hhiddenStuff(renderValue_inner(value!));
    ret renderValue_inner(value);
  }

  swappable S renderValue_inner(O value) {  
    if (value cast Bool)
      ret yesNo_short(value);
    ret htmlEncode_nlToBr_withIndents(shorten(valueDisplayLength, strOrEmpty(value)));
  }
  
  S renderTable(bool withCmds) {
    ret renderTable(withCmds, data.list());
  }
  
  S valueToSortable(O value) {
    if (value cast HTML)
      ret value!;
    ret strOrNull(value);
  }
  
  // l = list of maps as it comes from data object
  S renderTable(bool withCmds, L<MapSO> l) {
    //print("HCRUD renderTable");
    entryCount = l(l);
    if (empty(l)) ret p("No entries");
    if (!eq(data.defaultSortField(), pair(sortByField, descending))) {
      if (nempty(sortByField)) {
        print("Sorting " + nEntries(l) + " by " + sortByField);
        l = sortByTransformedMapKey_alphaNum valueToSortable(l, sortByField);
      }
      if (descending) l = reversed(l);
    }
    
    // l2 is the rendered map. use keyEncoding to get from l keys to l2 keys
    new SS keyEncoding;
    L<MapSO> l2 = lazyMap(l, _map -> {
      O id = itemID(_map);
      ret data.new Item(id) {
        public MapSO calcFullMap() {
          MapSO map = _map;
          map = mapMinusKeys(map, joinSets(unshownFields, unlistedFields));
          MapSO map2 = postProcessTableRow(map, mapToMap(
            (key, value) -> pair(mapPut_returnValue(keyEncoding, key, encodeField(key)), renderValue(key, value)),
            map));
          if (singleton)
            map2.remove(encodeField(data.idField())); // don't show ID in table in singleton mode
          if (withCmds)
            map2 = addCmdsToTableRow(map, map2);
          // add anchor to row
          map2.put(firstKey(map2), aname("obj" + id, firstValue(map2)));
          ret map2;
        }
      };
    });
    
    new LS out;
    
    if (paginate) {
      paginator.processParams(params);
      paginator.baseLink = addParamsToURL(baseLink,
        filterKeys keepParamInPagination(params));
      paginator.max = l(l2);
      out.add(divUnlessEmpty(paginator.renderNav()));
      
      L<MapSO> l3 = subListOrFull(l2, paginator.visibleRange());
      
      //printVars_str(+objectIDToHighlight, visible := l(l3), first := first(l3), firstID := mapToID(first(l3)));

      // if highlighted object is not on page or user wants to see only this object, show only this object
      if (objectIDToHighlight != null && (showOnlySelected || !any isHighlighted(l3))) {
        l3 = llNonNulls(firstThat isHighlighted(l2));
        //printVars_str(+objectIDToHighlight, total := l(l2), found := l(l3));
      }

      l2 = l3;
    }
    
    new SS replaceHeaders;
    if (sortable && !singleton)
      for (S key, html : keyEncoding) {
        bool sortedByField = eq(sortByField, key);
        bool showDescendingLink = sortedByField && !descending;
        S htmlOld = html;
        if (sortedByField) {
          S title = showDescendingLink ? "Click here to sort descending" : "Click here to sort ascending";
          S titleSorted = "Sorted by this field ("
            + (descending ? "descending" : "ascending") + ")";
          title = titleSorted + ". " + title;
          html = span_title(title, unicode_downOrUpPointingTriangle(descending)) + " " + html;
        }
        S sortLink = appendQueryToURL(baseLink, sortParameter, showDescendingLink ? "-" + key : key);
        replaceHeaders.put(htmlOld,
          /*html + " " + ahref(sortLink,
            unicode_smallDownOrUpPointingTriangle(showDescendingLink), +title)*/
          ahref(sortLink, html));
      }
    
    Map<S, O[]> paramsByColName = null;
    if (cellColumnToolTips) {
      paramsByColName = new Map;
      for (MapSO map : l2)
        for (S key : keys(map))
          if (!paramsByColName.containsKey(key))
            paramsByColName.put(key, litobjectarray(title := nullIfEmpty(htmldecode_dropTagsAndComments(key))));
    }

    out.add(hpostform(
      htmlTable2_noHtmlEncode(l2, paramsPlus(tableParams(), +replaceHeaders, +paramsByColName))
        + (!withCmds || !showCheckBoxes ? "" : "\n" + divUnlessEmpty(renderBulkCmds())),
      action := baseLink));
      
    if (showCheckBoxes && haveJQuery && enableMultiSelect)
      out.add(hCheckBoxMultiSelect_v2());
      
    ret lines_rtrim(out);
  }
  
  O mapToID(MapSO item) {
    ret item == null ?: dropAllTags(strOrNull(item.get(encodeField(idField()))));
  }
  
  // item is after encodeField
  bool isHighlighted(MapSO item) {
    O id = mapToID(item);
    //print("isHighlighted ID: " + toStringWithClass(id) + " / " + toStringWithClass(objectIDToHighlight));
    ret eq(id, objectIDToHighlight);
  }
  
  swappable S renderBulkCmds() {
    ret "Bulk action: " + hselect("bulkAction", litorderedmap("" := "", "deleteSelected" := "Delete selected"))
      + " " + hsubmit("OK", onclick := "return confirm('Are you sure?')");
  }
  
  MapSO addCmdsToTableRow(MapSO map, MapSO map2) {
    if (showCheckBoxes) {
      O id = itemID(map);
      map2.put(checkBoxKey(), hcheckbox("obj_" + id, false, title := "Select this object for a bulk action", class := checkBoxClass));
      map2 = putKeysFirst(map2, checkBoxKey());
    }
    map2.put(cmdsKey(), renderCmds(map));
    if (cmdsLeft)
      map2 = putKeysFirst(map2, cmdsKey());
    ret map2;
  }
  
  /*swappable*/ O[] tableParams() {
    ret litparams(
      tdParams := litparams(valign := "top"),
      tableParams := litparams(class := tableClass));
  }
  
  S renderForm(MapSO map) {
    temp tempSetTL(htmlencode_forParams_useV2, true);
    //print("renderForm: filteredFields=" + data.filteredFields());
    map = mapMinusKeys(map, joinSets(unshownFields, uneditableFields, data.filteredFields()));
    MapSO mapWithoutID = mapWithoutKey(map, data.idField());

    LLS matrix = map(mapWithoutID, (field, value) -> {
      S help = data.fieldHelp(field);
      ret ll(
        allowFieldRenaming ? hinputfield("rename_" + field, field, class := "field-rename", style := "border: none; text-align: right", title := "Edit this to rename field " + quote(field) + " or clear to delete field") : encodeField(field),
        addHelpText(help, renderInput(field, value))
      );
    });
    massageFormMatrix(map, matrix);
    
    ret htableRaw_valignTop(matrix
      , empty(formTableClass) ? litparams(border := 1, cellpadding := 4) : litparams(class := formTableClass));
  }
  
  S renderInput(S field, O value) {
    S name = fieldPrefix + field;
    ret renderInput(name, data.getRenderer(field, value), value);
  }
  
  S renderInput(S name, HCRUD_Data.Renderer r, O value) {
    //print("Renderer for " + name + ": " + r);
    if (r != null) value = r.preprocessValue(value);
    
    S meta = r == null ? "" : renderMetaInfo(r.metaInfo, name);
    
    // switch by renderer type

    if (r cast HCRUD_Data.AceEditor) {
      //ret meta + hAceEditor(strOrEmpty(value), style := "width: " + r.cols + "ch; height: " + r.rows + "em", +name);
      HTMLAceEditor ace = new(strOrEmpty(value));
      ace.name = name;
      ace.divParams.put(style := "width: " + r.cols + "ch; height: " + r.rows + "em");
      customizeACEEditor(ace);
      ret meta + ace.headStuff() + ace.html();
    }

    if (r cast HCRUD_Data.TextArea)
      ret meta + htextarea(strOrEmpty(value), +name, cols := r.cols, rows := r.rows);
      
    if (r cast HCRUD_Data.TextField)
      ret meta + renderTextField(name, strOrEmpty(value), r.cols);

    if (r cast HCRUD_Data.ComboBox)
      ret meta
        + renderComboBox(name, r.valueToEntry(value), r.entries, r.editable);
      
    if (r cast HCRUD_Data.DynamicComboBox)
      ret meta
        + renderDynamicComboBox(name, r.valueToEntry(value), r.info, r.editable, r.url);
      
    if (r cast HCRUD_Data.CheckBox)
      //ret hcheckbox(name, isTrue(value));
      ret meta + htrickcheckboxWithText(name, "", isTrue(value));
      
    if (r cast HCRUD_Data.FlexibleLengthList) {
      L list = cast value;
      new LS rows;
      
      int n = l(list)+flexibleLengthListLeeway;
      for i to n: {
        O item = _get(list, i);
        //print("Item: " + item);
        rows.add(tr(td(i+1 + ".", align := "right")
          + td(renderInput(name + "_" + i, r.itemRenderer, item))));
      }
      ret meta + htag table(lines(rows));
    }
    
    if (r instanceof HCRUD_Data.NotEditable)
      ret "Not editable";
      
    ret renderInput_default(name, value);
  }
  
  swappable void customizeACEEditor(HTMLAceEditor ace) {}
  
  S renderMetaInfo(S metaInfo, S name) {
    if (empty(metaInfo)) ret "";
    ret hhidden("metaInfo_" + dropPrefix(fieldPrefix, name), metaInfo);
  }
  
  S renderInput_default(S name, O value) {
    ret renderTextField(name, strOrEmpty(value), defaultTextFieldCols);
  }
  
  S renderTextField(S name, S value, int cols) {
    if (showTextFieldsAsAutoExpandingTextAreas) {
      ret htextarea(value, +name, class := "auto-expand",
        style := "width: " + cols + "ch",
        autofocus := eq(mapGet(params, "autofocus"), name) ? html_valueLessParam() : null,
        onkeydown := jquery_submitFormOnCtrlEnter());
    }

    ret htextfield(name, value, size := cols, style := "font-family: monospace");
  }
  
  S renderNewForm() {
    ret renderNewForm(data.emptyObject());
  }
  
  // pre-populate fields from request parameters
  S renderNewFormWithParams(SS params) {
    SS filteredMap = subMapStartingWith_dropPrefix(params, fieldPrefix);
    MapSO map = joinMaps(data.emptyObject(), (Map) filteredMap);
    data.rawFormValues = params;
    
    // pre-populate list fields  
    for (S key, value : filteredMap) {
      LS l = splitAt(key, "_");
      if (l(l) == 2) {
        S field = first(l);
        int idx = parseInt(second(l));
        LS list = cast map.get(field);
        if (!list instanceof ArrayList) map.put(field, list = new L);
        listPut(list, idx, value);
      }
    }

    ret renderNewForm(map);
  }
  
  S renderNewForm(MapSO map) {
    //printStruct("renderNewForm", map);
    S buttons = p(hsubmit("Create"));
    ret hpostform(
      hhidden("action", "create")
      + formExtraHiddens()
      + stringIf(buttonsOnTop, buttons)
      + renderForm(map)
      + stringIf(buttonsOnBottom, buttons),
      paramsPlus(formParameters(), action := baseLink));
  }
  
  swappable O[] formParameters() { ret litparams(id := formID); }
  
  S idField() { ret data.idField(); }
  
  S renderEditForm(S id) {
    if (!actuallyAllowEdit())
      ret "Can't edit objects in this table";
      
    if (!data.objectCanBeEdited(id))
      ret htmlEncode2("Object " + id + " can't be edited");
      
    MapSO map = data.getObjectForEdit(id);
    if (map == null) ret htmlEncode2("Entry " + id + " not found");
    
    S onlyFields = mapGet(params, "onlyFields");
    if (nempty(onlyFields))
      map = onlyKeys(map, itemPlus(idField(), tok_identifiersOnly(onlyFields)));

    S buttons = p_vbar(
      hsubmit("Save changes"),
      !showQuickSaveButton ? "" : 
        hbuttonOnClick_noSubmit("Save & keep editing", [[
          $.ajax({
            type: 'POST',
            url: $('#crudForm').attr('action'),
            data: $('#crudForm').serialize(), 
            success: function(response) { successNotification("Saved"); },
          }).error(function() { errorNotification("Couldn't save"); });
        ]]),
      deleteObjectHTML(id));
    ret hpostform(
      hhidden("action", "update") +
      formExtraHiddens() +
      hhidden(+id) +
      p("Object ID: " + htmlEncode2(id)) +
      + stringIf(buttonsOnTop, buttons)
      + renderForm(map)
      + stringIf(buttonsOnBottom, buttons),
      paramsPlus(formParameters(), action := baseLink + "#obj" + id));
  }
  
  S renderPage(SS params) {
    //print("HCRUD renderPage");
    setParams(params);
    
    try answer handleComboSearch(params);
    
    if (eqGet(params, "cmd", "new")) {
      if (!actuallyAllowCreate())
        ret "Can't create objects in ths table";
      ret frame(customTitleOr("New " + itemName()), renderNewFormWithParams(params));
    }
    
    if (nempty(params.get("edit")))
      ret frame("Edit " + itemName(), renderEditForm(params.get("edit")));
      
    if (nempty(params.get("duplicate")))
      ret frame("New " + itemName(), renderNewForm(data.getObjectForDuplication(params.get("duplicate"))));
      
    S rendered = render(mutationRights, params);
      
    // handle commands, render list
    S title = null;
    if (singleton)
      title = ahref(baseLink, firstToUpper(data.itemName()));
    else {
      if (objectIDToHighlight != null)
        title = data.titleForObjectID(objectIDToHighlight);
      if (empty(title))
        title = (showEntryCountInTitle ? n2(entryCount) + " " : "")
          + ahref(baseLink, firstToUpper(data.itemNamePlural()));
    }

    ret frame(customTitleOr(title), rendered);
  }
  
  HCRUD makeFrame(MakeFrame makeFrame) { super.makeFrame(makeFrame); this; }
  
  S cmdsKey() { ret "<!-- cmds -->"; }
  S checkBoxKey() { ret "<!-- checkbox -->"; }
  
  S itemName() { ret data.itemName(); }
  
  swappable MapSO postProcessTableRow(MapSO data, MapSO rendered) { ret rendered; }
  
  O itemID(MapSO item) {
    O id = mapGet(item, data.idField());
    // getVarOpt decodes HTML record
    if (cleanItemIDs) id = htmlDecode_dropTags(strOrNull(getVarOpt(id)));
    ret id;
  }
  
  long itemIDAsLong(MapSO item) {
    ret parseLong(itemID(item));
  }
  
  // return list of HTMLs for commands in pop down button
  swappable LS additionalCmds(MapSO item) { null; }
  
  swappable S renderCmds(MapSO item) {
    O id = itemID(item);
    LS additionalCmds = additionalCmds(item);
    ret joinNemptiesWithVBar(
      !actuallyAllowEdit() || !data.objectCanBeEdited(id) ? null : ahref(editLink(id), "EDIT"),
      deleteObjectHTML(id),
      !actuallyAllowCreate() ? null : targetBlankIf(duplicateInNewTab, duplicateLink(id), "dup", title := "duplicate"),
      empty(additionalCmds) ? null : hPopDownButton(additionalCmds)
    );
  }
  
  bool actuallyAllowCreate() {
    ret !singleton && allowCreateOrDelete && allowCreate;
  }
  
  bool actuallyAllowEdit() {
    ret allowCreateOrDelete && allowEdit;
  }
  
  bool actuallyAllowDelete() {
    ret !singleton && allowCreateOrDelete;
  }
  
  // e.g. for adding rows to edit/create form
  swappable void massageFormMatrix(MapSO map, LLS matrix) {
  }
  
  S renderComboBox(S name, S value, LS entries, bool editable) {
    if (haveSelectizeJS) {
      // coolest option - use selectize.js
      S id = aGlobalID();
      ret hselect_list(entries, value, +name, +id)
        + hjs("$('#" + id + "').selectize" + [[
          ({
            searchField: 'text',
            openOnFocus: true,
            dropdownParent: 'body',
            create: ]] + jsBool(editable) + [[
            /*allowEmptyOption: true*/
            ]]
            + unnull(moreSelectizeOptions2(name)) + [[
          });
        ]])
        + selectizeLayoutFix();
    }
      
    if (haveJQuery) {
      // make searchable list if JQuery is available
      // (functional, but looks quite poor on Firefox)
      // TODO: this seems to always be editable
      S id = aGlobalID();
      ret tag datalist(mapToLines hoption(entries), +id)
        + tag input("", +name, list := id);
    }
    
    // standard non-searchable list
    if (editable)
      ret hinputfield(name, value); // no editable combo box possible without selectize.js
    ret hselect_list(entries, value, +name);
  }
  
  S renderDynamicComboBox(S name, S value, S info, bool editable, S url default null) {
    assertTrue(+haveSelectizeJS);
    S id = aGlobalID();
    S ajaxURL = or2(url, baseLink);
    ret hselect_list(llNempties(value), value, +name, +id)
      + hjs("$('#" + id + "').selectize" + [[
        ({
          searchField: 'text',
          valueField: 'text',
          labelField: 'text',
          openOnFocus: true,
          dropdownParent: 'body',
          create: ]] + jsBool(editable) + [[,
          load: function(query, callback) {
            if (!query.length) return callback();
            var data = {
              comboSearchInfo: ]] + jsQuote(info) + [[,
              comboSearchQuery: query
            };
            console.log("Loading " + ]] + jsQuote(baseLink) + [[ + " with " + JSON.stringify(data));
            $.ajax({
              url: ]] + jsQuote(ajaxURL) + [[,
              type: 'GET',
              dataType: 'json',
              data: data,
              error: function() {
                console.log("Got error");
                callback();
              },
              success: function(res) {
                //console.log("Got data: " + res);
                var converted = res.map(x => { return {text: x}; });
                //console.log("Converted: " + converted);
                callback(converted);
              }
            });
          }
          /*allowEmptyOption: true*/
          ]] + moreSelectizeOptions2(name) + [[
        });
      ]])
      + selectizeLayoutFix();
  }
      
  void processSortParameter(SS params) {
    S sort = mapGet(params, sortParameter);
    //sortByField = null;
    if (nempty(sort))
      if (startsWith(sort, "-")) {
        descending = true;
        sortByField = substring(sort, 1);
      } else {
        descending = false;
        sortByField = sort;
      }
  }
  
  S deleteObjectHTML(O id) {
    ret !actuallyAllowDelete() ? null : 
      !data.objectCanBeDeleted(id) ?
        // TODO: custom msg!
        span_title("Object can't be deleted, either there are references to it or you are not authorized", htmlEncode2(unicode_DEL()))
        : ahrefWithConfirm(
          "Really delete item " + id + "?", deleteLink(id), htmlEncode2(unicode_DEL()), title := "delete");
  }
  
  // helpText is also HTML
  S addHelpText(S helpText, S html) {
    ret empty(helpText) ? html : html + p(small(helpText), style := "text-align: right");
  }
  
  S moreSelectizeOptions2(S name) {
    ret unnull(moreSelectizeOptions(name))
      + (!haveSelectizeClickable ? "" : [[
        , plugins: ['clickable']
        , render: {
            option: function(item) {
              var id = item.text.match(/\d+/)[0];
              return '<div><span>'+item.text+'</span>'
                  + '<div style="float: right">'
                  + '<a title="Go to object" class="clickable" href="/' + id + '" target="_blank">&#8599;</a>'
                  + '</div></div>';
            }
          }
        ]]);
  }
  
  swappable S moreSelectizeOptions(S name) { ret ""; }

  // deliver content for dynamic search in combo boxes
  S handleComboSearch(SS params) {
    S query = params.get("comboSearchQuery");
    if (nempty(query)) {
      S info = params.get("comboSearchInfo");
      ret jsonEncode_shallowLineBreaks(data.comboBoxSearch(info, query));
    }
    null;
  }
  
  // for update or create
  swappable SS preprocessUpdateParams(SS params) { ret params; }
  
  void disableAllMutationRights() {
    mutationRights = allowCreateOrDelete = allowCreate
      = allowEdit = false;
  }
  
  swappable bool keepParamInPagination(S name) {
    ret eq(name, "search");
  }
  
  S customTitleOr(S title) {
    ret or2(customTitle, or2(mapGet(params, "title"), title));
  }
  
  swappable S selectizeLayoutFix() {
    // dirty CSS quick-fix (TODO: send only once)
    ret hcss(".selectize-input, .selectize-control { min-width: 300px }");
  }
  
  S formExtraHiddens() {
    S redirectAfterSave = mapGet(params, "redirectAfterSave");
    ret empty(redirectAfterSave) ? "" : hhidden(+redirectAfterSave);
  }
  
  void processRenames(SS params) {
    if (!allowFieldRenaming) ret;
    for (S key1 : keysList(params)) {
      S field = dropPrefixOrNull("rename_", key1);
      if (field == null) continue;
      
      S newName = trim(params.get(key1));
      if (newName == null || eq(field, newName)) continue;
      print("Renaming " + field + " to " + or2(newName, "<deleted>"));
      params.remove("rename_" + field);
      
      // Try to catch f_myField, metaInfo_myField, f_myField_1...
      S re = "^([^_]+_)" + regexpQuote(field) + "(_[^_]+)?$";
      for (S key : keysList(params)) {
        LS groups = regexpGroups(re, key);
        if (groups != null) {
          S newKey = empty(newName) ? null : first(groups) + newName + unnull(second(groups));
          mapPut(params, newKey, params.get(key));
          params.put(key, ""); // this should delete stuff (if empty strings are converted to null)
          print("Renaming key: " + key + " => " + newKey);
        }
      }
    }
  }
}