import { DebugBuilder } from "../../modules/debugger.mjs";
const log = new DebugBuilder("server", "discordBot.modules.wrappers");
import {
  checkIfNodeIsConnectedToVC,
  getNodeDiscordID,
  getNodeDiscordUsername,
  checkIfNodeHasOpenDiscordClient,
  getNodeCurrentListeningSystem,
  requestNodeJoinSystem,
} from "../../modules/socketServerWrappers.mjs";
import { getAllDiscordIDs } from "../../modules/mongo-wrappers/mongoDiscordIDWrappers.mjs";
import { ActionRowBuilder, ButtonBuilder, ButtonStyle } from "discord.js";

export const checkOnlineBotsInGuild = async (nodeIo, guildId) => {
  let onlineBots = [];
  const openSockets = [...(await nodeIo.allSockets())];
  await Promise.all(
    openSockets.map(async (openSocket) => {
      openSocket = await nodeIo.sockets.sockets.get(openSocket);
      const connected = await checkIfNodeIsConnectedToVC(
        nodeIo,
        guildId,
        openSocket.node.nuid,
      );
      log.INFO("Connected:", connected);
      if (connected) {
        const username = await getNodeDiscordUsername(openSocket, guildId);
        const discordID = await getNodeDiscordID(openSocket);
        onlineBots.push({
          name: username,
          discord_id: discordID,
          nuid: openSocket.node.nuid,
        });
      }
    }),
  );

  return onlineBots;
};

export const getAvailableTokensInGuild = async (nodeIo, guildId) => {
  try {
    // Execute both asynchronous functions concurrently
    const [discordIDs, onlineBots] = await Promise.all([
      getAllDiscordIDs(), // Fetch all Discord IDs
      checkOnlineBotsInGuild(nodeIo, guildId), // Check online bots in the guild
    ]);

    // Use the results of both promises here
    log.INFO("Available Discord IDs:", discordIDs);
    log.INFO("Online bots in the guild:", onlineBots);

    // Filter any discordIDs that are not active
    const availableDiscordIDs = discordIDs
      .filter((discordID) => discordID.active == true)
      .filter(
        (discordID) =>
          !onlineBots.some(
            (bot) => Number(bot.discord_id) == discordID.discord_id,
          ),
      );

    // Return the unavailable discordIDs
    return availableDiscordIDs;
  } catch (error) {
    console.error("Error getting available tokens in guild:", error);
    throw error;
  }
};

/**
 * Get the nodes with given system that are available to be used within a given server
 * @param {any} nodeIo The nodeIO object contained in the discord server object
 * @param {any} guildId The guild ID to search in
 * @param {any} system The system to filter the nodes by
 * @returns {any}
 */
export const getAvailableNodes = async (nodeIo, guildId, system) => {
  // Get all open socket nodes
  const openSockets = [...(await nodeIo.allSockets())]; // TODO - Filter the returned nodes to only nodes that have the radio capability
  log.DEBUG("All open sockets: ", openSockets);

  var availableNodes = [];
  // Check each open socket to see if the node has the requested system
  await Promise.all(
    openSockets.map(async (openSocket) => {
      openSocket = await nodeIo.sockets.sockets.get(openSocket);
      // Check if the node has an existing open client (meaning the radio is already being listened to)
      const hasOpenClient = await checkIfNodeHasOpenDiscordClient(openSocket);
      if (hasOpenClient) {
        let currentSystem = await getNodeCurrentListeningSystem(openSocket);
        if (currentSystem != system.name) {
          log.INFO(
            "Node is listening to a different system than requested",
            openSocket.node.name,
          );
          return;
        }
      }

      // Check if the bot has an open voice connection in the requested server already
      const connected = await checkIfNodeIsConnectedToVC(
        nodeIo,
        guildId,
        openSocket.node.nuid,
      );
      log.INFO("Connected:", connected);
      if (!connected) {
        // Check if this node has the requested system, if so add it to the availble array
        if (system.nodes.includes(openSocket.node.nuid)) {
          availableNodes.push(openSocket);
        }
      }
    }),
  );

  log.DEBUG(
    "Availble nodes:",
    availableNodes.map((socket) => socket.node.name),
  );

  return availableNodes;
};

/**
 * Gets the voice channel the user is currently in.
 * @param {any} interaction - The interaction object.
 * @returns {any} - The voice channel object, or null if the user is not in a voice channel.
 */
export const getUserVoiceChannel = (interaction) => {
  if (!interaction.member.voice.channel) {
    interaction.editReply({
      content: `<@${interaction.member.id}>, you need to enter a voice channel before using this command`,
      ephemeral: true,
    });
    return null;
  }
  return interaction.member.voice.channel;
};

/**
 * Joins a node to a specified system and voice channel.
 * @param {any} nodeIo - The nodeIO server for manipulation of sockets.
 * @param {any} interaction - The interaction object.
 * @param {string} nodeId - The ID of the node to join.
 * @param {any} system - The system object to join.
 * @param {any} channel - The voice channel to join.
 */
export const joinNode = async (
  nodeIo,
  interaction,
  nodeId,
  system,
  channel,
) => {
  try {
    const openSocket = await nodeIo.sockets.sockets.get(nodeId);
    const discordTokens = await getAvailableTokensInGuild(
      nodeIo,
      interaction.guild.id,
    );

    if (discordTokens.length === 0) {
      await interaction.editReply({
        content: `<@${interaction.member.id}>, there are no free bots available.`,
        ephemeral: true,
      });
      return;
    }

    log.INFO(
      "Joining node:",
      nodeId,
      system.name,
      channel.id,
      openSocket.node.name,
      discordTokens[0].token,
    );
    await requestNodeJoinSystem(
      openSocket,
      system.name,
      channel.id,
      discordTokens[0].token,
    );

    await interaction.editReply({
      content: `<@${interaction.member.id}>, a bot will join your channel listening to '${system.name}' shortly.`,
      ephemeral: true,
    });
  } catch (err) {
    log.ERROR("Failed to join node:", err);
    await interaction.editReply({
      content: `<@${interaction.member.id}>, an error occurred while joining the node: ${err.message}`,
      ephemeral: true,
    });
  }
};

/**
 * Prompts the user to select a node from available nodes.
 * @param {any} interaction - The interaction object.
 * @param {Array} availableNodes - The list of available nodes.
 * @param {Function} onNodeSelected - Callback function to handle the selected node.
 */
export const promptNodeSelection = async (
  interaction,
  availableNodes,
  onNodeSelected,
) => {
  const nodeSelectionButtons = availableNodes.map((node) =>
    new ButtonBuilder()
      .setCustomId(node.id)
      .setLabel(node.node.name)
      .setStyle(ButtonStyle.Primary),
  );

  const actionRow = new ActionRowBuilder().addComponents(nodeSelectionButtons);

  const response = await interaction.editReply({
    content: `<@${interaction.member.id}>, please select the Node you would like to join with this system:`,
    components: [actionRow],
    ephemeral: true,
  });

  const collectorFilter = (i) => i.user.id === interaction.user.id;
  try {
    const selectedNode = await response.awaitMessageComponent({
      filter: collectorFilter,
      time: 60_000,
    });
    await onNodeSelected(selectedNode.customId);
  } catch (e) {
    log.ERROR("Node selection timeout:", e);
    await interaction.editReply({
      content: "Confirmation not received within 1 minute, cancelling.",
      components: [],
    });
  }
};