!include once #1027578 // Named

// Note: db_mainConcepts() doesn't work (because of cases), always use cc!

concept BotName > Named {} // e.g. for finding the module in Cruddie

concept Cmd > ConceptWithGlobalID {
  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"); }
  
  sS importableFields() { ret "cmd conditions exampleInputs globalID index patterns 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;
}

// main class
asclass DynChatBotFrontend extends DynCRUD<Cmd> {
  switchable S backendModuleID;
  switchable S baseThingName = "$thing";
  O currentAttractor;
  transient CRUD<Replacement> replacementsCRUD;
  transient CRUD<Mishearing> mishearingsCRUD;
  transient JTabbedPane tabs;
  transient long lastAccessed = sysNow();
  transient Set currentActivities = syncSet();
  transient bool deleting;

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

  void start {
    cc = dm_handleCaseIDField();
    super.start();
    dm_watchFieldAndNow backendModuleID(r updateModuleName);
    
    crud.multiLineFields = litset("exampleInputs", "questionsForArguments");
    crud.sorter = func(Cl<Cmd> l) -> L<Cmd> { sortByField index(l) };
    crud.formFixer = 48;
    
    replacementsCRUD = new CRUD(cc, Replacement);
    mishearingsCRUD = new CRUD(cc, Mishearing);
    
    dm_vmBus_onMessage_q objectTypesChanged((module, names) -> {
      if (dm_isSame(module, backend()))
        importReplacements();
    });
  }
  
  void importReplacements() {
    LS names = cast dm_call(backend(), 'objectTypes);
    print("Got names: " + names);
    if (names != null) {
      deleteConcepts(cc, Replacement);
      for (S name : names)
        if (neqic(name, baseThingName))
          cnew(cc, Replacement, in := baseThingName, out := name);
    }
    applyReplacements();
  }

  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 backendModuleID;
  }
  
  visual {
    JComponent mainCRUD = super.visualize();

    addComponents(crud.buttons,
      jbutton("Talk to me", rThread talkToMe),
      jPopDownButton_noText(popDownButtonParams()));

    ret tabs = jtabs(
      "Commands" := mainCRUD,
      "Replacements" := replacementsCRUD.visualize(),
      "Mishearings" := mishearingsCRUD.visualize());
  }
  
  O[] popDownButtonParams() {
    ret litobjectarray(
      "Apply replacements", rThread applyReplacements,
      "Import replacements", rThread importReplacements,
      "Consistency check", rThread consistencyCheck,
      "Import commands from snippet...", rThread importCmdsFromSnippet);
  }
  
  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(cc, Cmd, 'autoGenerated, 'index))
      cset(cmd, index := index++);
  }
  
  void applyReplacements {
    deleteConceptsWhere(cc, 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, globalID := aGlobalIDObject());
        for (S field : cmd.translatableFields())
          cset(cmd2, field, fixAOrAn(replacePhrases(map, getString(cmd, field))));
        if (anyFieldsDifferent(cmd, cmd2, cmd.translatableFields()))
          registerConcept(cc, cmd2);
      }
    consistencyCheck();
  }
  
  bool unloadBackendTooWhenUnloaded() { true; }
  
  // API
  
  // for initial fill of translation table. probably doesn't catch many patterns usually
  void copyCommandsFromBackend() {
    for (S cmd : allIfQuotedPatterns(loadSnippet(beforeSlash(dm_moduleLibID(backend())))))
      uniqConcept(+cmd);
  }
  
  S preprocess(S s) {
    S s1 = s;
    s = replacePhrases(fieldToFieldIndexCI('in, 'out, list(Mishearing)), s);
    if (neq(s, s1)) print("Corrected to: " + s);
    ret s;
  }
  
  S answer(S s) {
    if (deleting) fail("Deleting module");
    touch();
    afterwards { touch(); }
    temp tempAddToCollection(currentActivities, new Var("Answering: " + s)); // abusing Var to allow duplicates
    s = preprocess(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;
      }
    }
    try S a = answer_other(s);
    try S a = answer_cmds(s);
    try S a = sendToBackend(s);
    ret answer_other_lowPrio(s);
  }
  
  // overridable
  S answer_other(S s) { null; }
  
  // overridable
  S answer_other_lowPrio(S s) { null; }

  // returns null iff not handled
  S answer_cmds(S s) null {  
    L<Cmd> cmds = filter(conceptsSortedByField(cc, Cmd, 'index),
      c -> nempty(c.patterns) && checkCondition(c));
    Cmd cmd = mmo_matchMultiWithTypos(1, cmds, c -> c.parsedPattern(), s);
    if (cmd != null) ret unnull(handleCommand(cmd));
  }
  
  bool checkCondition(Cmd cmd) {
    true;
  }
  
  // e.g. from snippet #1027616
  void importCmds(S src) {
    L l = dynShortNamed Cmd(safeUnstructList(src));
    int imported = 0;
    for (O o : l) {
      S id = getString globalID(o);
      if (empty(id)) continue;
      ++imported;
      GlobalID globalID = GlobalID(id);
      Cmd cmd = uniq_sync(cc, Cmd, +globalID);
      for (S field : splitAtSpace(Cmd.importableFields()))
        cSmartSet(cmd, field, getOpt(o, field));
    }
    topLeftInfoBox("Imported/updated " + nEntries(imported));
    if (imported != 0)
      importReplacements();
  }
  
  void importCmdsFromSnippet(S snippetID) {
    print("Importing cmds from " + snippetID);
    importCmds(loadSnippet(snippetID));
  }
  
  // import if we have no cmds yet
  void importCmdsFromSnippetIfEmpty(S snippetID) {
    if (conceptCount() == 0)
      importCmdsFromSnippet(snippetID);
  }
  
  void importCmdsFromSnippet enter {
    selectSnippetID("Commands to import", vf<S> importCmdsFromSnippet);
  }
  
  void connectToBackend(S backendModuleID) {
    setField(+backendModuleID);
  }
  
  void setBotName(S name) {
    cset(uniq(cc, BotName), +name);
    updateModuleName();
  }
  
  // may return null or empty string
  S botName() {
    ret getString name(conceptWhere(cc, BotName));
  }
  
  S getBotName() { ret botName(); }
  
  void updateModuleName enter {
    S name = botName();
    if (empty(name)) name = dm_moduleName(backend());
    dm_setModuleName("Frontend for " + name);
  }
  
  void touch { setField(lastAccessed := sysNow()); }
  
  void deleteYourself {
    setField(deleting := true);
    if (unloadBackendTooWhenUnloaded()) {
      print("Deleting backend " + backendModuleID);
      dm_deleteModule(backendModuleID);
    }
    dm_deleteModule();
  }
}

Began life as a copy of #1027602