!7

concept Cmd {

  S patterns; // for mmo_parsePattern

  S exampleInputs; // line-separated

  S cmd; // a star pattern recognized by the backend

  S questionsForArguments; // line-separated

  S conditions;

  int index;

  bool autoGenerated;

  LS translatableFields() { ret splitAtSpace("patterns exampleInputs cmd questionsForArguments"); }

  transient MMOPattern parsedPattern;

  void change { parsedPattern = null; super.change(); }

  MMOPattern parsedPattern() {

    if (parsedPattern == null) parsedPattern = mmo_parsePattern(patterns);

    ret parsedPattern;

  }

  sS _fieldOrder = "autoGenerated exampleInputs patterns cmd questionsForArguments conditions";

}

concept Replacement {

  S in, out; // word to replace and which word to replace it with

  S except; // IDs of Cmd concepts to skip

  sS _fieldOrder = "in out except";

}

concept Mishearing {

  S in, out;

}

cmodule ChatBotFrontend > DynCRUD<Cmd> {

  switchable S backendModuleLibID = "#1027443/Scenarios";

  O currentAttractor;

  transient CRUD<Replacement> replacementsCRUD = new(Replacement);

  transient CRUD<Mishearing> mishearingsCRUD = new(Mishearing);

  class HandleArgument implements IF1<S> {

    S cmd;

    LS argQuestions;

    new LS arguments;

    *() {}

    *(S *cmd, LS *argQuestions) {}

    // process an argument

    public S get(S arg) {

      arguments.add(arg);

      if (l(arguments) >= countAsteriskTokens(cmd))

        ret sendToBackend(format_quoteAll(cmd, asObjectArray(arguments)));

      else

        ret handleQuestionWithArguments(this);

    }

    S currentQuestion() {

      ret or2(_get(argQuestions, l(arguments)), "Need argument");

    }

  }

  runnable class Cancel { setField(currentAttractor := null); }

  class UndoHandler implements IF1<Bool, S> {

    public S get(Bool yes) {

      if (!yes) ret "OK"; // user said no

      ret (S) sendToBackend("undo");

    }

  }

  start {

    dm_watchFieldAndNow backendModuleLibID(r {

      dm_setModuleName("Frontend for " + dm_moduleName(backend()))

    });

    crud.multiLineFields = litset("exampleInputs", "questionsForArguments");

    crud.sorter = func(Cl<Cmd> l) -> L<Cmd> { sortByField index(l) };

    crud.formFixer = 48;

  }

  S handleCommand(Cmd cmd) {

    if (cmd == null) null;

    print("handleCommand " + cmd.cmd);

    if (match("undo after confirm", cmd.cmd)) {

      O undo = dm_call(backend(), 'lastUndo);

      if (undo == null) ret "Nothing to undo";

      new WaitForAnswer_YesNo attractor;

      attractor.question = "Undo " + undo + "?";

      setField(currentAttractor := attractor);

      print("Set attractor to: " + attractor);

      attractor.processAnswer = new UndoHandler;

      attractor.cancelSilently = new Cancel;

      ret attractor.question;

    }

    if (hasAsteriskTokens(cmd.cmd))

      ret handleQuestionWithArguments(

        new HandleArgument(cmd.cmd, tlft(cmd.questionsForArguments)));

    else

      ret sendToBackend(cmd.cmd);

  }

  S handleQuestionWithArguments(HandleArgument handler) {

    new WaitForName attractor;

    attractor.question = handler.currentQuestion();

    setField(currentAttractor := attractor);

    print("Set attractor to: " + attractor);

    attractor.processName = handler;

    attractor.cancelSilently = new Cancel;

    ret attractor.question;

  }

  S sendToBackend(S cmd) {

    ret (S) dm_call(backend(), 'answer, cmd);

  }

  S backend() {

    ret dm_require(backendModuleLibID);

  }

  visual {

    JComponent mainCRUD = super.visualize();

    addComponents(crud.buttons,

      jbutton("Talk to me", rThread talkToMe),

      jPopDownButton_noText(

        "Apply replacements", rThread applyReplacements,

        "Consistency check", rThread consistencyCheck));

    ret jtabs(

      "Commands" := mainCRUD,

      "Replacements" := replacementsCRUD.visualize(),

      "Mishearings" := mishearingsCRUD.visualize());

  }

  void talkToMe enter { dm_showConversationPopupForModule(); }

  void consistencyCheck enter {

    reindex();

    L<Cmd> cmds = list(Cmd);

    L<MMOConsistencyError> errors = mmo_consistencyCheck(

      map(cmds, cmd -> pair(cmd.exampleInputs, cmd.patterns)));

    if (empty(errors)) infoBox("No consistency problems");

    else

      dm_showText(n2(errors, "consistency problem"), lines(errors));

  }

  void reindex {

    int index = 1;

    for (Cmd cmd : conceptsSortedByFields Cmd('autoGenerated, 'index))

      cset(cmd, index := index++);

  }

  void applyReplacements {

    deleteConceptsWhere Cmd(autoGenerated := true);

    for (Cmd cmd)

      for (Replacement r) {

        if (jcontains(r.except, str(cmd.id))) continue;

        SS map = litcimap(r.in, r.out, plural(r.in), plural(r.out));

        Cmd cmd2 = shallowCloneUnlisted(cmd);

        cset(cmd2, autoGenerated := true);

        for (S field : cmd.translatableFields())

          cset(cmd2, field, fixAOrAn(replacePhrases(map, getString(cmd, field))));

        if (anyFieldsDifferent(cmd, cmd2, cmd.translatableFields()))

          registerConcept(cmd2);

      }

    consistencyCheck();

  }

  // API

  // for initial fill of translation table. probably doesn't catch many patterns usually

  void copyCommandsFromBackend() {

    for (S cmd : allIfQuotedPatterns(loadSnippet(beforeSlash(backendModuleLibID))))

      uniqConcept(+cmd);

  }

  S answer(S s) {

    S s1 = s;

    s = replacePhrases(fieldToFieldIndexCI('in, 'out, list(Mishearing)), s);

    if (neq(s, s1)) print("Corrected to: " + s);

    if (currentAttractor != null) {

      print("Sending to attractor " + currentAttractor + ": " + s);

      S a = strOrNull(call(currentAttractor, 'answer, s));

      if (a != null) {

        print("Attractor said: " + a);

        ret a;

      }

    }

    L<Cmd> cmds = filter(conceptsSortedByField Cmd('index),

      c -> nempty(c.patterns) && checkCondition(c));

    Cmd cmd = mmo_matchMultiWithTypos(1, cmds, c -> c.parsedPattern(), s);

    if (cmd != null) ret handleCommand(cmd);

    ret sendToBackend(s);

  }

  bool checkCondition(Cmd cmd) {

    if (match("have scenario", cmd.conditions))

      ret print("have scenario", dm_call(backend(), 'selectedScenario)) != null;

    true;

  }

}