!752

!include #1002268 // Slack Bot

static boolean actuallyPost = true;

static S botUserName = "eleu_learns_to_think";

static S actualBotUserName = "eleu"; // token user name

static boolean hotwire_over_bot = true;

static int maxAnswerLength = 1000, shortenTo = 200;

static L<S> botIDs;

static new L<Class> bots;

static new L<Class> privBots; // bots with an answerPriv method (privileged/private answering)

static new L<S> activeBots;

static Map<S, Class> botsByID = synchroTreeMap();

// information for "answer" functions

static new ThreadLocal<S> userName;

static new ThreadLocal<S> dialogID;

static new ThreadLocal<S> actualURI;

static volatile boolean loaded;

static int webServerPort = 80; // set to 0 for no web serving

static long hitCount;

static new L<Map> history; // stores all processed user questions (not whole chat log)

p {

  if (webServerPort != 0) {

    readLocally("hitCount");

    serveHttp(webServerPort);

  }

  initSlackBot();

  reload();

  readLog();

  loaded = true;

  slackBotLoop();

}

static S answerImpl(S s) {

  new Matches m;

  if (match("reboot", s)) {

    thread {

      sleepSeconds(1);

      nohupJavax(getProgramID());

      System.exit(100);

    }

    ret "Rebooting...";

  }

  if (match("reload", s)) {

    time { reload(); }

    ret l(bots) + "/" + l(botIDs) + " bots reloaded in "+ getLastTiming() + " ms.";

  }

  if (match("reload *", s, m)) {

    reload(m.unq(0));

    ret "Bot " + formatSnippetID(m.unq(0)) + " reloaded.";

  }

  if (match("list bots", s)) {

    S answer = "Active bots: " + structure(activeBots);

    L<S> inactiveBots = diff(botIDs, activeBots);

    if (!inactiveBots.isEmpty())

      answer += ". Inactive bots: " + structure(inactiveBots);

    ret answer;

  }

  if (match("test", s))

    ret "blah!";

  ret callStaticAnswerMethod(bots, s);

}

static synchronized S answer(S s) {

  long time = now();

  S a = "ERREUR";

  try {

    a = answerImpl(s);

  } finally {

    pcall {

      long x = now();

      // We should record which bot answered!

      Map map = litmap("startTime", time, "duration", x-time,

        "question", s, "answer", a, "botID", "?");

      printList(answerPriv(format("log timing *", structure(map))));

    }

  }

  ret a;

}

// can give multiple answers

static synchronized L<S> answerPriv(S s) {

  new L<S> l;

  for (Class bot : privBots) pcall {

    S a = cast callOpt(bot, "answerPriv", s);

    if (!empty(a))

      l.add(a);

  }

  ret l;

}

static void recordFeedback(S probableQuestion, S answer, S answerTime, S feedback, int score) {

  if (answer == null || probableQuestion == null) ret;

  Map data = litmap("realtime", now(), "question", probableQuestion, "answer", answer, "answertime", answerTime, "feedback", feedback, "score", score);

  print("Recording feedback: " + data);

  logQuoted(new File(programDir(), "feedback-log"), structure(data));

  logQuoted(new File(programDir(), "memory-log"), structure(data));

}

static void reloadLists() {

  botIDs = or((L<S>) loadVariableDefinition("botIDs"), botIDs);

  generalReleaseBots = or((L<S>) loadVariableDefinition("generalReleaseBots"), generalReleaseBots);

  botIDs.addAll(generalReleaseBots);

}

static void reload() {

  reloadLists();

  cleanUp(bots);

  activeBots = new ArrayList();

  privBots = new ArrayList();

  botsByID.clear();

  for (S botID : botIDs)

    pcall {

      loadBot(botID);

    }

}

static void reload(S botID) {

  reloadLists();

  S parsedID = "" + parseSnippetID(botID);

  Class bot = botsByID.get(parsedID);

  if (bot != null) {

    cleanUp(bot);

    botsByID.remove(parsedID);

    activeBots.remove(formatSnippetID(botID));

    bots.remove(bot);

    privBots.remove(bot);

  }

  loadBot(botID);

}

static void loadBot(S botID) {

  print("Loading bot: " + botID);

  Class c = hotwire_over_bot ? hotwire_overBot(botID) : hotwire(botID);

  setOpt(c, "mainBot", getMainClass());

  callMain(c);

  bots.add(c);

  activeBots.add(formatSnippetID(botID)); // only if loading doesn't fail

  botsByID.put("" + parseSnippetID(botID), c);

  if (hasMethodNamed(c, "answerPriv"))

    privBots.add(c);

  print("Loaded bot: " + botID + ", bots now: " + l(activeBots));

}

static NanoHTTPD.Response serve(S uri, NanoHTTPD.Method method,

  Map<S,S> header, Map<S,S> parms, Map<S,S> files) {

  print("Serving HTTP " + quote(uri));

  ++hitCount;

  saveLocally("hitCount");

  actualURI.set(uri);

  uri = dropPrefixMandatory("/", uri);

  if (!loaded)

    ret serveHTML("LOADING, PLEASE TRY AGAIN. " + l(bots) + "/" + l(botIDs) + " bots loaded");

  if (eq(uri, ""))

    ret serveHomePage();

  if (eq(uri, "favicon.ico"))

    ret serve404();

  // count and set cookie

  O visitorsBot = getBot("#1002157");

  if (visitorsBot != null) {

    S visitorHTML = callHtmlMethod(visitorsBot, "/");

  }

  int i = uri.indexOf('/');

  S firstPart = i >= 0 ? uri.substring(0, i) : uri;

  S rest = i >= 0 ? substr(uri, i) : "/"; // rest always starts with "/"

  ret serveBot(firstPart, rest, parms);

}

static NanoHTTPD.Response serveBot(S botID, S subUri, Map<S, S> params) {

  Class bot = botsByID.get("" + parseSnippetID(botID));

  boolean raw = subUri.equals("/raw") || subUri.startsWith("/raw/");

  if (raw) {

    subUri = substr(subUri, "/raw".length());

    if (subUri.length() == 0) subUri = "/";

  }

  if (bot != null) {

    print("Bot " + botID + " methods: " + structure(allMethodNames(bot)));

    S botHtml = callHtmlMethod(bot, subUri, params);

    if (raw) ret serveHTML(unnull(botHtml));

    if (botHtml == null)

      botHtml = "Bot has no HTML output.";

    S title = "Eleutheria Bot " + formatSnippetID(botID);

    S html = "<html><head><title>" + title + "</title></head>" +

      "<body><h3>Bot <a href=\"http://tinybrain.de/" + parseSnippetID(botID) + "\">" + formatSnippetID(botID) + "</a></h3>\n" + botHtml +

      "\n</body></html>";

    ret serveHTML(html);

  }

  ret serve404();

}

static NanoHTTPD.Response serveHomePage() {

  new StringBuilder buf;

  buf.append("<html>");

  buf.append("<head><title>Eleutheria Chat Bots</title></head>");

  buf.append("<body>");

  buf.append("<h3><a href=" + htmlQuote("http://tinybrain.de") + ">Eleutheria</a> Bots</h3>");

  buf.append("<ul>");

  for (S botID : concatLists(litlist(getProgramID()), activeBots)) {

    botID = formatSnippetID(botID);

    S parsedID = "" + parseSnippetID(botID);

    S title = "?";

    pcall { title = getSnippetTitle_overBot(botID); }

    S name = botID + " - " + htmlencode(title);

    buf.append("<li><a href=" + htmlQuote(parsedID) + ">" + name + "</a> (");

    buf.append("<a href=" + htmlQuote("http://tinybrain.de/" + parsedID) + ">source</a>)</li>");

  }

  buf.append("</ul>");

  buf.append("<p>Hit count: " + hitCount + "</p>");

  buf.append("<p>Last interactions:</p>");

  int maxInteractionsToPrint = 10;

  for (int i = l(history)-1; i >= 0 && i >= l(history)-maxInteractionsToPrint; i--) {

    Map m = history.get(i);

    buf.append("<p>" + htmlencode(m.get("question")) + "<br>&nbsp; &nbsp; " + htmlencode(m.get("answer")) + "</p>");

  }

  buf.append("</body>");

  buf.append("</html>");

  ret serveHTML(buf);

}

static S getSnippetTitle_overBot(S snippetID) {

  startBot("Snippet Title Bot", "#1001747");

  // Use local version

  //S s = sendToLocalBot(getVMPort() + "/Snippet Title Bot", "what is the title of snippet *", snippetID);

  // Use bot VM version

  S s = sendToLocalBot_cached("Snippet Title Bot", "what is the title of snippet *", snippetID);

  new Matches m;

  if (match("The title of snippet * is *.", s, m))

    ret m.unq(1);

  throw fail("Bot said: " + s);

}

static void readLog() {

  for (S prog : litlist("#1001915", "#1002017"))

    for (S s : scanLog(prog, "memory-log")) pcall {

      history.add((Map) safeUnstructure(s));

    }

  print(l(history) + " history entries.");

}

// for current thread

static S getUserName() {

  ret userName.get();

}

// for current thread

static S getDialogID() {

  ret dialogID.get();

}

// for current thread

static S getActualURI() {

  ret actualURI.get();

}

// for sub-bots to call

static O getSession() {

  ret NanoHTTPD.currentSession.get();

}

// for sub-bots to call

static O getCookies() {

  NanoHTTPD.IHTTPSession session = NanoHTTPD.currentSession.get();

  NanoHTTPD.CookieHandler cookies = session.getCookies();

  ret cookies;

}

static O getBot(S botID) {

  ret botsByID.get("" + parseSnippetID(botID));

}

static synchronized void historyAdd(Map logEntry) {

  history.add(logEntry);

  logQuoted(new File(programDir(), "memory-log"), structure(logEntry));

}

static S webAnswer(S s) {

  O session = getSession();

  O cookieHandler = getCookies();

  S cookie = cast call(cookieHandler, "read", "cookie");

  print("Web answer cookie: " + cookie);

  print("Web answer question: " + quote(s));

  S dialogID = cookie;

  main.dialogID.set(dialogID);

  // user name is empty for now

  S a = null;

  pcall {

    a = answer(s, false); // generalRelease = false, all bots

    print("Web answer: " + quote(a));

    if (empty(a))

      a = "Hello :)";

  }

  if (empty(a)) a = "(no response)";

  Map logEntry = litmap("question", s, "user", "web", "answer", a, "realtime", now());

  historyAdd(logEntry);

  ret a;

}