Blacklist+Chat+Spam

def eat(string src) {
  auto r := range(src);
  auto ret = "";
  while (!r.empty() && r.front() == ' ') {
    r.pop_front();
  }
  while (!r.empty() && r.front() != ' ') {
    ret += r.front().to_string();
    r.pop_front();
  }
  if (!r.empty()) { r.pop_front(); }
  return [ret, r.join("")];
}

def eat(string src, int n) {
  auto r := range(src);
  auto arr = [];
  auto temp = "";
  while (!r.empty() && r.front() == ' ') {
    r.pop_front();
  }
  while (!r.empty() && arr.size() < n) {
    if (r.front() == ' ') {
      arr.push_back(temp);
      temp = "";
      r.pop_front();
      while (!r.empty() && r.front() == ' ') {
        r.pop_front();
      }
      continue;
    }
    temp += r.front().to_string();
    r.pop_front();
  }
  if (!r.empty) {
    arr.push_back(r.join(""));
  }
  return arr;
}

auto BlackListDB := ProfileDB
BlackListDB.exec("CREATE TABLE IF NOT EXISTS blacklist(uuid BLOB PRIMARY KEY CHECK(valid_uuid(uuid)), reason TEXT, time TIMESTAMP DEFAULT CURRENT_TIMESTAMP) WITHOUT ROWID;");
global blacklist_list = BlackListDB.prepare("SELECT uuid, reason, time FROM blacklist;");
global blacklist_add = BlackListDB.prepare("INSERT INTO blacklist(uuid, reason) VALUES(?, ?);");
global blacklist_remove = BlackListDB.prepare("DELETE FROM blacklist WHERE uuid=?;");

setTimeout(fun() {
  while (blacklist_list.step() == ROW) {
    auto uuid := blacklist_list.get(0);
    auto reason = blacklist_list.get(1);
    addToBlacklist(uuid, reason);
  }
  blacklist_list.reset();
}, 0);

{
  defcmd("blacklist", "Show blacklist", 0, 1, fun(CommandOrigin orig, string in) {
    auto buffer = ""
    while (blacklist_list.step() == ROW) {
      auto uuid := blacklist_list.get(0);
      auto reason = blacklist_list.get(1);
      buffer += "${uuid}#${reason}\n";
    }
    buffer.rtrim();
    blacklist_list.reset();
    return buffer;
  }).add(CommandOverload());
}

{
  auto banOverload = CommandOverload();
  banOverload.add(Param_target("target", false));
  banOverload.add(Param_message("reason", true));
  defcmd2("ban", "Ban player for some reason", 0, 1, fun(CommandOrigin orig, PlayerList list, string in) {
    if (list.size() == 0) {
      return "No players selected";
    }
    auto buffer = ""
    for (item : list) {
      blacklist_add.bind(1, item.getUUID());
      blacklist_add.bind(2, in);
      blacklist_add.step();
      blacklist_add.reset();
      blacklist_add.clear();
      addToBlacklist(item.getUUID(), in);
      buffer += "Banned ${item.getNameTag()}\n";
    }
    buffer.rtrim();
    return buffer;
  }).add(banOverload);
}

{
  auto banOverload = CommandOverload();
  banOverload.add(Param_string("uuid", false));
  banOverload.add(Param_message("reason", true));
  defcmd("banuuid", "Ban player for some reason (by UUID)", 0, 1, fun(CommandOrigin orig, string in) {
    auto spd = in.eat();
    auto uuid = UUID(spd[0])
    blacklist_add.bind(1, uuid);
    blacklist_add.bind(2, spd[1]);
    blacklist_add.step();
    blacklist_add.reset();
    blacklist_add.clear();
    addToBlacklist(uuid, spd[1]);
    return "Banned UUID '${uuid}'"
  }).add(banOverload);
}

{
  auto pardonOverload = CommandOverload();
  pardonOverload.add(Param_string("uuid", false));
  defcmd("pardon", "Pardon player", 0, 1, fun(CommandOrigin orig, string in) {
    auto uuid = UUID(in)
    Log.info("pardon", in);
    blacklist_remove.bind(1, uuid);
    blacklist_remove.step();
    blacklist_remove.reset();
    blacklist_remove.clear();
    removeFromBlacklist(uuid, "Pardoned");
    return "Pardoned UUID '${uuid}'"
  })
}

auto ChatModDB := ProfileDB

WorldDB.exec("CREATE TABLE IF NOT EXISTS chat_log(id INTEGER PRIMARY KEY AUTOINCREMENT, sender_uuid BLOB CHECK(valid_uuid(sender_uuid)), sender_name TEXT, content TEXT);")
global chat_log_stmt = WorldDB.prepare("INSERT INTO chat_log(sender_uuid, sender_name, content) VALUES (?, ?, ?);")
ChatModDB.exec("CREATE TABLE IF NOT EXISTS chat_mod(uuid BLOB PRIMARY KEY CHECK(valid_uuid(uuid)), prefix TEXT, suffix TEXT, tails TEXT) WITHOUT ROWID;")
global chat_mod_query = ChatModDB.prepare("SELECT ifnull(prefix, ''), ifnull(suffix, ''), ifnull(tails, '') FROM chat_mod WHERE uuid=?;")
global chat_mod_update = [
  "prefix": ChatModDB.prepare("INSERT INTO chat_mod(uuid, prefix) VALUES (?, ?) ON CONFLICT(uuid) DO UPDATE SET prefix=excluded.prefix;"),
  "suffix": ChatModDB.prepare("INSERT INTO chat_mod(uuid, suffix) VALUES (?, ?) ON CONFLICT(uuid) DO UPDATE SET suffix=excluded.suffix;"),
  "tails": ChatModDB.prepare("INSERT INTO chat_mod(uuid, tails) VALUES (?, ?) ON CONFLICT(uuid) DO UPDATE SET tails=excluded.tails;")
];

MemDB.exec("CREATE TABLE spam_detect(uuid BLOB CHECK(valid_uuid(uuid)), time TIMESTAMP DEFAULT CURRENT_TIMESTAMP);");
global spam_add = MemDB.prepare("INSERT INTO spam_detect(uuid) VALUES(?);");
global spam_clear = MemDB.prepare("DELETE FROM spam_detect");
global spam_detect = MemDB.prepare("SELECT uuid, count(time) FROM spam_detect GROUP BY uuid;");

def addSpam(UUID uuid) {
  spam_add.bind(1, uuid);
  spam_add.step();
  spam_add.reset();
  spam_add.clear();
}

setInterval(fun() {
  try {
    while (spam_detect.step() == ROW) {
      auto uuid := spam_detect.get(0)
      auto num = spam_detect.get(1)
      if (num > 2) {
        auto player = getPlayer(uuid);
        if (!player.is_var_null()) {
          player.kick();
        }
      }
    }
    spam_detect.reset();
  } catch(e) {
    Log.error("SPAMD", e.what());
    spam_detect.reset();
  }


  spam_clear.reset();
  spam_clear.step();
}, 100);

dbus_chat_start(fun(string message) {
  forEachPlayer(fun[message](ServerPlayer n) {
    n.sendMessage("system։ " + message)
  })
})

setChatHook(fun(ServerPlayer sp, string message) {
  auto sender = sp.getNameTag();
  Log.info("CHAT", sender + ": " + message);
  dbus_chat_log(sender, message);
  auto uuid = sp.getUUID();
  addSpam(uuid);
  chat_log_stmt.bind(1, uuid);
  chat_log_stmt.bind(2, sp.getNameTag());
  chat_log_stmt.bind(3, message);
  chat_log_stmt.step();
  chat_log_stmt.reset();
  chat_log_stmt.clear();

  auto send;

  chat_mod_query.bind(1, uuid);
  switch (chat_mod_query.step()) {
    case (ROW) {
      send = fun[sender, message](n) { n.sendMessage(chat_mod_query.get(0) + sender + chat_mod_query.get(1) + "։ " + message + chat_mod_query.get(2)); };
      break;
    }
    case (DONE) {
      send = fun[sender, message](n) { n.sendMessage(sender + "։ " + message); };
    }
  }
  forEachPlayer(fun[send](ServerPlayer n) {
    send(n);
  });
  chat_mod_query.clear();
  chat_mod_query.reset();
});

{
  auto chatOverload = CommandOverload()
  chatOverload.add(Param_target_wildcard("target", false));
  auto modEnum = EnumDef("chat_mod")
  modEnum.add("prefix");
  modEnum.add("suffix");
  modEnum.add("tails");
  chatOverload.add(Param_enum("attr", false, modEnum));
  chatOverload.add(Param_message("text", false));
  defcmd2("setchat", "Set chat option to players", 0, 0, fun(orig, list, str) {
    if (list.size() == 0) {
      return "No players selected";
    }
    auto spd = str.eat();
    auto key := spd[0];
    auto value := spd[1];
    if (chat_mod_update.count(key) == 0) {
      return "Illegal attr"
    }
    auto stmt := chat_mod_update[key];
    auto res = "success";
    for (item : list) {
      stmt.bind(1, item.getUUID());
      stmt.bind(2, value);
      stmt.step();
      stmt.reset();
      stmt.clear();
    }
    return res;
  }).add(chatOverload);
}