sclass CleanFluidTextFile implements Runnable {

  srecord Entry(S text, SS params) {

    long targetIndex;

    S actualText() { ret unquote(text); }

  }

  // set by user

  int maxRefLength = 8;

  bool verbose;

  Reader reader;

  Writer writer;

  // set by class

  new L<Entry> entries;

  new Map<S, Entry> relocationMap;

  long maxFileSize() {

    ret rangeOfNHexNumberWithNDigits(maxRefLength);

  }

  run {

    read();

    write();

  }

  void read ctex {

    Producer<S> tokenizer = javaTok_onReader(reader);

    FluidTextFileEntry entry;

    while ((entry = readFluidTextFileEntry(tokenizer)) != null) {

      if (!containsKey(entry.params, "_")) // not a deletable entry

        entries.add(new Entry(entry.quotedContent, entry.params));

    }

    if (verbose) pnlStruct(entries);

  }

  void write ctex {

    // make a map and pessimistically assign byte indices to all entries

    for (Entry e : entries)

      mapPut(relocationMap, e.params.get("i"), e);

    makeIndices(entries);

    // rewrite references

    for (Entry e : entries)

      if (hasReferences(e))

        e.text = replaceRefs(e, r -> lookupInRelocationMap(r));

    // write out

    long idx = 0; // index into file

    for (Entry e : entries) {

      assertEquals(e.targetIndex, idx);

      e.params.put("i", renderReference(e.targetIndex));

      S line = entryToString(e, idx);

      if (verbose)

        print(quote(line));

      writer.write(line);

      int l = lUtf8(line);

      if (verbose)

        print("Actual entry length: " + l);

      idx += l;

    }

  }

  S lookupInRelocationMap(S ref) {

    Entry e = relocationMap.get(ref);

    //print("lookupInRelocationMap: " + ref + " => " + e);

    ret e == null ? null : renderReference(e.targetIndex);

  }

  S renderReference(long idx) {

    ret takeLast(maxRefLength, longToHex(idx));

  }

  void makeIndices(L<Entry> entries) {

    long idx = 0; // index into file

    for (Entry e : entries) {

      e.targetIndex = idx;

      int l = pessimisticEntryLength(e);

      idx += l;

      if (verbose)

        print("Pessimistic entry length: " + l);

    }

  }

  S entryToString(Entry e, long idx) {

    ret entryToString(e, renderReference(idx));

  }

  S entryToString(Entry e, S idx) {

    SS params = litorderedmap(

      i := idx,

      l := intToHex_flexLength(lUtf8(e.text)));

    mapPutAll_noOverwrite(params, e.params);

    ret renderEqualsCommaProperties(params) + " " + e.text + "\n";

  }  

  S dummyRef() {

    ret rep('0', maxRefLength);

  }

  bool hasReferences(Entry e) {

    ret eq(e.params.get("refs"), quote("at *"));

  }

  int pessimisticEntryLength(Entry e) {

    Entry e2 = e;

    if (hasReferences(e)) {

      e2 = cloneObject(e);

      e2.text = replaceRefs(e, r -> dummyRef());

      if (verbose)

        print("Pessimistic: rewrote text to " + quote(e2.text));

    }

    S s = entryToString(e2, dummyRef());

    if (verbose)

      print(quote(s));

    ret lUtf8(s);

  }

  S replaceRefs(Entry e, IF1<S> f) {

    LS tok = javaTokWithUnifiedNumbersAndIdentifiers(e.actualText());

    for (int i : jfindAll(tok, "at *")) {

      S x = f.get(tok.get(i+2));

      if (nempty(x))

        tok.set(i+2, x);

    }

    ret multiLineQuote(join(tok));

  }

}