!7

set flag Matches_fsi.

static new L<Bot> bots;
static S whoSaidThat;
static new ThreadLocal<S> sendingAnswer;
static new ThreadLocal<Bool> dispatcherAuth;
static ThreadLocal<L<Answer>> answers = new ThreadLocal;
static boolean showMultiResponse = false;
static Set<S> reloading = syncSet();

static class Answer {
  S bot, text;
  
  *(S *bot, S *text) {}
  *() {}
}

static volatile S loadingBotID;

static class Bot {
  S id; // always formatted
  boolean enabled, always;
  double prio;
  
  *(S *id, boolean *enabled) {}
  *() {}
}

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

// wait while a bot is reloading; not used yet
static Set<S> gracePeriods = expiringSet(20.0);

static volatile long ticks;
static volatile boolean tickActionsEnabled = true;

p {
  load("bots");
  loadAll();
  
  load("ticks");
  load("tickActionsEnabled");
  //startTicking();
}

static void loadAll() {
  for (Bot bot : bots) pcall {
    loadBot(bot);
  }
}

static void loadBot(Bot bot) {
  loadingBotID = bot.id;
  try {
    Class c;
    try {
      c = hotwire(bot.id);
    } catch (Throwable e) {
      throw new RuntimeException("Error in hotwire of " + bot.id, e);
    }
    classes.put(bot.id, c);
    setOpt(c, "mainBot", getMainBot());
    try {
      callMain(c);
    } catch (Throwable e) {
      throw new RuntimeException("Error in main of " + bot.id, e);
    }
  } finally {
    loadingBotID = null;
  }
}

static Class getSubBot(S id) {
  ret getBot(id);
}

static Class getBot(S id) {
  ret classes.get(formatSnippetID(id));
}

static Bot findSubBot(S id) {
  ret findByField(bots, "id", formatSnippetID(id));
}

answer {
try {
 synchronized(main.class) {
  if "ticks" ret str(ticks);
  
  if (master()) {
    if "enable ticks" {
      tickActionsEnabled = true;
      save("tickActionsEnabled");
      ret "OK, enabled";
    }
    
    if "disable ticks" {
      tickActionsEnabled = false;
      save("tickActionsEnabled");
      ret "OK, disabled";
    }
  }
  
  if "count sub bots"
    ret lstr(getSubBots());

  if "full list sub bots"
    ret slackSnippet(structureLines(getSubBots()));

  if "list sub bots" {
    new L<S> notLoaded;
    L<Bot> bots = getSubBots();
    for (Bot bot : bots)
      if (!classes.containsKey(bot.id))
        notLoaded.add(bot.id);
    S a = "Enabled: " + structure(collectField(filterByField(bots, "enabled", true), "id")) + ". Disabled: " + structure(collectField(filterByField(bots, "enabled", false), "id"));
    if (!empty(notLoaded))
      a += ". Not loaded: " + structure(notLoaded);
    ret a;
  }
  
  if "bot prios" {
    new MultiMap<Double, S> map;
    for (Bot bot : bots)
      map.put(bot.prio, bot.id);
    map.remove(0.0);
    ret slackSnippet("Listing all but prio 0:\n"+ structureLines(map.data));
  }
    
  if "is * a sub bot?"
    ret findSubBot(m.unq(0)) != null ? "yes": "no";
    
  if (master()) {
  
    if "add sub bots *" {
      L<S> bots = (L) safeUnstructure(m.unq(0));
      new L<S> out;
      for (S id : bots) pcall {
        S q = format("add sub bot *", id);
        out.add(q + " => ");
        appendToLast(out, askSelf(q));
      }
      ret slackSnippet(fromLines(out));
    }
    if "add sub bot *" {
      S id = m.fsi(0);
      Bot bot = findSubBot(id);
      if (bot != null) {
        bots.remove(bot);
        bots.add(0, bot);
        save("bots");
        ret "OK, bumped.";
      }
      bots.add(0, bot = new Bot(id, true));
      save("bots");
      loadBot(bot);
      ret format("OK, * loaded & added to top.", id);
    }
    
    if "enable sub bot *" {
      S id = m.fsi(0);
      Bot bot = findSubBot(id);
      if (bot != null) {
        bot.enabled = true;
        save("bots");
        ret "OK, enabled.";
      }
      ret "woot";
    }
    
    if "disable sub bot *" {
      S id = m.fsi(0);
      Bot bot = findSubBot(id);
      if (bot != null) {
        bot.enabled = false;
        save("bots");
        ret "OK, disabled.";
      }
      ret "woot";
    }
    
    // an "always bot" is one that should read all msgs
    
    if "enable always bot *" {
      S id = m.fsi(0);
      Bot bot = findSubBot(id);
      if (bot != null) {
        bot.always = true;
        save("bots");
        ret "OK, has status 'always' now.";
      }
      ret "woot";
    }
    
    if "disable always bot *" {
      S id = m.fsi(0);
      Bot bot = findSubBot(id);
      if (bot != null) {
        bot.always = false;
        save("bots");
        ret "OK, lost status 'always'.";
      }
      ret "woot";
    }
    
    if "prio bot * *" {
      S id = m.fsi(0);
      double newPrio = parseDouble(m.unq(1));
      Bot bot = findSubBot(id);
      if (bot != null) {
        bot.prio = newPrio;
        save("bots");
        ret format("OK, prio changed to *", newPrio);
      }
      ret "woot";
    }
    
    if "list bot *"
      ret structure(findSubBot(m.unq(0)));

    if "remove sub bot *" {
      S id = m.fsi(0);
      Bot bot = findSubBot(id);
      if (bot != null) {
        bots.remove(bot);
        save("bots");
        
        cleanUp(classes.get(id));
        classes.remove(id);
        ret "OK, removed.";
      }
      ret "woot not there anyway";
    }
    
    if (match("reload sub bot *", s, m) || match("reload sub *", s, m)) {
      S id = m.fsi(0);
      long time = sysNow();
      Bot bot = findSubBot(id);
      if (bot != null) {
        gracePeriods.add(id);
        temp tempAdd(reloading, id);
        cleanUp(classes.get(id));
        classes.remove(id);
        loadBot(bot);
        ret "OK, reloaded in " + renderElapsedTimePleasantly_100ms(elapsedMS(time));
      }
      ret "woot not found";
    }
  }
  
  
 }
 
  // dispatch to sub bots
  
  O randomChecker = getBot("#1003005");

  L<Bot> dehbots = getSubBots();

  sendingAnswer.set(null);
  answers.set(new L);
  boolean showMultiResponse = main.showMultiResponse || tb();
  for (Bot bot : dehbots) pcall {
    if (!bot.enabled) continue;
    Class c = classes.get(bot.id);
    if (c != null) {
      //print("Dispatching to " + bot.id);
      S a = callStaticAnswerMethod(c, s);
      if (!empty(a)) {
        sendingAnswer.set(a);
        answers.get().add(new Answer(bot.id, a));
        whoSaidThat = bot.id;
        if (!showMultiResponse) {
          informAlwaysBots(subList(dehbots, dehbots.indexOf(bot)+1), s);
          ret sendingAnswer.get();
        }
      }
    }
  }
  
  if (showMultiResponse) {
    new L<Answer> nonrand;
    new L<Answer> rand;
    for (Answer a : answers.get())
      (isRandomBot(randomChecker, a.bot) ? rand : nonrand).add(a);
      
    // only show random if there is no non-random response
    if (empty(nonrand)) nonrand.addAll(rand);
    
    L<Answer> l = nonrand;
    new L<S> list;
    if (empty(l)) ret null;
    if (l(l) == 1) ret first(l).text;
    for (Answer a : l)
      setAdd(list, "[" + a.bot + "] " + a.text);
    ret fromLines(list);
  }
} catch (Throwable e) { printStackTrace(e); ret str(e); }
}

static synchronized void cleanMeUp() {
  print("Cleaning up " + l(classes) + " sub-bots");
  for (Class c : classes.values())
    cleanUp(c);
  classes.clear();
  save("ticks");
}

static void informAlwaysBots(L<Bot> bots, S s) {
  for (Bot bot : bots)
    if (bot.always) pcall {
      Class c = classes.get(bot.id);
      if (c != null) {
        S a = callStaticAnswerMethod(c, s);
        if (!empty(a))
          print("Always bot " + bot.id + " said quietly: " + quote(a));
      }
    }
}

static synchronized L<S> getSubBotIDs() {
  ret collectField(getSubBots(), "id");
}

static synchronized L<Bot> getSubBots() {
  ret reversedList(sortedByField(bots, "prio"));
  /*ret concatLists(
    filterByField(bots, "lowPrio", false),
    filterByField(bots, "lowPrio", true));*/
}

static Class getClassOfSubBot(S id) {
  ret classes.get(id);
}

// loaded / total
static int[] numLoaded() {
  ret new int[] {l(classes), l(bots) };
}

static void addSeedBot(S id) {
  Bot bot = findSubBot(id);
  if (bot != null) {
    printF("Seed bot * already there.", id);
    ret;
  }
  bots.add(0, bot = new Bot(id, true));
  save("bots");
  loadBot(bot);
  printF("OK, seed bot * loaded & added to top.", id);
}

static void startTicking() {
  thread "Ticker" {
    while true {
      if (tickActionsEnabled) pcall {
        tick();
      }
      ++ticks;
      sleep(250);
    }
  }
}

static void tick() {
  L<Bot> dehbots = getSubBots();

  for (Bot bot : dehbots) pcall {
    if (!bot.enabled) continue;
    Class c = classes.get(bot.id);
    if (c != null)
      callOpt(c, "tick");
  }
}

static S getSendingAnswer() {
  ret sendingAnswer.get();
}

static void overwriteAnswer(S a) {
  sendingAnswer.set(a);
}

static boolean isRandomBot(O randomChecker, S id) {
  if (randomChecker == null) ret false;
  pcall {
    ret (bool) call(randomChecker, "isRandomBot", id);
  }
  ret false;
}

sbool master() { ret webAuthed() || isTrue(dispatcherAuth!); }

sbool isReloading(S botID) {
  ret contains(reloading, fsIOpt(botID));
}