import org.openxmlformats.schemas.wordprocessingml.x2006.main.*;

sclass WordDocumentTextReplacer2 {

  replace Run with XWPFRun.

  replace Paragraph with XWPFParagraph.

  File inFile, outFile;

  srecord OutRun(Run run, S newText) {}

  L<Paragraph> paragraphs;

  new LL<OutRun> outParagraphs;

  run {

    assertNotNull(+inFile);

    assertNotNull(+outFile);

    XWPFDocument doc = loadDocx(print("Loading", inFile));

    print("Document loaded");

    new XWPFDocument docOut;

    CTBody body = doc.getDocument().getBody();

    CTSectPr sectPr = body.getSectPr();

    CTBody bodyOut = docOut.getDocument().getBody();

    bodyOut.setSectPr(sectPr);

    paragraphs = doc.getParagraphs();

    for (Paragraph para : paragraphs) {

      L<Run> runs = para.getRuns();

      //print(n2(runs, "run"));

      new LPair<Run, S> runs2;

      for (Run r : runs)

        addPair(runs2, r, unnull(r.getText(0)));

      S fullText = join(pairsB(runs2));

      //print(quote(fullText));

      //printIfNempty(regexpExtractAll(regexp, fullText));

      processParagraph(runs2);

      outParagraphs.add(map(runs2, p -> new OutRun(p.a, p.b)));

    }

    postprocess();

    for (L<OutRun> runs : outParagraphs) {

      Paragraph paraOut = docOut.createParagraph();

      for (OutRun r : runs) {

        //paraOut.addRun(run);

        Run run = r.run;

        Run runOut = paraOut.createRun();

        runOut.setText(r.newText);

        // copy run attributes

        runOut.setColor(run.getColor());

        runOut.setFontFamily(run.getFontFamily());

        runOut.setFontSize(run.getFontSize());

        runOut.setBold(run.isBold());

        runOut.setItalic(run.isItalic());

        runOut.setUnderline(run.getUnderline());

        paraOut.addRun(runOut);

      }

    }

    saveDocx(docOut, outFile);

    printFileInfo(outFile);

  }

  swappable void postprocess() {}

  swappable void processParagraph(LPair<Run, S> runs2) {}

  void regexpReplacement(LPair<Run, S> runs2, S regularExpression, IF2<S, LS, S> getReplacement) {

    int safety = 100;

    for (int i = 0; safety-- > 0 && i < l(runs2); i++) {

      for (int j = i+1; j <= l(runs2); j++) {

        S text = join(pairsB(subList(runs2, i, j)));

        //print(+text);

        IntRange range = regexpFindRangeIC(regularExpression, text);

        if (range == null) continue; // no match

        //print("Match: " + substring(text, range));

        // we have a match, find out run indices

        // skip runs left of match

        while (i < l(runs2) && range.start >= l(runs2.get(i).b)) {

          range = shiftIntRange(range, -l(runs2.get(i).b));

          i++;

        }

        text = join(pairsB(subList(runs2, i, j)));

        print("Found match: " + substring(text, range));

        // replace all matched runs with one or two runs at i

        removeSubList(runs2, i+1, j);

        Run run = runs2.get(i).a;

        S found = substring(text, range);

        LS groups = regexpFirstGroups(regularExpression, found);

        S replacement = getReplacement.get(found, groups);

        print("Replacing with: " + replacement);

        S text1 = takeFirst(text, range.start) + replacement;

        if (nempty(text1)) {

          runs2.add(i, pair(run, text1));

          ++i;

        }

        S rest = substring(text, range.end);

        if (empty(rest))

          runs2.remove(i);

        else

          runs2.get(i).b = rest;

        --i; // process again

      }

    }

  }

  S fullText(L<OutRun> paragraph) {

    ret join(map(p -> p.newText, paragraph));

  }

}