!7

cmodule TomiiBoiAnswers > DynPrintLogAndEnabled {

  switchable int port = 8080;

  switchable S frontendName = "tomiiBoiDiscordBot";

  transient CRUD<Category> categoriesCRUD;

  transient CRUD<Server> serversCRUD;

  transient CRUD<Channel> channelsCRUD;

  transient CRUD<ServerToCategory> serverToCategoryCRUD;

  start {

    init();

    categoriesCRUD = new CRUD(Category);

    serversCRUD = new CRUD(Server);

    serverToCategoryCRUD = new CRUD(ServerToCategory);

    channelsCRUD = new CRUD(Channel);

    thread {

      dm_serveHttpFromFunction(port, lambda2 html);

      print("Admin live at: http://localhost:" + port);

      dm_registerAs('tomiiBoiQA);

    }

  }

  visualize {

    JComponent c = super.visualize();

    addComponents(buttons,

      jbutton("Open admin in browser", rThread { openURLInBrowser("http://localhost:" + port) }),

      jPopDownButton_noText(

        "Import data...", rThreadEnter importData));

    c = jtabs(

      "Main", c,

      "Categories", categoriesCRUD.visualize(),

      "Servers", serversCRUD.visualize(),

      "Server-to-category", serverToCategoryCRUD.visualize(),

      "Channels", channelsCRUD.visualize());

    channelsCRUD.addButton("Update list", rThreadEnter grabChannels);

    ret c;

  }

  void importData {

    selectFile("Tomii Brain File", voidfunc(File f) enter {

      replaceConceptsWithTextFileOnNextStart(f);

      dm_reloadModule();

    });

  }

  void grabChannels {

    dm_call(frontendName, 'grabChannels);

  }

  // API

  Server addServer(S serverID, S name) {

    ret csetAndReturn(uniq Server(+serverID), +name);

  }

  Channel addChannel(Server server, S channelID, S name) {

    ret csetAndReturn(uniq Channel(+server, +channelID), +name);

  }

  Channel channelForID(S channelID) {

    ret conceptWhere Channel(+channelID);

  }

}

//sS mainBotID = #1026411;

static int maxTypos = 1;

sS adminTitle = "Tomii Boi Chat Bot Admin";

sS shortLink; // catchy link to admin if available

sS embedderLink; // where chat bot will go

sS goDaddyEmbedCode;

static Cache<Scorer<ConsistencyError>> consistencyCheckResult = new(lambda0 consistencyCheck);

concept Server {

  S serverID, name;

  toString { ret name; }

}

concept ServerToCategory {

  Server server;

  Category category;

  bool enabled;

  sS _fieldOrder = "server category enabled";

}

concept Channel {

  Server server;

  S channelID;

  S name;

  bool botEnabled = true;

  toString { ret name; }

  sS _fieldOrder = "botEnabled name server";

}

concept Category {

  int index;

  S name;

  bool onByDefault = true;

  toString { ret name; }

}

concept Language {

  int index;

  S code;

}

concept QA {

  int index;

  S questions; // line by line

  S patterns; // to be determined

  S answers; // one answer, or "random { answers separated by empty lines }"

  S category; // "business", "smalltalk" etc.

  transient MMOPattern parsedPattern;

  sS _fieldOrder = "category index questions patterns answers";

  void change {

    parsedPattern = null;

    super.change();

  }

  MMOPattern parsedPattern() {

    if (parsedPattern == null)

      parsedPattern = mmo_parsePattern(patterns);

    ret parsedPattern;

  }

}

// keep these because otherwise deserialization breaks

concept Settings {}

concept Defaults {}

svoid init {

  processConceptsOverwriteFile();

  //print("fieldOrder", getFieldOrder(QA));

  dbIndexing(Category, 'index, Channel, 'channelID);

  print("QA count: " + countConcepts(QA));

  // categories, default category

  int i = 0;

  for (S category : ll("business", "smalltalk", "btd"))

    cset(uniq(Category, name := category), index := i++);

  cset(conceptsWhere QA(category := null), category := "business");

  onConceptsChange(r { consistencyCheckResult.clear(); });

  reindexQAs();

}

html { try {

  print(+uri);

  // force auth

  /*try answer callHtmlMethod(getBot(mainBotID), "/auth-only", mapPlus(

params, uri := rawLink(uri)));*/

  if (eq(uri, "/download"))

    ret serveText(conceptsStructure());

  HCRUD_Concepts<QA> data = new HCRUD_Concepts<QA>(QA) {

    S itemName() { ret "question"; }

    S fieldHelp(S field) {

      if (eq(field, "index"))

        ret "lower index = higher matching precedence";

      if (eq(field, "patterns"))

        ret [[Phrases to match. Use "+" as "and" operator, commas as "or" operator. Round brackets for grouping. Quotes for special characters. Put exclamation mark after phrase to disable typo correction.]];

      if (eq(field, "answers"))

        ret "Text of answer. Use random { ... } for multiple answers (separated from each other by an empty line)";

      null;

    }

    Renderer getRenderer(S field) {

      if (eqOneOf(field, 'questions, 'answers))

        ret new TextArea(80, 10);

      if (eq(field, 'patterns))

        ret new TextField(80);

      if (eq(field, 'category))

        ret new ComboBox(collect name(conceptsSortedByField(Category, 'index)));

      ret super.getRenderer(field);

    }

    // sort by priority (category + index)

    L<QA> defaultSort(L<QA> l) {

      ret sortQAs(l);

    }

  };

  data.onCreateOrUpdate.add(qa -> reindexQAs());

  HCRUD crud = new(rawLink(), data) {

    S frame(S title, S contents) {

      title = ahref(or2(shortLink, rawLink("")), adminTitle) + " | " + title;

      ret hhtml(hhead_title_decode(title)

        + hbody(h2(title)

        + p(joinWithVBar(

          targetBlank(rawLink("download"), "export brain"),

          ))

        + contents));

    }

    S renderTable(bool withCmds) {

      Scorer<ConsistencyError> scorer = consistencyCheckResult!;

      ret (empty(scorer.errors)

        ? p("Pattern analysis: No problems found. " + nEntries(countConcepts(QA)) + ".")

        : joinMap(scorer.errors, lambda1 renderErrorAsParagraph))

        + super.renderTable(withCmds);

    }

    S renderErrorAsParagraph(ConsistencyError error) {

      S fix = error.renderFix();

      ret p("Error: " + htmlEncode2(error.msg) + " " +

        joinMap(error.items, qa -> ahref(editLink(qa.id), "[item]"))

        + (empty(fix) ? "" : " " + fix));

    }

  };

  // actions

  if (eqGet(params, action := 'reindex)) {

    long id = parseLong(params.get('id));

    int newIndex = parseInt(params.get('newIndex));

    QA qa = getConcept(QA, id);

    if (qa == null) ret crud.refreshWithMsgs("Item not found");

    cset(qa, index := newIndex);

    reindexQAs();

    ret crud.refreshWithMsgs("Index of item " + qa.id + " changed");

  }

  ret crud.renderPage(params);

 } catch print e {

  ret "ERROR.";

 }

}

// main API function for other bots

sS answer(S s, O... _) {

  optPar Server server;

  QA qa = findMatchingQA(s, qasForServer(server));

  if (qa == null) null;

  S raw = qa.answers;

  S contents = extractKeywordPlusBracketed_keepComments("random", raw);

  if (contents != null)

    ret random(splitAtEmptyLines(contents));

  ret raw;

}

static L<QA> qasForServer(Server server) {

  Set<S> categories = asSet(categoriesForServer(server));

  ret sortQAs(filter(list(QA), qa -> contains(categories, qa.category)));

}

static QA findQAWithTypos(S s, Cl<QA> qas) {

  Lowest<QA> qa = findClosestQA(s, qas);

  if (!qa.has()) null;

  if (qa.score() > maxTypos) {

    print("Rejecting " + nTypos((int) qa.score()) + ": " + s + " / " + qa->patterns);

    null;

  }

  print("Accepting " + nTypos((int) qa.score()) + ": " + s + " / " + qa->patterns);

  ret qa!;

}

static QA findMatchingQA(S s, Cl<QA> qas, bool allowTypos) {

  try object QA qa = findMatchingQA(s, qas);

  if (allowTypos)

    try object QA qa = findQAWithTypos(s, qas);

  null;

}

static Lowest<QA> findClosestQA(S s, Cl<QA> qas) {

  time "findClosestQA" {

    new Lowest<QA> qa;

    findClosestQA(s, qa, qas);

  }

  ret qa;

}

static L<QA> sortQAs(Cl<QA> qas) {

  Map<S, Int> categoryToIndex = fieldToFieldIndex('name, 'index, list(Category));

  ret sortedByCalculatedField(qas, q -> pair(categoryToIndex.get(q.category), q.index));

}

svoid reindexQAs() {

  int index = 1;

  for (QA qa : sortQAs(list(QA)))

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

}

static QA findMatchingQA(S s, Cl<QA> qas) {

  for (QA qa : sortQAs(qas))

    if (mmo_match_parsedPattern(qa.parsedPattern(), s))

      ret qa;

  null;

}

svoid findClosestQA(S s, Lowest<QA> best, Cl<QA> qas) {

  for (QA qa : sortQAs(qas)) {

    Int score = mmo_levenWithSwapsScore_parsedPattern(qa.parsedPattern(), s);

    if (score != null)

      best.put(qa, score);

  }

}

sclass ConsistencyError {

  S msg;

  L<QA> items;

  *(S *msg, QA... items) { this.items = asList(items); }

  S renderFix() { null; }

}

svoid checkLocalConsistency(QA qa, Scorer<ConsistencyError> scorer) {

  LS questions = tlft(qa.questions);

  for (S q : questions)

    if (mmo_match_parsedPattern(qa.parsedPattern(), q))

      scorer.ok();

    else

      scorer.error(ConsistencyError("Question " + quote(q) + " not matched by patterns " + quote(qa.patterns), qa));

}

svoid checkGlobalConsistency(QA qa, Cl<QA> qas, Scorer<ConsistencyError> scorer) {

  for (S q : tlft(qa.questions)) {

    QA found = findMatchingQA(q, qas);

    if (found != null && found != qa)

      scorer.error(new ConsistencyError("Question " + quote(q) + " (item " + qa.id + ") shadowed by patterns " + quote(found.patterns) + " (item " + found.id + ")", qa, found) {

        S renderFix() {

          ret ahref(rawLink("?action=reindex&id=" + qa.id + "&newIndex=" + (found.index-1)), "[fix by changing index]");

        }

      });

    else

      scorer.ok();

  }

}

static Scorer<ConsistencyError> consistencyCheck() {

  new Scorer<ConsistencyError> scorer;

  scorer.collectErrors();

  for (QA qa) checkLocalConsistency(qa, scorer);

  for (Server server) {

    L<QA> qas = qasForServer(server);

    for (QA qa : qas)

      checkGlobalConsistency(qa, qas, scorer);

  }

  ret scorer;

}

// server can be null

static Cl<S> categoriesForServer(Server server) {

  Set<Category> set = asSet(conceptsWhere Category(onByDefault := true));

  if (server != null) for (ServerToCategory link : conceptsWhere(ServerToCategory, +server))

    addOrRemove(set, link.category, link.enabled);

  ret collectAsSet name(set);

}

// API

svoid importQA(virtual QA qa_external) {

  QA qa = shallowCloneToUnlistedConcept QA(qa_external);

  uniq QA(allConceptFieldsAsParams(qa));

}

sS rawLink() { ret "/"; }

sS rawLink(S uri) { ret addSlashPrefix(uri) ; }