!752

static boolean actuallyPost = true;

static L<S> botIDs = litlist("#1001890", "#1001923", "#1001937", "#1001942", "#1001945", "#1001951" /*, "#1001747"*/,

  "#1001989", "#1001861", "#1001991", "#1001994", "#1002007");

static new L<Class> bots;

static new L<S> activeBots;

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

static S channelID = "C0FH9PY8J"; // relp, #talkingbots

static S token;

//static new Map<S, S> lastPostByUser;

static new Map<S, S> userNames;

static S lastQuestion, lastAnswer;

static S lastAnswerTimestamp; // only for posted in this session

static int lastAnswerScore;

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

static long hitCount;

/*

static class Interaction {

  S question, user, answertime, answer;

  long realtime;

  int score; // not used yet

}

static new L<Interaction> interactions;

*/

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

p {

  if (token == null)

    token = loadSecretTextFileMandatory("#1001889", "relp-slack-botstuff-token").trim();

  reload();

  readLog();

  if (webServerPort != 0) {

    readLocally("hitCount");

    serveHttp(webServerPort);

  }

  while true {

    pcall {

      if (lastAnswerTimestamp != null) {

        // Poll reactions to our last answer - is there a more efficient way?

        int score = slackReactionScore(token, channelID, lastAnswerTimestamp);

        if (score != lastAnswerScore) {

          print("Reaction score changes to " + score);

          recordFeedback(lastQuestion, lastAnswer, lastAnswerTimestamp, "emoji", score-lastAnswerScore);

          lastAnswerScore = score;

        }

      }

      L<SlackMsg> qs = getNewQuestions();

      //print(l(qs) + " question(s).");

      //printList(qs);

      for (SlackMsg msg : qs) {

        S q = msg.text;

        S userName = getUserName(msg.user);

        print("Processing question: " + quote(q));

        if (lastAnswer != null) { // TODO: maybe check the time delay

          int score = feedbackScore(q);

          if (score != 0) {

            recordFeedback(lastQuestion /*lastPostByUser.get(userName)*/, lastAnswer, lastAnswerTimestamp, q, score);

            if (score > 0)

              pcall { slackSmile(token, channelID, msg.ts); }

            else

              pcall { slackReact(token, channelID, msg.ts, "thinking_face"); }

          }

          lastAnswer = null;

        }

        //if (userName != null) lastPostByUser.put(userName, msg.text);

        pcall {

          S a = answer(q);

          if (a != null) {

            if (userName != null)

              a = "<@" + userName + "> " + a;

            print("Answering with: " + quote(a));

            lastAnswer = a;

            lastQuestion = q;

            if (actuallyPost) {

              S answerTime = postAnswer(a);

              Map logEntry = litmap("question", q, "user", userName, "answertime", answerTime, "answer", a, "realtime", now());

              history.add(logEntry);

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

            }

          }

        }

      }

    }

    sleepSeconds(5);

  }

}

// returns the slack timestamp

static S postAnswer(S text) {

  S username = "botstuff";

  S url = "https://slack.com/api/chat.postMessage";

  S postData = "token=" + urlencode(token) + "&channel=" + urlencode(channelID) + "&text=" + urlencode(text)

    + "&username=" + urlencode(username);

  print(postData);

  S data = doPost(postData, url);

  Map map = jsonDecodeMap(data);

  lastAnswerTimestamp = (S) map.get("ts");

  lastAnswerScore = 0;

  print("postAnswer: " + data);

  ret lastAnswerTimestamp;

}

static S getNewQuestions_lastSeen;

static L<SlackMsg> getNewQuestions() {

  // Get 150 on first call (history before bot start)

  // and 1000 thereafter (just grab anything new)

  int limit = getNewQuestions_lastSeen == null ? 150 : 1000;

  L<SlackMsg> msgs = slackReadChannel(channelID, token, limit, getNewQuestions_lastSeen);

  if (!msgs.isEmpty()) getNewQuestions_lastSeen = last(msgs).ts;

  int i = indexOfLastBotAnswer(msgs);

  if (i >= 0) {

    print("Last bot answer at " + (i+1) + "/" + l(msgs) + ": " + structure(msgs.get(i)));

    // update variables

    lastAnswer = msgs.get(i).text;

    for (int j = 0; j < i; j++) {

      SlackMsg msg = msgs.get(j);

      S userName = getUserName(msg.user);

      //if (userName != null) lastPostByUser.put(userName, msg.text);

    }

    msgs = subList(msgs, i+1);

  }

  ret msgs;

}

static int indexOfLastBotAnswer(L<SlackMsg> msgs) {

  for (int i = l(msgs)-1; i >= 0; i--)

    if (msgs.get(i).botName != null) ret i;

  ret -1;

}

static synchronized S answer(S s) {

  new Matches m;

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

    reload();

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

  }

  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 void recordFeedback(S probableQuestion, S answer, S answerTime, S feedback, int score) {

  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 reload() {

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

  cleanUp(bots);

  activeBots = new ArrayList<S>();

  botsByID.clear();

  for (S botID : botIDs)

    pcall {

      loadBot(botID);

    }

}

static void reload(S botID) {

  S parsedID = "" + parseSnippetID(botID);

  Class bot = botsByID.get(parsedID);

  if (bot == null) ret;

  cleanUp(bot);

  botsByID.remove(parsedID);

  activeBots.remove(bot);

  loadBot(botID);

}

static void loadBot(S botID) {

  print("Loading bot: " + botID);

  Class c = run(botID);

  bots.add(c);

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

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

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

}

static S getUserName(S userID) {

  if (userID == null) ret null;

  S userName = userNames.get(userID);

  if (userName == null) pcall {

    userName = (S) slackGetUserInfo(token, userID).get("name");

    userNames.put(userID, userName);

  }

  ret userName;

}

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

  uri = dropPrefixMandatory("/", uri);

  if (eq(uri, ""))

    ret serveHomePage();

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

    ret serve404();

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

}

static NanoHTTPD.Response serveBot(S botID, S subUri) {

  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) {

    S botHtml = callHtmlMethod(bot, subUri);

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

    if (botHtml == null)

      botHtml = "Bot has no HTML output.";

    S title = "TinyBrain 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>TinyBrain Chat Bots</title></head>");

  buf.append("<body>");

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

  buf.append("<ul>");

  for (S botID : 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 s : scanLog("#1001915", "memory-log")) pcall {

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

  }

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

}