/*
How to:
-set snippet IDs
-call run()
-Manually add lambdaMapLike etc to includeSnippetID
-Transpile lib & then main
-Check that things still work

-TODO: rewritten class names
*/

sclass LoadableUtilsExpander {
  run { prepare(); doIt(); }
  
  S mainProgramSnippetID = #1033411;
  S loadableUtilsSnippetID = #1033505;
  S includeSnippetID = #1033506;
  S globalSnippetID = #1020737;

  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;
  transient S transpilerOutput;
  
  void prepare {
    transpilerOutput = transpilerOutput(loadSnippet(mainProgramSnippetID));
    LS transpilerLines = mapLines dropLeadingAngleBracketStuff(transpilerOutput);
    
    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 (eqOneOf(p.a, "mapLike", "mapMethodLike", "nuLike", "lambdaMapLike", "curry1Like"))
        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);
    
    newFunctions = setMinusSet(setMinusSet(requestedFunctions, blockedFunctions), have);
    print(n2(newFunctions, "new function"));
    
    newClasses = setMinusSet(setMinusSet(requestedClasses, blockedClasses), haveClasses);
    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"));
    
    var negativeSet = joinSets(imported, blockedFunctions);
    var positiveSet = joinSets(have, newFunctions);
    toImport = setMinusSet(positiveSet, negativeSet);
    print(n2(toImport) + " function(s) to import");
    
    classesToImport = setMinusSet(haveClasses, importedClasses);
    print(n2(classesToImport) + " class(es) to import");
  }
  
  // appends to Loadable Utils snippet
  void appendThem {
    if (empty(newFunctions) && empty(newClasses)) ret with print("Nothing to do");
    S text = loadSnippet(loadableUtilsSnippetID);
    text += "\n\n"
      + mapToLines(newFunctions, f -> "please include function " + f + ".")
      + mapToLines(newClasses, c -> "please include class " + c + ".");
    editSnippet(loadableUtilsSnippetID, text);
  }
  
  // appends to Compact Module Include
  void appendImported {
    if (empty(toImport) && empty(classesToImport)) ret with print("Nothing to do");
    S text = loadSnippet(includeSnippetID);
    text += "\n\n"
      + mapToLines(toImport, f -> "import static loadableUtils.utils."
        + appendSpaceIfNempty(modifiers.get(f))
        + f + ";")
      + mapToLines(classesToImport, c -> "import loadableUtils.utils." + c + ";");
    editSnippet(includeSnippetID, text);
  }
  
  void doIt {
    appendThem();
    appendImported();
  }
}