function getBiblSelectionModal(editor: EditorAPI): Modal {
  let modal = editor.getModeData(BIBL_SELECTION_MODAL_KEY);
  if (modal) {
    return modal;
  }

  modal = editor.makeModal();
  modal.setTitle("Invalid Selection");
  modal.setBody("<p>The selection should contain only text. The current " +
                "selection contains elements.</p>");
  modal.addButton("Ok", true);
  editor.setModeData(BIBL_SELECTION_MODAL_KEY, modal);

  return modal;
}

function getNestingModal(editor: EditorAPI): Modal {
  let nestingModal = editor.getModeData(NESTING_MODAL_KEY);
  if (nestingModal) {
    return nestingModal;
  }

  nestingModal = editor.makeModal();
  nestingModal.setTitle("Invalid nesting");
  nestingModal.setBody("<p>In this part of the article, you cannot embed one " +
                       "language into another.</p>");
  nestingModal.addButton("Ok", true);
  editor.setModeData(NESTING_MODAL_KEY, nestingModal);

  return nestingModal;
}

function getEditSemanticFieldModal(editor: EditorAPI): Modal {
  let modal = editor.getModeData(EDIT_SF_MODAL_KEY);
  if (modal) {
    return modal;
  }

  modal = editor.makeModal({
    resizable: true,
    draggable: true,
  });
  modal.setTitle("Edit Semantic Fields");
  modal.addButton("Commit", true);
  modal.addButton("Cancel");
  const body = modal.getTopLevel()[0].getElementsByClassName("modal-body")[0];
  body.classList.add("sf-editor-modal-body");
  body.style.overflowY = "hidden";
  editor.setModeData(EDIT_SF_MODAL_KEY, modal);

  return modal;
}

function executeDeleteAttribute(editor: EditorAPI,
                                data: TransformationData): void {
  const node = data.node;

  if (node == null || !isAttr(node)) {
    throw new Error("node must be an attribute");
  }

  const element = node.ownerElement!;
  const caretManager = editor.caretManager;
  const guiOwnerLoc = caretManager.mustFromDataLocation(element, 0);
  // If the node we start with is an Element, then the node in guiOwnerLoc
  // is necessarily an Element too.
  const guiOwner = guiOwnerLoc.node as Element;
  if (!guiOwner.classList.contains("_readonly")) {
    const encoded = node.name;
    const startLabel = childByClass(guiOwner, "__start_label")!;

    // An earlier version of this code relied on the order of attributes in the
    // data tree. However, this order is not consistent from platform to
    // platform. Using the order of attributes in the GUI is
    // consistent. Therefore we go to the GUI to find the next attribute.

    const values = startLabel.getElementsByClassName("_attribute_value");

    // We have to get the parent node because fromDataLocation brings us to the
    // text node that contains the value.
    const guiNode = caretManager.mustFromDataLocation(node, 0).node.parentNode;
    const index = indexOf(values, guiNode!);
    const nextGUIValue = values[index + 1];
    const nextAttr = nextGUIValue != null ?
      editor.toDataNode(nextGUIValue) : null;

    editor.dataUpdater.setAttribute(element, encoded, null);

    // We set the caret inside the next attribute, or if it does not exist,
    // inside the label.
    if (nextAttr !== null) {
      editor.caretManager.setCaret(nextAttr, 0);
    }
    else {
      editor.caretManager.setCaret(
        guiOwner.getElementsByClassName("_element_name")[0], 0);
    }
  }
}

export function replaceSemanticFields(editor: EditorAPI,
                                      data: SemanticFieldTransformationData):
void {
  const dataCaret = editor.caretManager.getDataCaret(true)!;
  const guiCaret = editor.caretManager.fromDataLocation(dataCaret)!;
  const guiSfsContainer = domutil.closestByClass(guiCaret.node,
                                                 "btw:semantic-fields",
                                                 editor.guiRoot);
  if (guiSfsContainer === null) {
    throw new Error("unable to acquire btw:semantic-fields");
  }

  const sfsContainer = editor.toDataNode(guiSfsContainer)!;
  const sfsParent = sfsContainer.parentNode!;
  const sfsIndex = _indexOf.call(sfsParent.childNodes, sfsContainer);
  // Remove the container from the tree.
  editor.dataUpdater.removeNode(sfsContainer);

  // and manipulate it off-line.
  while (sfsContainer.firstChild !== null) {
    sfsContainer.removeChild(sfsContainer.firstChild);
  }

  const doc = sfsContainer.ownerDocument;
  const newPaths = data.newPaths;
  const mode = editor.modeTree.getMode(sfsContainer);
  const ename = mode.getAbsoluteResolver().resolveName("btw:sf")!;

  for (const path of newPaths) {
    const sf = makeElement(doc, ename.ns, "btw:sf");
    sf.textContent = path;
    sfsContainer.appendChild(sf);
  }

  // Finally, reintroduce it to the data tree.
  editor.dataUpdater.insertNodeAt(sfsParent, sfsIndex, sfsContainer);
  editor.caretManager.setCaret(sfsContainer, 0);
}

 (editor: EditorAPI, data: NamedTransformationData) => {
   editor.insertText(data.name);
 });