sS botUserName = "electron";

sS logFile = "slack.log";

static new ThreadLocal<Bool> dedicated;

static new ThreadLocal<Channel> channel;

static new ThreadLocal<S> slackUserName;

static int maxAnswerLength = 1000, shortenTo = 200;

sbool actuallyPost = true;

static int slackSpeed = 5000, slackTimeout = 20000;

static int historySuckSize = 1;

sbool checkReactions = false;

static new L actionsAfterPost;

static new L<Channel> channels;

static class Channel {

  S channelName; // includes the site

  S channelID, token;

  boolean generalRelease, postAsUser, dedicated;

  boolean firstTime = true;

  new Map<S, Map> userInfos;

  S lastQuestion, lastAnswer;

  S lastAnswerTimestamp; // only for posted in this session

  int lastAnswerScore;

  void tendTo() {

    if (lastAnswerTimestamp != null && checkReactions) {

      // 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) if (!isMyAnswer(msg)) {

      S q = msg.text;

      S userName = getUserName(msg.user);

      Map userInfo = getUserInfo(msg.user);

      if (userInfo != null && eq(true, userInfo.get("is_bot"))) {

        print("Skipping question from bot " + userName + ": " + quote(q));

        continue;

      }

      slackUserName.set(userName);

      q = q.trim();

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

      print("dedicated: " + dedicated);

      main.dedicated.set(dedicated);

      main.channel.set(this);

      S a;

      try {

        a = callStaticAnswerMethod(q);

      } catch e {

        printStackTrace(e);

        a = "?" + getInnerMessage(e);

      }

      logStructure(logFile, ll(now(), channelID, channelName, msg.ts, msg.userName, a));

      if (nempty(a)) {

        // slack snippets have some size limit - let's forget that

        /*if (l(a) > maxAnswerLength)

          a = "```" + a + "```";*/

        // post long stuff to tinybrain instead

        if (l(a) > maxAnswerLength) {

          S title = "Answer for " + userName + " (>> " + q + ")";

          S id = ntUpload("eleutheria-for-user", title, unSlackSnippet(a));

          boolean isSnippet = a.contains("```");

          a = shorten(a, shortenTo) + (isSnippet ? "```" : "") + "\nFull answer here: tinybrain.de/" + parseSnippetID(id);

        }

        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, "answertime", answerTime, "answer", a, "user", userName, "dedicated", dedicated);

          //historyAdd(logEntry);

        }

      }

    }

  }

  Map getUserInfo(S userID) {

    if (userID == null) ret null;

    Map userInfo = userInfos.get(userID);

    if (userInfo == null) pcall {

      userInfo = slackGetUserInfo(token, userID);

      userInfos.put(userID, userInfo);

    }

    ret userInfo;

  }

  S getUserName(S userID) {

    Map userInfo = getUserInfo(userID);

    ret userInfo == null ? null : (S) userInfo.get("name");

  }

  // returns the slack timestamp

  S postAnswer(S text) {

    S postAs = null; // main.postAs.get();

    S username = or(postAs, botUserName);

    S botIcon = null; // main.botIcon.get();

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

    Map postData = litmap(

      "token", token,

      "channel", channelID,

      "text", text,

      "username", username/*,

      "parse", "none",

      "link_names", "1"*/,

      "icon_url", botIcon);

    if (postAsUser && postAs == null)

      postData.put("as_user", "true");

    printStructure(postData);

    S data = doPostWithTimeout(postData, url, slackTimeout);

    Map map = jsonDecodeMap(data);

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

    lastAnswerScore = 0;

    print("postAnswer: " + data);

    ret lastAnswerTimestamp;

  }

  S getNewQuestions_lastSeen;

  L<SlackMsg> getNewQuestions() {

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

    // and 1000 thereafter (just grab anything new)

    int limit = getNewQuestions_lastSeen == null ? historySuckSize : 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);

      }

      if (firstTime)

        msgs = subList(msgs, i+1);

    }

    firstTime = false;

    ret msgs;

  }

} // end of class Channel

static boolean slackBot_inited;

static void initSlackBot() {

  if (slackBot_inited) ret;

  slackBot_inited = true;

  Channel c;

  c = new Channel;

  c.channelName = "xwired, #allgemein";

  c.channelID = "C9FAC6EAE";

  c.token = electronToken();

  c.postAsUser = true;

  c.dedicated = false;

  channels.add(c);

}

static int indexOfLastBotAnswer(L<SlackMsg> msgs) {

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

    if (isMyAnswer(msgs.get(i))) ret i;

  ret -1;

}

static boolean isMyAnswer(SlackMsg msg) {

  ret msg.botName != null /*|| actualBotUserNames.contains(msg.userName)*/;

}

static void slackBotLoop() {

  slackSetTimeout(slackTimeout);

  try {

    long lastPrinted = now();

    while licensed {

      runAndClear(actionsAfterPost);

      for (Channel c : channels) pcall {

        c.tendTo();

      }

      sleep(slackSpeed);

      if (now() > lastPrinted + 60*1000) {

        lastPrinted = now();

        print("Slack loop still going. " + unixTime());

      }

    }

  } finally {

    print("Slack bot loop exit!?");

  }

}

static void sayInDedicated(S s) {

  for (Channel c : channels) pcall {

    if (c.dedicated)

      c.postAnswer(s);

  }

}

static void dediSay(S s) {

  sayInDedicated(s);

}