fenixenbot.js/src/Utils/Reload.js

Libreria Creacion De Bots De Discord

const handleEvent = require("../Handlers/EventsHandler");
const handleCommands = require("../Handlers/CommandHandler");
const handlePrefixCommands = require("../Handlers/PrrefixCommandsHandler");
const handleButtons = require("../Handlers/ButtonHandler");
const path = require("path");
const { SlashCommandBuilder, EmbedBuilder } = require("discord.js");
const registerSlashCommands = require("../Registers/registerSlashCommands");
const Color = require("../Utils/Color");

const createReloadCommand = (nameBot) => {
  const nameBots = `${nameBot}-`;
  return {
    data: new SlashCommandBuilder()
        .setName(`${nameBots || ""}reload`)
        .setDescription("Recarga los handlers especificados o todos.")
        .addStringOption((option) =>
            option
                .setName("tipo")
                .setDescription("Tipo de handler a recargar")
                .setRequired(false)
                .addChoices(
                    { name: "events", value: "events" },
                    { name: "commands", value: "commands" },
                    { name: "prefixcommands", value: "prefixcommands" },
                    { name: "buttons", value: "buttons" },
                    { name: "modelsDB", value: "modelsDB" },
                    { name: "all", value: "all" }
                )
        ),
    async execute(interaction) {
      const tipoRecarga = interaction.options.getString("tipo");
      const handlerPaths = interaction.client.handlerPaths;
      let recargadoConExito = true;
      let mensajesRecarga = [];
      // **Movemos la declaración de reloadCommand AQUÍ, dentro de execute**
      const reloadCommand = createReloadCommand(interaction.client.nameBot);


      if (!tipoRecarga || tipoRecarga === "all") {
        await interaction.deferReply({ flags: 64 });
        const handlersARecargar = [
          {
            tipo: "eventos",
            handler: handleEvent,
            ruta: handlerPaths.eventHandlerPath,
            nombre: "eventos",
          },
          {
            tipo: "comandos slash",
            handler: handleCommands,
            ruta: handlerPaths.commandsHandlerPath,
            nombre: "comandos slash",
          },
          {
            tipo: "comandos prefix",
            handler: handlePrefixCommands,
            ruta: handlerPaths.prefixCommandsHandlerPath,
            nombre: "comandos de prefijo",
          },
          {
            tipo: "botones",
            handler: handleButtons,
            ruta: handlerPaths.buttonsHandlerPath,
            nombre: "botones",
          },
          {
            tipo: "modelsDB",
            handler: handleModels,
            ruta: handlerPaths.modelsHandlerPath,
            nombre: "modelsDB",
          },
        ];

        for (const h of handlersARecargar) {
          if (h.ruta) {
            try {
              h.handler(interaction.client, h.ruta);
              if (h.tipo === "comandos slash") {
                // **Aseguramos que el comando reload siempre esté presente antes de registrar**
                if (!interaction.client.commands.has(reloadCommand.data.name)) {
                  interaction.client.commands.set(reloadCommand.data.name, reloadCommand);
                }
                await registerSlashCommands(
                    interaction.client.token,
                    interaction.client.clientId,
                    [...interaction.client.commands.values()]
                );
              }
              mensajesRecarga.push(`✅ ${h.tipo} recargados.`);
            } catch (error) {
              console.error(`Error al recargar ${h.nombre}:`, error);
              mensajesRecarga.push(
                  `❌ Error al recargar ${h.tipo}. Revisa la consola para detalles.`
              );
              recargadoConExito = false;
            }
          } else {
            mensajesRecarga.push(
                `⚠️ Handler de ${h.tipo} no configurado, omitiendo.`
            );
          }
        }
      } else {
        await interaction.deferReply({ flags: 64 });

        switch (tipoRecarga) {
          case "events":
            if (handlerPaths.eventHandlerPath) {
              try {
                handleEvent(interaction.client, handlerPaths.eventHandlerPath);
                mensajesRecarga.push("✅ Eventos recargados.");
              } catch (error) {
                console.error("Error al recargar eventos:", error);
                mensajesRecarga.push(
                    "❌ Error al recargar eventos. Revisa la consola para detalles."
                );
                recargadoConExito = false;
              }
            } else {
              mensajesRecarga.push("⚠️ Handler de eventos no configurado.");
            }
            break;

          case "commands":
            if (handlerPaths.commandsHandlerPath) {
              try {
                handleCommands(
                    interaction.client,
                    handlerPaths.commandsHandlerPath
                );
                // **Aseguramos que el comando reload siempre esté presente antes de registrar**
                if (!interaction.client.commands.has(reloadCommand.data.name)) {
                  // **Volvemos a crear reloadCommand AQUÍ si no existe**
                  const reloadCommand = createReloadCommand(interaction.client.nameBot);
                  interaction.client.commands.set(reloadCommand.data.name, reloadCommand);
                }
                await registerSlashCommands(
                    interaction.client.token,
                    interaction.client.clientId,
                    [...interaction.client.commands.values()]
                );
                mensajesRecarga.push("✅ Comandos slash recargados.");
              } catch (error) {
                console.error("Error al recargar comandos slash:", error);
                mensajesRecarga.push(
                    "❌ Error al recargar comandos slash. Revisa la consola para detalles."
                );
                recargadoConExito = false;
              }
            } else {
              mensajesRecarga.push(
                  "⚠️ Handler de comandos slash no configurado."
              );
            }
            break;

          case "prefixcommands":
            if (handlerPaths.prefixCommandsHandlerPath) {
              try {
                handlePrefixCommands(
                    interaction.client,
                    handlerPaths.prefixCommandsHandlerPath
                );
                mensajesRecarga.push("✅ Comandos de prefijo recargados.");
              } catch (error) {
                console.error("Error al recargar comandos de prefijo:", error);
                mensajesRecarga.push(
                    "❌ Error al recargar comandos de prefijo. Revisa la consola para detalles."
                );
                recargadoConExito = false;
              }
            } else {
              mensajesRecarga.push(
                  "⚠️ Handler de comandos de prefijo no configurado."
              );
            }
            break;

          case "buttons":
            if (handlerPaths.buttonsHandlerPath) {
              try {
                handleButtons(
                    interaction.client,
                    handlerPaths.buttonsHandlerPath
                );
                mensajesRecarga.push("✅ Botones recargados.");
              } catch (error) {
                console.error("Error al recargar botones:", error);
                mensajesRecarga.push(
                    "❌ Error al recargar botones. Revisa la consola para detalles."
                );
                recargadoConExito = false;
              }
            } else {
              mensajesRecarga.push("⚠️ Handler de botones no configurado.");
            }
            break;
          default:
            mensajesRecarga.push("⚠️ Tipo de recarga no válido.");
            recargadoConExito = false;
            break;
        }
      }

      const respuestaEmbed = new EmbedBuilder()
          .setTitle("Recarga de Handlers")
          .setDescription(mensajesRecarga.join("\n"));

      await interaction.editReply({
        embeds: [respuestaEmbed],
        flags: 64,
      });

      if (!recargadoConExito) {
        console.warn(
            "Recarga de handlers completada con errores. Revisa los mensajes de error detallados en la consola."
        );
      }
    },
  };
};

function reload(
    client,
    clientId,
    Discord,
    commandsHandler,
    eventHandler,
    buttonsHandler,
    prefixCommandsHandler,
    token,
    nameBot
) {
  // Inicializar colecciones solo si no existen
  if (!client.commands) client.commands = new Discord.Collection();
  if (!client.events) client.events = new Discord.Collection();
  if (!client.buttons) client.buttons = new Discord.Collection();
  if (!client.prefix) client.prefix = new Discord.Collection();

  client.nameBot = nameBot;
  client.token = token;
  client.clientId = clientId;

  client.handlerPaths = {
    commandsHandlerPath: commandsHandler ? path.resolve(commandsHandler) : null,
    eventHandlerPath: eventHandler ? path.resolve(eventHandler) : null,
    buttonsHandlerPath: buttonsHandler ? path.resolve(buttonsHandler) : null,
    prefixCommandsHandlerPath: prefixCommandsHandler
        ? path.resolve(prefixCommandsHandler)
        : null,
  };

  const reloadCommand = createReloadCommand(nameBot);

  client.on("ready", async () => {
    if (!client.commands.has(reloadCommand.data.name)) {
      client.commands.set(reloadCommand.data.name, reloadCommand);
    }

  });
}

module.exports = reload;