Comando serverinfo Public

import { 
  ActionRowBuilder, 
  ButtonBuilder, 
  ButtonStyle, 
  StringSelectMenuBuilder, 
  EmbedBuilder, 
  ChannelType,
  version
} from 'discord.js';

export const name = 'serverinfo';
export const description = 'Comando de información del servidor';

function formatBytes(bytes) {
  if (bytes === 0) return '0 Bytes';
  const k = 1024;
  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
  const i = Math.floor(Math.log(bytes) / Math.log(k));
  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
}

function getMemberStatuses(guild) {
  const members = guild.members.cache;
  return {
    total: members.size,
    online: members.filter(m => m.presence?.status === 'online').size,
    idle: members.filter(m => m.presence?.status === 'idle').size,
    dnd: members.filter(m => m.presence?.status === 'dnd').size,
    offline: members.filter(m => !m.presence || m.presence.status === 'offline').size,
    bots: members.filter(m => m.user.bot).size,
    humans: members.filter(m => !m.user.bot).size
  };
}

function getVerificationLevel(level) {
  const levels = {
    0: 'NINGUNO',
    1: 'BAJO',
    2: 'MEDIO',
    3: 'ALTO',
    4: 'MUY_ALTO'
  };
  return levels[level] || 'DESCONOCIDO';
}

function getExplicitContentFilter(filter) {
  const filters = {
    0: 'DESACTIVADO',
    1: 'MIEMBROS_SIN_ROLES',
    2: 'TODOS_LOS_MIEMBROS'
  };
  return filters[filter] || 'DESCONOCIDO';
}

export async function execute(message, client) {
  const guild = message.guild;
  if (!guild) return;

  await guild.fetch();
  await guild.members.fetch({ withPresences: true }).catch(() => {});
  await guild.roles.fetch().catch(() => {});
  await guild.channels.fetch().catch(() => {});
  await guild.emojis.fetch().catch(() => {});
  await guild.stickers.fetch().catch(() => {});
  await guild.invites.fetch().catch(() => {});

  const owner = await guild.fetchOwner().catch(() => null);
  const createdAt = Math.floor(guild.createdAt.getTime() / 1000);
  const bannerURL = guild.bannerURL({ size: 1024 }) || null;
  const iconURL = guild.iconURL({ size: 512 }) || null;
  const splashURL = guild.splashURL({ size: 1024 }) || null;
  const discoverySplashURL = guild.discoverySplashURL({ size: 1024 }) || null;

  const channels = guild.channels.cache;
  const counts = {
    categories: channels.filter(c => c.type === ChannelType.GuildCategory).size,
    text: channels.filter(c => c.type === ChannelType.GuildText).size,
    voice: channels.filter(c => c.type === ChannelType.GuildVoice).size,
    stage: channels.filter(c => c.type === ChannelType.GuildStageVoice).size,
    forum: channels.filter(c => c.type === ChannelType.GuildForum).size,
    announcements: channels.filter(c => c.type === ChannelType.GuildAnnouncement).size,
    threads: channels.filter(c => c.isThread()).size,
  };

  const memberStatuses = getMemberStatuses(guild);
  
  const roles = guild.roles.cache;
  const rolesSorted = roles
    .filter(r => r.name !== '@everyone')
    .sort((a, b) => b.position - a.position);

  const emojis = guild.emojis.cache;
  const emojiStats = {
    total: emojis.size,
    animated: emojis.filter(e => e.animated).size,
    static: emojis.filter(e => !e.animated).size,
    availableSlots: guild.emojiLimit - emojis.size
  };

  const baseEmbed = new EmbedBuilder()
    .setTitle(`Información del Servidor: ${guild.name}`)
    .setThumbnail(iconURL)
    .setColor(0x5865F2)
    .addFields(
      { name: "ID del Servidor", value: `\`${guild.id}\``, inline: true },
      { name: "Propietario", value: owner ? `${owner.user.tag} (\`${owner.id}\`)` : 'N/A', inline: true },
      { name: "Creado", value: `<t:${createdAt}:F>\n(<t:${createdAt}:R>)`, inline: true },
      { name: "Nivel de Verificación", value: `\`${getVerificationLevel(guild.verificationLevel)}\``, inline: true },
      { name: "Filtro de Contenido", value: `\`${getExplicitContentFilter(guild.explicitContentFilter)}\``, inline: true },
      { name: "Características del Servidor", value: guild.features.length > 0 ? `\`${guild.features.join('`, `')}\`` : "Ninguno", inline: false },
    )
    .setTimestamp();

  if (bannerURL) baseEmbed.setImage(bannerURL);

  const membersEmbed = new EmbedBuilder()
    .setTitle("Miembros")
    .setColor(0x00A86B)
    .setDescription([
      `👥 **Total de Miembros:** ${memberStatuses.total}`,
      `🤖 **Bots:** ${memberStatuses.bots}`,
      `👤 **Humanos:** ${memberStatuses.humans}`,
      ``,
      `🟢 **En Línea:** ${memberStatuses.online}`,
      `🟡 **Ausente:** ${memberStatuses.idle}`,
      `🔴 **No Molestar:** ${memberStatuses.dnd}`,
      `⚫ **Desconectado:** ${memberStatuses.offline}`,
    ].join('\n'))
    .addFields(
      { name: "Boosters", value: `${guild.premiumSubscriptionCount || 0}`, inline: true },
      { name: "Nivel de Boost", value: `Nivel ${guild.premiumTier || 0}`, inline: true },
    );

  const channelsEmbed = new EmbedBuilder()
    .setTitle("Canales")
    .setColor(0x0099FF)
    .setDescription([
      `📊 **Total de Canales:** ${channels.size}`,
      ``,
      `📁 **Categorías:** ${counts.categories}`,
      `💬 **Canales de Texto:** ${counts.text}`,
      `🔊 **Canales de Voz:** ${counts.voice}`,
      `🎤 **Canales de Stage:** ${counts.stage}`,
      `📝 **Canales de Foro:** ${counts.forum}`,
      `📢 **Canales de Anuncios:** ${counts.announcements}`,
      `🧵 **Hilos:** ${counts.threads}`,
    ].join('\n'));

  const rolePages = [];
  const rolePageSize = 10;
  const roleList = rolesSorted.map(r => `${r.toString()} • ${r.members.size} miembros`);
  
  for (let i = 0; i < roleList.length; i += rolePageSize) {
    rolePages.push(roleList.slice(i, i + rolePageSize));
  }

  let currentRolePage = 0;

  const rolesEmbed = () => new EmbedBuilder()
    .setTitle("Roles")
    .setColor(0xFFA500)
    .setDescription(rolePages.length ? rolePages[currentRolePage].join('\n') : "No se encontraron roles")
    .setFooter({ 
      text: `Página ${rolePages.length ? currentRolePage + 1 : 0} de ${rolePages.length} • ${rolesSorted.length} roles en total` 
    });

  const emojisEmbed = new EmbedBuilder()
    .setTitle("Emojis & Stickers")
    .setColor(0x9B59B6)
    .setDescription([
      `😀 **Total de Emojis:** ${emojiStats.total}`,
      `🎬 **Animados:** ${emojiStats.animated}`,
      `🖼️ **Estáticos:** ${emojiStats.static}`,
      `📦 **Espacios Disponibles:** ${emojiStats.availableSlots}`,
      ``,
      `🏷️ **Stickers:** ${guild.stickers.cache.size}`,
    ].join('\n'));

  const securityEmbed = new EmbedBuilder()
    .setTitle("Seguridad & Moderación")
    .setColor(0xE74C3C)
    .setDescription([
      `🛡️ **Nivel de Verificación:** \`${getVerificationLevel(guild.verificationLevel)}\``,
      `🔞 **Filtro de Contenido Explícito:** \`${getExplicitContentFilter(guild.explicitContentFilter)}\``,
      `🔒 **MFA Requerido:** ${guild.mfaLevel === 1 ? '✅' : '❌'}`,
      ``,
      `📊 **Invitaciones Activas:** ${guild.invites.cache.size}`,
      `👑 **Propietario del Servidor:** ${owner ? owner.user.tag : 'N/A'}`,
    ].join('\n'));

  const mainSelect = new StringSelectMenuBuilder()
    .setCustomId('serverinfo_main')
    .setPlaceholder('Selecciona una categoría de información...')
    .addOptions(
      { label: "Información General", value: 'general', description: "Información básica del servidor" },
      { label: "Miembros", value: 'members', description: "Estadísticas y estados de miembros" },
      { label: "Canales", value: 'channels', description: "Desglose y conteo de canales" },
      { label: "Roles", value: 'roles', description: "Lista de roles del servidor" },
      { label: "Emojis & Stickers", value: 'emojis', description: "Estadísticas de emojis y stickers" },
      { label: "Seguridad & Moderación", value: 'security', description: "Configuración de seguridad y moderación" },
    );

  const rowSelect = new ActionRowBuilder().addComponents(mainSelect);

  const rowButtons = new ActionRowBuilder().addComponents(
    new ButtonBuilder().setCustomId('serverinfo_prev').setLabel('⯇ Anterior').setStyle(ButtonStyle.Secondary),
    new ButtonBuilder().setCustomId('serverinfo_next').setLabel('Siguiente ⯈').setStyle(ButtonStyle.Secondary),
    new ButtonBuilder().setLabel('Icono del Servidor').setStyle(ButtonStyle.Link).setURL(iconURL || 'https://discord.com'),
    ...(bannerURL ? [new ButtonBuilder().setLabel('Banner del Servidor').setStyle(ButtonStyle.Link).setURL(bannerURL)] : []),
    ...(splashURL ? [new ButtonBuilder().setLabel('Server Splash').setStyle(ButtonStyle.Link).setURL(splashURL)] : [])
  );

  const sent = await message.channel.send({
    embeds: [baseEmbed],
    components: [rowSelect, rowButtons],
  });

  const collector = sent.createMessageComponentCollector({ time: 10 * 60 * 1000 });

  let currentSection = 'general';

  collector.on('collect', async (interaction) => {
    if (interaction.user.id !== message.author.id) {
      return interaction.reply({ content: "Solo el autor del comando puede usar estos botones", ephemeral: true });
    }

    if (interaction.isStringSelectMenu() && interaction.customId === 'serverinfo_main') {
      const value = interaction.values[0];
      currentSection = value;
      
      const embeds = {
        general: [baseEmbed],
        members: [membersEmbed],
        channels: [channelsEmbed],
        roles: [rolesEmbed()],
        emojis: [emojisEmbed],
        security: [securityEmbed]
      };

      await interaction.update({ embeds: embeds[value] || [baseEmbed] });
      return;
    }

    if (interaction.isButton() && currentSection === 'roles') {
      if (interaction.customId === 'serverinfo_prev') {
        if (currentRolePage > 0) currentRolePage--;
        return interaction.update({ embeds: [rolesEmbed()] });
      }
      if (interaction.customId === 'serverinfo_next') {
        if (currentRolePage < Math.max(0, rolePages.length - 1)) currentRolePage++;
        return interaction.update({ embeds: [rolesEmbed()] });
      }
      return interaction.deferUpdate();
    }
  });

  collector.on('end', async () => {
    try {
      await sent.edit({ components: [] });
    } catch {}
  });
}