sclass LoadableUtilsHelper {
  transient settable S exampleProgramID = #1031393;
  transient settable S loadableUtilsSnippetID = #1030952;
  transient settable S includeSnippetID = #1030953;
  transient settable S globalSnippetID = #1020737;
  transient settable bool onlyImportDefined = true;
  
  // for classes and functions
  transient settable IPred<S> dontDelegatePredicate = name -> false;
  
  transient S transpilerOutput;
  transient Set<S> requestedFunctions, requestedClasses;
  transient Set<S> have, haveClasses;
  transient new Set<S> blockedFunctions;
  transient new Set<S> blockedClasses;
  transient Set<S> newFunctions, newClasses;
  transient new Set<S> imported;
  transient Set<S> importedClasses;
  transient Set<S> toImport, classesToImport;
  transient new SS modifiers;
  
  selfType transpilerOutput(S transpilerOutput) {
    this.transpilerOutput = transpilerOutput;
    this;
  }
  
  S getTranspilerOutput() {
    new RunTranspiler rt;
    rt.onPreparingTranspiler(transpiler ->
      setOpt(transpiler, printMapLikes := true));
    ret transpilerOutput = hijackPrint(-> rt.get(loadSnippet(exampleProgramID)));
  }
  
  void prepare {
    if (transpilerOutput == null)
      getTranspilerOutput();
      
    LS transpilerLines = mapLines(transpilerOutput, s -> dropLeadingAngleBracketStuff(s));
    requestedFunctions = asSet(startingWithIC_dropAndTrim("Compiling function:", transpilerLines);
    requestedClasses = asSet(startingWithIC_dropAndTrim("Compiling class:", transpilerLines);
    
    print(n2(requestedFunctions, "requested function"));
    print(n2(requestedClasses, "requested class", "requested classes"));
    
    for (PairS p : parseColonPropertyPairs(lines(transpilerLines)))
      if (functionAdjuvantKeywords().contains(p.a))
        modifiers.put(p.b, p.a);
    print(n2(modifiers, "function modifier"));
        
    S text = loadSnippet(loadableUtilsSnippetID);
    have = asSet(lmap tok_lastIdentifier(jextractAll("please include function <id>.", text)));
    haveClasses = asSet(lmap tok_lastIdentifier(jextractAll("please include class <id>.", text)));
    
    print("Have " + n2(have, "function"));
    
    S includeSnippet = joinNemptiesWithEmptyLines(
      loadSnippet(includeSnippetID),
      loadSnippet(globalSnippetID));
    
    new Matches m;
    for (S comment : trimAll(getJavaLineComments(text))) {
      if (find3("don't include function *", comment, m))
        blockedFunctions.add($1);
      if (find3("don't include class *", comment, m))
        blockedClasses.add($1);
    }
        
    for (S comment : trimAll(getJavaLineComments(includeSnippet)))
      if (swic(comment, "don't import "))
        blockedFunctions.add(tok_lastIdentifier(comment));
        
    for (S s : jextractAll(javaTok(includeSnippet), "please include function <id>."))
      blockedFunctions.add(tok_lastIdentifier(s));
      
    print(n2(blockedFunctions, "blocked function") + ": " + blockedFunctions);
    print(n2(blockedClasses, "blocked class", "blocked classes") + ": " + blockedClasses);
    
    Set<S> shouldHave = setMinusSet(requestedFunctions, blockedFunctions);
    
    newFunctions = setMinusSet(shouldHave, have);
    newFunctions = antiFilterToSet(dontDelegatePredicate, newFunctions);
    print(n2(newFunctions, "new function"));
    
    Set<S> shouldHaveClasses = setMinusSet(requestedClasses, blockedClasses);
    newClasses = setMinusSet(shouldHaveClasses, haveClasses);
    newClasses = antiFilterToSet(dontDelegatePredicate, newClasses);
    print(n2(newClasses, "new class", "new classes"));
    
    for (S s : tlft(includeSnippet)) {
      s = simpleSpaces(s);
      if (startsWith(s, "import static "))
        imported.add(tok_lastIdentifier(s));
    }
    print(n2(imported, "imported function"));
    
    importedClasses = asSet(lmap tok_lastIdentifier(jextractAll("import loadableUtils.utils.<id>;", includeSnippet)));
    print(n2(importedClasses, "imported class", "imported classes"));
    
    toImport = toTreeSet(setMinusSet(onlyImportDefined ? have : shouldHave, imported));
    toImport = antiFilterToSet(dontDelegatePredicate, toImport);
    toImport = setMinusSet(toImport, blockedFunctions);
    print(n2(toImport) + " function(s) to import");
    
    classesToImport = toTreeSet(setMinusSet(onlyImportDefined ? haveClasses : shouldHaveClasses, importedClasses));
    print(n2(classesToImport) + " class(es) to import");
  }
  
  LPairS suggestedAppends() {
    ret ll(pair(loadableUtilsSnippetID,
      mapToLines(newFunctions, f -> "please include function " + f + ".")
      + mapToLines(newClasses, c -> "please include class " + c + ".")),
      pair(includeSnippetID,
        mapToLines(toImport, f -> "import static loadableUtils.utils."
          + appendSpaceIfNempty(modifiers.get(f))
          + f + ";")
        + mapToLines(classesToImport, c -> "import loadableUtils.utils." + c + ";")
      )
    );
  }
}