ZSR Interactive Session

const userSessionEmojiTable = [":one:", ":two:"];
var userSessionsInput = {};

function onMessage(message) {
    //Somewhere in the code
    if (message.content == "!assignToRace") {
        startInteractiveBotSession("raceAssign", message).then(() => {
            console.log("session ended, delete message");
            message.delete();
        });
    }
}

async function startInteractiveBotSession(name, message) {

    try {
        //All the interactive session commands we support
        switch (name) {
            case "raceAssign": {
                return await raceAssignSession(message);
            }
         }
    }
    catch (ex) {
        console.log("Aborted session cause:", ex);
    }
}

async function raceAssignSession(message) {

  try{

  //Say hello
  let messagePointer = await renderRaceAssignEmbed("intro", message);

  //Wait for yes or no
  let userResponse = await waitForUserInput(messagePointer, message.member);

  //Verify to which number the emoji belongs if reaction or otherwise look at the message content and do something/branch off
  let pressedNo = userResponse.isReaction && userResponse.data == 2 || !userResponse.isReaction && userResponse.data.content == "No";

  if (pressedNo) {
    await renderRaceAssignEmbed("aborted", messagePointer, true);
    return;
  }

  //User wants to continue. Time to select the person
  messagePointer = await renderRaceAssignEmbed("selectPerson", messagePointer, true, { user: message.member });

  //Wait for person selection
  let userResponsePerson = await waitForUserInput(messagePointer, message.member);

  if (userResponsePerson.isReaction) {
    //User selected a pre-defined person from our list
  }
  else {
    //User entered a completely new name presumably. Verify and get name from userResponsePerson.data (= the message)
  }

  console.log("Session finished. Set data to replicant now!");
  await renderRaceAssignEmbed("finished", messagePointer, true, { selectedPerson: "Trez" });
  } catch (ex) {
   if (typeof(ex) == "string" and ex == "no_response") {
      await renderRaceAssignEmbed("aborted", messagePointer, true);
   }
  }
 }

async function renderRaceAssignEmbed(phase, message, editExisting = false, extraInfo = null) {

    let embed;
    let menuOptionsCount;

    //All our session phases and possibilities we need an embed for
    switch (phase) {
        case "intro": { //user just started
            embed = { text: "hey there, here is my start embed. My options are explained here. Press 1 for yes and 2 for no" };
            menuOptionsCount = 2;
            break;
        }
        case "selectPerson": { //user selects a person
            embed = { text: `hey there ${extraInfo.user.name}, now select from this list of runners or enter a new name!` };
            menuOptionsCount = 5;
            break;
        }
        case "finished": { //user finished the process
            embed = { text: `Thank you! You selected: ${extraInfo.selectedPerson}` };
            menuOptionsCount = 0;
            break;
        }
        case "aborted": { //user aborted the process
            embed = { text: "Too bad. Process aborted!" };
            menuOptionsCount = 0;
            break;
        }
    }

    return await renderUserSessionEmbed(message, embed, menuOptionsCount, editExisting);
}

async function renderUserSessionEmbed(message, embed, menuOptionsCount, editExisting) {

    let messagePointer;

    if (!editExisting) {
        messagePointer = await message.reply(embed);
    }
    else {
        await message.reactions.removeAll();
        messagePointer = await message.edit(embed);
    }

    //Add reaction emojis to posted or edited message
    let reactions = [];

    for (let i = 0; i < menuOptionsCount; i++) {

        let emoji = emojiIndexToName(i); //1-x number reaction emoji

        reactions.push(messagePointer.react(emoji));
    }

    await Promise.all(reactions);

    return messagePointer;
}

function waitForUserInput(message, user) {

    return new Promise((resolve, reject) => {

        let timeout = setTimeout(() => {
            delete userSessionsInput[message.id];
            reject("no_response");
        }, 10000);

        userSessionsInput[message.id] = { message, user, resolve, reject, timeout };
    });
}

function emojiIndexToName(index) {
   return userSessionEmojiTable[index];
}

function emojiNameToIndex(emoji) {
   return userSessionEmojiTable.indexOf(emoji) + 1;
}

//Client Events
bot.on("messageReactionAdd", (messageReaction, user) => {

    //Check for active user session reaction
    for (let value of Object.values(userSessionsInput)) {

        let channelMessage = value.message;
        let channelUser = value.user;

        if (messageReaction.message.id == channelMessage.id && user.id == channelUser.id) {

            if (value.timeout)
                clearTimeout(value.timeout);

            value.resolve({ isReaction: true, data: emojiNameToIndex(messageReaction.emoji.name) });
            delete userSessionsInput[channelMessage.id];
        }
    }
});

bot.on("message", (message) => {

    //Check for active user session reply
    for (let value of Object.values(userSessionsInput)) {

        let channelMessage = value.message;
        let channelUser = value.user;

        if (channelMessage.channel.id == message.channel.id && channelUser.id == message.member.id) {

            if (value.timeout)
                clearTimeout(value.timeout);

            value.resolve({ isReaction: false, data: message });
            delete userSessionsInput[channelMessage.id];
        }
    }

    //The entire rest of the existing ZSR message handling code
    onMessage(message);
});