!7

set flag DynModule. // for transpilation

sclass DevelopFromExamples > DynTextArea {
  S whatToTry;
  transient ReliableSingleThread rst = new(r think);
  transient volatile PlanInMotion<Runnable> currentPlan;
  transient int delay = 0; //2000; // to see stuff

  visualize {
    final JLabel lblStatus = jlabel();
    awtEvery(lblStatus, 100, r { main.setText(lblStatus, planStatus()) });
    ret withCenteredButtons(centerAndSouthWithMargins(
      jhsplit(jSection("Examples (struct => struct)", super.visualize()), dm_printLogComponent()),
      vstackWithSpacing(
        jsection("Standard functions to try", onEnter(dm_fieldTextField('whatToTry), rst)),
        lblStatus
      )), "Think", rst, "Fresh", rThread fresh, "[disabled] Cancel", r cancel);
  }
  
  S planStatus() {
    PlanInMotion plan = currentPlan;
    if (plan == null) ret " ";
    ret "Steps done: " + l(plan.doneSteps) + ". Steps planned: " + l(plan.plannedSteps);
  }
  
  void cancel {
    PlanInMotion plan = currentPlan;
    if (plan != null) plan.cancelled = true;
  }
  
  void fresh {
    dm_refreshTranspiler();
    forgetTranspiledStandardFunctions(words(whatToTry));
    loadFunctions_clearCache();
    rst.trigger();
  }
  
  class Thinker {
    new PlanInMotion<Runnable> plan;
    new L<Pair<S>> examples;
    new L<Pair<O>> unstructedExamples;
    F2<O, O, Bool> equalsFunction;
    new LinkedHashSet<S> thingsThatWork;
    
    void go {
      currentPlan = plan;
      temp tempAfterwards(r { currentPlan = null; });
      temp tempEnableButton(findButton(dm_vis(), "Cancel"));
      
      clearPrintLog();
      loadFunctions_preferDiskCache();
    
      S text = rtrimAll(getText());
      Pair<File, Bool> examplesFile = ai_makeExamplesFile(text);
      if (examplesFile.b) print("Wrote: " + f2s(examplesFile.a));
      bool eqic = false;
    
      L<S> lines = tlftj(text);
      if (eq(first(lines), "splitAtEmptyLines"))
        lines = splitAtEmptyLines(text);
        
      for (S line : lines) pcall {
        if (eqic(line, "eqic")) eqic = true;
        L<S> l = splitAtDoubleArrow_bothDirections(line);
        if (l(l) == 2) {
          Pair<S> p = pair(
            tok_multiLineQuotesToStandardQuotes(first(l)),
            safeCanonicalizeStructure(tok_multiLineQuotesToStandardQuotes(second(l))));
          add(examples, p);
          add(unstructedExamples, pair(safeUnstruct(p.a), safeUnstruct(p.b));
        }
      }
      
      final File logFile = replaceExtension(examplesFile.a, ".log");
      final LineBuffer lineBuffer = new(voidfunc(S line) { appendToFile(logFile, line + "\n") });
      temp tempInterceptPrint(func(S s) -> Bool { lineBuffer.append(s); true; });
      
      print(localDateWithMilliseconds());
      print("Thinking about " + n2(examples, "example"));
      
      equalsFunction = eqic
          ? func(O a, O b) -> Bool { eqic((S) a, (S) b) }
          : func(O a, O b) -> Bool { eq(a, b) };
  
      // Make plan
      fL<S> functionsToTry = uniquify(standardFunctionsOnly(words(whatToTry)));
      
      for (fS s : functionsToTry) addToPlan(s);
      for (fS a : functionsToTry)
        for (fS b : listMinus(functionsToTry, a))
          addToPlan(a + "°" + b);
      
      for (Runnable r : plan.master())
        callF(r);
        
      print("\n" + (plan.cancelled ? "Cancelled" : "Done") + " after " + n2(plan.doneSteps, "step") + ". " +
        (empty(thingsThatWork) ? (plan.cancelled ? "Nothing worked so far." : "Nothing works.") : (plan.cancelled ? "Things that worked so far: " : "Things that work: ") + joinWithComma(thingsThatWork)));
      print();
    }
    
    void addToPlan(fS s) {
      plan.add(r {
        sleep(delay);
        F1<S, S> f = functionFromText(s);
        func(S in) -> S { struct(callAndMake_orDirect(s, unstruct(in))) };
        T3<S, S, O> counterExample = worksOnAllExamples_returnCounterExample(f, examples, equalsFunction);
        if (counterExample == null)
          print("WORKS: " + addAndReturn(thingsThatWork, s));
        else {
          print("Nope: " + s);
          bool exc = counterExample.c instanceof Throwable;
          print((exc ? "Exception on:    "
                     : "Wrong result on: ") + sfu(counterExample.a));
          print(       "Expected:        " + sfu(counterExample.b));
          if (exc)
            printStackTrace((Throwable) counterExample.c);
          else
            print(     "         Result: " + sfu(counterExample.c));
        }
      });
    }
  }
  
  void think {
    if (currentPlan != null) ret;
    new Thinker().go();
  }
  
  // Allows composed functions ("g°f") or simple function names
  F1<S, S> functionFromText(fS s) {
    fL<S> l = splitAtJavaToken(s, "°");
    if (l(l) == 2)
      ret func(S in) -> S {
        O o = unstruct(in);
        o = callAndMake_orDirect(second(l), o);
        o = callAndMake_orDirect(first(l), o);
        ret struct(o);
      };
    else
      ret func(S in) -> S { struct(callAndMake_orDirect(s, unstruct(in))) };
  }
}