!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))) };

  }

}