!7

concept Comment {

  Concept commentingOn;

  S comment;

  S source;

}

concept Is {

  S globalID = aGlobalID();

  S a, b; // what is what?

  S mod; // 'yes, 'no, 'sometime, ...

  S linkWord; // "is", "are" (or null)

  S source; // where is the info from

  Bool useful;

  S render() {

    ret a + " " + linkPhrase() + " " + b;

  }

  toString { ret "[" + globalID + "] " + render(); }

  S linkPhrase() { ret makeLinkPhrase(this); }

  void setUseful(Bool useful) { cset(this, +useful); }

}

cmodule IsBot > DynAttractorBot {

  transient SimpleCRUD<Is> crud;

  // word -> language

  transient SS linkWords = reversePseudoMultiMapAsCIMap(litmap(

    "english" := splitAtSpaceToCISet(/*"is are am"*/"is are"),

    "german" := splitAtSpaceToCISet(/*"ist sind bin bist seid"*/"ist sind")));

  // magic sentence splitter

  PairS splitIt(S s) {

    LS tok = wordTok(s);

    int i = -1;

    if (l(tok) == 2*2+1) // two words

      i = 3;

    else {

      L<Int> determiners = indicesOfAny(tok, combinedMechSetsCI("Determiners", "German | Determiners"), 3);

      if (l(determiners) == 1)

        i = last(determiners);

    }

    ret i < 0 ? null : pair(joinSubList(tok, 1, i-1), joinSubList(tok, i, l(tok)-1));

  }

  void storeAnswer(PairS p, S mod, S linkWord, S huh) {

    if (p == null) {

      // emitAnswer(huh);

    } else {

      Collection<S> mods = lookup(p.a, p.b);

      if (containsIC(mods, mod))

        emitAnswer("I know");

      else {

        Is entry = uniqCI_sync Is(a := p.a, b := p.b, +linkWord, +mod);

        emitAnswer("Stored: " + p.a + " " + makeLinkPhrase(entry) + " " + p.b);

      }

    }

  }

  // returns mods

  Collection<S> lookup(S a, S b) {

    ret collect mod(findConceptsWhereCI(Is, +a, +b));

  }

  AttractorBot makeBot() {

    ret testBot(new SingleAttractorBot {

      PairS lastPair; // persistent

      void process(S s) { // MAIN ANSWER FUNCTION

        new Matches m;

        s = dropTrailingPunctuation(s);

        temp ai_setLanguages("english", "german");

        /*s = ai_userSpaceToObjective(s);

        print("Got objective space input: " + s);*/

        if (matchX_any(mL("Is Bot | Yes Phrases"), s))

          storeAnswer(lastPair, 'yes, null, "Yes what?");

        if (matchX_any(mL("Is Bot | No Phrases"), s))

          storeAnswer(lastPair, 'no, null, "No what?");

        LS tok = wordTok(s);

        S linkWord = second(tok);

        S language = linkWords.get(linkWord);

        if (language == null) {

          L<Int> linkIndices = indicesOfCodeTokensContainedInMap(tok, linkWords);

          if (l(linkIndices) != 1) ret with lastPair = null;

          int idx = first(linkIndices);

          linkWord = tok.get(idx);

          language = linkWords.get(linkWord);

          PairS p = pair(joinSubList(tok, 0, idx-1), joinSubList(tok, idx+2));

          if (eqicOneOf(p.a, "what", "who", "was", "wer")) {

            lastPair = null;

            ret with emitAnswer(whatIs(p.b, language));

          }

          if (!ai_ontologyBot_tester1(p)) ret with print("Skipping: " + p);

          lastPair = p;

          storeAnswer(p, 'yes, linkWord, null);

          ret;

        }

        bool g = eq(language, 'german);

        ai_setLanguages(language);

        PairS p;

        if (flexMatchIC("is it true that * is *", s, m))

          p = pair($1, $2);

        else {

          // tautological case

          S s2 = joinSubList(tok, 3);

          if (matchDoubleRest("", s2))

            ret with emitAnswer(g ? "Ja, natürlich" : "yes, obviously");

          p = splitIt(s2);

          if (p == null) ret/* with emitAnswer(g

            ? "Ich verstehe diesen Satz nicht"

            : [[I can't parse that sentence. Please try rephrasing with "Is it true that..."]])*/;

        }

        lastPair = p;

        S a = p.a, b = p.b;

        Collection<S> mods = lookup(a, b);

        if (nempty(mods))

          emitAnswer(join(" and ", mods));

        else

          emitAnswer(ai_objectiveSpaceToBot(g

            ? "Ich weiß nicht, ob " + a + " wohl " + b + " " + linkWord

            : "I don't know if " + a + " " + linkWord + " " + b));

      }

    });

  }

  // test for the empty bot

  AttractorBot testBot(AttractorBot bot) {

    testAttractorBotResponses_noFail(bot,

      "is green green?", "yes, obviously",

      "is a man a child?", "I don't know if a man is a child",

      "is sleep pleasant", "I don't know if sleep is pleasant");

    ret bot;

  }

  start {

    dbIndexingCI(Is, 'a, Is, 'b);

    dm_localMechListCopies();

    persistBot();

    crud = SimpleCRUD<Is>(db_mainConcepts(), Is);

  }

  afterVisualize {

    addTab(tabs, "CRUD" := crud.make_dontStartBots());

    addAndValidate(crud.buttons,

      tableDependentButton_extraCondition(crud.table,

        "Useful", r { cset(crud.selected(), useful := true) },

        func -> bool { neq(crud.selected().useful, true) } ));

    addAndValidate(crud.buttons,

      tableDependentButton_extraCondition(crud.table,

        "Not useful", r { cset(crud.selected(), useful := false) },

        func -> bool { neq(crud.selected().useful, false) } ));

    replaceAWTComponent(crud.buttons, func(Component c) -> JComponent {

      centerAndSouthWithMargin(c,

        jrightalignedlabel("Note: 'Useful' means grammatically correct and context-free, not necessarily 'true statement'"))

    });

  }

  S whatIs(S thing, S language) {

    L<Is> l = conceptsWhereIC(Is, a := thing);

    L<Is> l2 = conceptsWhereIC(Is, b := thing);

    if (empty(l) && empty(l2)) ret isGerman(language) ? "I don't know" : "Keine Ahnung";

    if (randomlyChooseFirstList(l, l2))

      ret random(l).b;

    else {

      Is entry = random(l2);

      ret entry.a + " " + makeLinkPhrase(entry) + " " + thing;

    }

  }

  // API

  L<Is> concepts() { ret list(Is); }

  L<Is> searchForA(S entity) { ret conceptsWhereIC(Is, a := entity); }

  L<Is> searchForB(S entity) { ret conceptsWhereIC(Is, b := entity); }

  L<Is> searchForAny(S entity) { ret mergeConceptLists(searchForA(entity), searchForB(entity)); }

  L<Is> unclassifiedConcepts() { ret conceptsWhere(Is, useful := null); }

  L<Is> conceptsWithUsefulness(Bool usefulness) { ret conceptsWhere(Is, useful := usefulness); }

}

sS makeLinkPhrase(Is entry) {

  S linkWord = or2(entry.linkWord, "is"), mod = entry.mod;

  if (eqic(mod, 'yes)) ret linkWord;

  if (eqic(mod, 'no)) ret linkWord + " not";

  ret linkWord + " " + mod;

}