ping-bot.js

/**
 * Fluxer Example Bot
 *
 * Demonstrates prefix commands, embeds, DMs, voice join, audio, and video playback.
 * DMs: !dm (DM yourself), !dmuser @user [message] (DM another user).
 * Guild profile: !setnick [nickname] (change nickname), !setavatar [url] (change guild avatar).
 * Voice: !play (joins your VC and plays WebM/Opus audio via youtube-dl-exec). No FFmpeg.
 * Video: !playvideo [url] [480p|720p|1080p|1440p|4k] (streams MP4 in your VC; default 720p 30fps).
 *   Resolution forces FFmpeg path. Set FLUXER_VIDEO_FFMPEG=1 to use FFmpeg without resolution.
 * !stop stops playback and leaves.
 *
 * Usage (from repo root after npm install && npm run build):
 *   FLUXER_BOT_TOKEN=your_token node examples/ping-bot.js
 *
 * Optional env: FLUXER_API_URL for custom API base; VOICE_DEBUG=1 for voice connection logs;
 * SETAVATAR_DEBUG=1 for guild avatar request/response logs.
 */

import youtubedl from 'youtube-dl-exec';
import {
  Client,
  Events,
  EmbedBuilder,
  Routes,
  User,
  VoiceChannel,
  cdnBannerURL,
  cdnMemberAvatarURL,
  UserFlagsBits,
  PermissionFlags,
} from '@fluxerjs/core';
import { getVoiceManager, LiveKitRtcConnection } from '@fluxerjs/voice';

/** Fixed non‑copyrighted track; we get a direct WebM/Opus URL so the voice package can play without FFmpeg. */
const PLAY_URL = 'https://www.youtube.com/watch?v=eVTXPUF4Oz4';
const YTDLP_FORMAT = 'bestaudio[ext=webm][acodec=opus]/bestaudio[ext=webm]/bestaudio';

/** Default MP4 video URL for !playvideo (short public domain clip). Must be direct MP4 (H.264). */
const DEFAULT_VIDEO_URL = 'https://www.w3schools.com/html/mov_bbb.mp4';

/** yt-dlp format for MP4 video (prefer 1080p, then 720p, 360p, then best). */
const YTDLP_VIDEO_FORMAT =
  'best[height<=1080][ext=mp4]/best[height<=1080]/22/18/best[ext=mp4]/best';

/** Regex for YouTube and similar sites that yt-dlp supports for video extraction. */
const YOUTUBE_LIKE = /youtube\.com|youtu\.be|yt\.be/i;

async function getStreamUrl(url) {
  const result = await youtubedl(
    url,
    {
      getUrl: true,
      f: YTDLP_FORMAT,
      formatSort: 'acodec:opus',
      noWarnings: true,
      noPlaylist: true,
    },
    { timeout: 15000 },
  );
  return String(result ?? '').trim();
}

/** Get a direct MP4 video URL from YouTube or similar. Returns null on failure. */
async function getVideoUrl(url) {
  const result = await youtubedl(
    url,
    {
      getUrl: true,
      f: YTDLP_VIDEO_FORMAT,
      noWarnings: true,
      noPlaylist: true,
    },
    { timeout: 20000 },
  );
  return String(result ?? '').trim() || null;
}

// ─────────────────────────────────────────────────────────────────────────────
// Configuration
// ─────────────────────────────────────────────────────────────────────────────

const PREFIX = '!';

/** Per-guild play state for auto-reconnect when LiveKit server sends leave. */
const playState = new Map();

function setPlayState(guildId, channel, streamUrl) {
  playState.set(guildId, { channel, streamUrl });
}

function clearPlayState(guildId) {
  playState.delete(guildId);
}
const BRAND_COLOR = 0x4641d9;

// ─────────────────────────────────────────────────────────────────────────────
// Helpers
// ─────────────────────────────────────────────────────────────────────────────

/** Format milliseconds into human-readable uptime. */
function formatUptime(ms) {
  const seconds = Math.floor(ms / 1000) % 60;
  const minutes = Math.floor(ms / (1000 * 60)) % 60;
  const hours = Math.floor(ms / (1000 * 60 * 60)) % 24;
  const days = Math.floor(ms / (1000 * 60 * 60 * 24));

  const parts = [];
  if (days > 0) parts.push(`${days}d`);
  if (hours > 0) parts.push(`${hours}h`);
  if (minutes > 0) parts.push(`${minutes}m`);
  parts.push(`${seconds}s`);

  return parts.join(' ');
}

/** Measure REST API latency by timing a lightweight request. */
async function measureApiLatency(client) {
  const start = Date.now();
  try {
    await client.rest.get(Routes.gatewayBot());
  } catch {
    // Ignore errors; we just want the round-trip time
  }
  return Date.now() - start;
}

/** Resolve a user ID from the first argument: mention (<@id> or <@!id>) or raw snowflake. Returns null if invalid. */
function resolveUserId(arg, authorId) {
  if (!arg) return authorId;
  const mentionMatch = arg.match(/^<@!?(\d+)>$/);
  if (mentionMatch) return mentionMatch[1];
  if (/^\d{17,19}$/.test(arg)) return arg;
  return null;
}

// ─────────────────────────────────────────────────────────────────────────────
// Command Handlers
// ─────────────────────────────────────────────────────────────────────────────

const commands = new Map();

commands.set('ping', {
  description: 'Check bot and API latency',
  async execute(message, client) {
    const apiLatency = await measureApiLatency(client);

    const embed = new EmbedBuilder()
      .setTitle('Pong!')
      .setColor(BRAND_COLOR)
      .addFields({ name: 'API Latency', value: `\`${apiLatency}ms\``, inline: true })
      .setFooter({ text: 'Fluxer Bot' })
      .setTimestamp();

    await message.reply({ embeds: [embed.toJSON()] });
  },
});

commands.set('info', {
  description: 'Display bot information',
  async execute(message, client) {
    const uptime = client.readyAt ? Date.now() - client.readyAt.getTime() : 0;
    const apiLatency = await measureApiLatency(client);

    const embed = new EmbedBuilder()
      .setTitle('Bot Information')
      .setColor(BRAND_COLOR)
      .setThumbnail(client.user?.avatarURL?.() ?? null)
      .addFields(
        { name: 'Username', value: client.user?.username ?? 'Unknown', inline: true },
        { name: 'Guilds', value: `${client.guilds.size}`, inline: true },
        { name: 'Channels', value: `${client.channels.size}`, inline: true },
        { name: 'Uptime', value: formatUptime(uptime), inline: true },
        { name: 'API Latency', value: `${apiLatency}ms`, inline: true },
        { name: 'Node.js', value: process.version, inline: true },
      )
      .setFooter({ text: 'Powered by @fluxerjs/core' })
      .setTimestamp();

    await message.reply({ embeds: [embed.toJSON()] });
  },
});

commands.set('setnick', {
  description: "Change the bot's nickname in this server (!setnick [nickname])",
  async execute(message, client, args) {
    const guildId = message.guildId;
    if (!guildId) {
      await message.reply('Use this command in a server.');
      return;
    }
    const guild = client.guilds.get(guildId) ?? (await client.guilds.fetch(guildId));
    if (!guild) {
      await message.reply('Could not find this server.');
      return;
    }
    const me = guild.members.me ?? (await guild.members.fetchMe());
    const newNick = args.join(' ').trim() || null;
    try {
      await me.edit({ nick: newNick });
      await message.reply(
        newNick
          ? `Nickname set to \`${newNick}\` in this server.`
          : 'Nickname cleared (showing username again).',
      );
    } catch {
      await message
        .reply('Failed to change nickname. The bot may need Change Nickname permission.')
        .catch(() => {});
    }
  },
});

const SETAVATAR_DEBUG =
  process.env.SETAVATAR_DEBUG === '1' || process.env.SETAVATAR_DEBUG === 'true';

commands.set('setavatar', {
  description: "Change the bot's guild avatar (!setavatar [image URL] or !setavatar clear)",
  async execute(message, client, args) {
    const guildId = message.guildId;
    if (!guildId) {
      await message.reply('Use this command in a server.');
      return;
    }
    const guild = client.guilds.get(guildId) ?? (await client.guilds.fetch(guildId));
    if (!guild) {
      await message.reply('Could not find this server.');
      return;
    }
    const me = guild.members.me ?? (await guild.members.fetchMe());
    const arg = args[0]?.toLowerCase();
    if (arg === 'clear' || arg === 'reset') {
      try {
        if (SETAVATAR_DEBUG) {
          console.log(
            '[setavatar] PATCH /guilds/%s/members/@me with avatar: null (clear)',
            guildId,
          );
        }
        await me.edit({ avatar: null });
        if (SETAVATAR_DEBUG) {
          const updated = await guild.fetchMember(me.id);
          console.log('[setavatar] Response: avatar=%s', updated.avatar ?? 'null');
        }
        await message.reply('Guild avatar cleared. Showing global avatar again.');
      } catch (err) {
        if (SETAVATAR_DEBUG) console.error('[setavatar] Clear failed:', err);
        await message.reply('Failed to clear guild avatar.').catch(() => {});
      }
      return;
    }
    const url = args[0]?.trim();
    if (!url || (!url.startsWith('http://') && !url.startsWith('https://'))) {
      await message.reply(
        'Provide an image URL: `!setavatar https://example.com/image.png` or `!setavatar clear` to reset.',
      );
      return;
    }
    try {
      const controller = new AbortController();
      const timeout = setTimeout(() => controller.abort(), 30000);
      const res = await fetch(url, { signal: controller.signal });
      clearTimeout(timeout);
      if (!res.ok) {
        await message.reply(`Could not fetch image: ${res.status}`);
        return;
      }
      const contentType = res.headers.get('content-type') ?? 'image/png';
      const mime = contentType.split(';')[0].trim();
      if (!mime.startsWith('image/')) {
        await message.reply('URL must point to an image (png, jpeg, gif, webp).');
        return;
      }
      const buf = Buffer.from(await res.arrayBuffer());
      const base64 = buf.toString('base64');
      const dataUri = `data:${mime};base64,${base64}`;
      if (SETAVATAR_DEBUG) {
        console.log(
          '[setavatar] PATCH /guilds/%s/members/@me with avatar (dataUri len=%d, mime=%s)',
          guildId,
          dataUri.length,
          mime,
        );
      }
      await me.edit({ avatar: dataUri });
      const updated = await guild.fetchMember(me.id);
      if (SETAVATAR_DEBUG) {
        console.log('[setavatar] Response: avatar=%s', updated.avatar ?? 'null');
      }
      if (dataUri && !updated.avatar) {
        await message.reply(
          'Request succeeded but the avatar was not applied. On Fluxer, guild avatars require a premium subscription—bots cannot set guild avatars.',
        );
      } else {
        await message.reply('Guild avatar updated!');
      }
    } catch (err) {
      if (SETAVATAR_DEBUG) console.error('[setavatar] Set failed:', err);
      if (err?.name === 'AbortError') {
        await message.reply('Timed out fetching image (30s).');
      } else {
        await message
          .reply('Failed to set guild avatar. Check the URL and try again.')
          .catch(() => {});
      }
    }
  },
});

commands.set('bme', {
  description: "Display guild.members.me (bot's member) info in this server",
  async execute(message, client) {
    const guildId = message.guildId;
    if (!guildId) {
      await message.reply('Use this command in a server.');
      return;
    }
    const guild = client.guilds.get(guildId) ?? (await client.guilds.fetch(guildId));
    if (!guild) {
      await message.reply('Could not find this server.');
      return;
    }
    const me = guild.members.me ?? (await guild.members.fetchMe());
    const avatarUrl = me.displayAvatarURL({ size: 256 });
    const accentColor = me.accentColor ?? me.user.avatarColor ?? BRAND_COLOR;
    const roleNames = me.roles
      .filter((id) => id !== guild.id)
      .map((id) => guild.roles.get(id)?.name ?? id);
    const permNames = [];
    try {
      for (const [name, bit] of Object.entries(PermissionFlags)) {
        if (typeof bit === 'number' && me.permissions.has(bit)) permNames.push(name);
      }
    } catch {
      /* ignore import error */
    }

    const embed = new EmbedBuilder()
      .setTitle('guild.members.me')
      .setDescription("Bot's GuildMember in this server")
      .setColor(accentColor)
      .setThumbnail(avatarUrl)
      .addFields(
        { name: 'ID', value: `\`${me.id}\``, inline: true },
        { name: 'Username', value: me.user.username ?? '—', inline: true },
        { name: 'Display name', value: me.displayName ?? '—', inline: true },
        { name: 'Nickname', value: me.nick ?? '*(none)*', inline: true },
        { name: 'Joined', value: me.joinedAt.toISOString(), inline: true },
        {
          name: 'Roles',
          value: roleNames.length ? roleNames.slice(0, 15).join(', ') : '*(none)*',
          inline: false,
        },
        { name: 'Mute', value: String(me.mute), inline: true },
        { name: 'Deaf', value: String(me.deaf), inline: true },
        {
          name: 'Permissions (sample)',
          value: permNames.length ? permNames.slice(0, 12).join(', ') : '*(none)*',
          inline: false,
        },
      )
      .setFooter({ text: `Guild: ${guild.name}` })
      .setTimestamp();

    await message.reply({ embeds: [embed.toJSON()] });
  },
});

commands.set('attachurl', {
  description: 'Test file attachment by URL (sends image fetched from URL)',
  async execute(message) {
    const url = 'https://www.w3schools.com/html/pic_trulli.jpg';
    await message.reply({
      content: 'File attached from URL:',
      files: [{ name: 'trulli.jpg', url }],
    });
  },
});

/** Get human-readable badge names from user flags (checks common badges that fit in 32-bit). */
function getBadgeNames(flags) {
  if (flags == null || typeof flags !== 'number') return [];
  const badges = [];
  const DISPLAY_FLAGS = [
    ['Staff', UserFlagsBits.Staff],
    ['Partner', UserFlagsBits.Partner],
    ['Bug Hunter', UserFlagsBits.BugHunter],
    ['Ctp Member', UserFlagsBits.CtpMember],
    ['Friendly Bot', UserFlagsBits.FriendlyBot],
    ['Friendly Bot (Manual)', UserFlagsBits.FriendlyBotManualApproval],
  ];
  for (const [name, bit] of DISPLAY_FLAGS) {
    if ((flags & bit) === bit) badges.push(name);
  }
  return badges;
}

function addProfileFields(fields, profile, profileData, prefix = '') {
  if (!profile || typeof profile !== 'object') return;
  if (profile.pronouns != null && profile.pronouns !== '')
    fields.push({
      name: prefix + 'Pronouns',
      value: String(profile.pronouns).slice(0, 40),
      inline: true,
    });
  if (profile.bio != null && profile.bio !== '')
    fields.push({
      name: prefix + 'Bio',
      value: String(profile.bio).slice(0, 1024) || '—',
    });
  if (profile.banner != null && profile.banner !== '')
    fields.push({ name: prefix + 'Banner', value: 'Set', inline: true });
  const accent = profile.accent_color ?? profile.banner_color;
  if (accent != null)
    fields.push({
      name: prefix + 'Accent color',
      value: `#${Number(accent).toString(16).padStart(6, '0')}`,
      inline: true,
    });
  if (profile.theme != null)
    fields.push({ name: prefix + 'Theme', value: String(profile.theme), inline: true });
  const mutualCount = profileData?.mutual_guilds?.length ?? profileData?.mutual_guild_ids?.length;
  if (mutualCount != null && mutualCount > 0)
    fields.push({ name: prefix + 'Mutual servers', value: String(mutualCount), inline: true });
  const connected = profileData?.connected_accounts;
  if (connected?.length)
    fields.push({
      name: prefix + 'Connected accounts',
      value:
        connected
          .map((a) => a.name ?? a.type ?? '?')
          .slice(0, 5)
          .join(', ') + (connected.length > 5 ? ` (+${connected.length - 5})` : ''),
      inline: true,
    });
}

commands.set('userinfo', {
  description: "Show a user's profile (mention or user ID); no arg = yourself",
  async execute(message, client, args) {
    const userId = resolveUserId(args[0], message.author.id);
    if (!userId) {
      await message.reply(
        'Provide a user mention (`@user`) or a user ID. Example: `!userinfo @Someone` or `!userinfo 123456789012345678`',
      );
      return;
    }
    let data;
    try {
      data = await client.users.fetchWithProfile(userId, {
        guildId: message.guildId ?? undefined,
      });
    } catch {
      await message.reply(
        'Could not fetch that user. They may not exist or the ID may be invalid.',
      );
      return;
    }
    const {
      user,
      userData,
      globalProfile: globalProfileData,
      serverProfile: serverProfileData,
      memberData,
    } = data;
    const globalProfileUserProfile = globalProfileData?.user_profile;
    const serverProfileUserProfile = serverProfileData?.user_profile;
    const bannerUrl =
      serverProfileUserProfile?.banner != null && serverProfileUserProfile.banner !== ''
        ? cdnBannerURL(userData.id, serverProfileUserProfile.banner, { size: 512 })
        : globalProfileUserProfile?.banner != null && globalProfileUserProfile.banner !== ''
          ? cdnBannerURL(userData.id, globalProfileUserProfile.banner, { size: 512 })
          : userData.banner != null && userData.banner !== ''
            ? cdnBannerURL(userData.id, userData.banner, { size: 512 })
            : null;
    const accentColor =
      serverProfileUserProfile &&
      (serverProfileUserProfile.accent_color ?? serverProfileUserProfile.banner_color) != null
        ? Number(serverProfileUserProfile.accent_color ?? serverProfileUserProfile.banner_color)
        : globalProfileUserProfile &&
            (globalProfileUserProfile.accent_color ?? globalProfileUserProfile.banner_color) != null
          ? Number(globalProfileUserProfile.accent_color ?? globalProfileUserProfile.banner_color)
          : userData.avatar_color != null
            ? Number(userData.avatar_color)
            : memberData?.accent_color != null
              ? Number(memberData.accent_color)
              : BRAND_COLOR;
    // Prefer guild-specific avatar when in a server (like Discord.js member.displayAvatarURL)
    const avatarUrl =
      message.guildId && memberData?.avatar
        ? cdnMemberAvatarURL(message.guildId, userData.id, memberData.avatar, { size: 256 })
        : user.displayAvatarURL({ size: 256 });
    const displayName = userData.global_name ?? userData.username ?? 'User';
    const embed = new EmbedBuilder()
      .setTitle(`${displayName}'s profile`)
      .setAuthor({ name: displayName, iconURL: avatarUrl })
      .setColor(accentColor);
    if (bannerUrl) embed.setImage(bannerUrl);

    const fields = [
      { name: 'Username', value: userData.username ?? '—', inline: true },
      {
        name: 'Display name',
        value: userData.global_name ?? userData.username ?? '—',
        inline: true,
      },
      { name: 'ID', value: `\`${userData.id}\``, inline: true },
      { name: 'Bot', value: userData.bot ? 'Yes' : 'No', inline: true },
      { name: 'System', value: userData.system ? 'Yes' : 'No', inline: true },
      { name: 'Discriminator', value: userData.discriminator ?? '0', inline: true },
      {
        name: 'Avatar',
        value: userData.avatar
          ? userData.avatar.startsWith('a_')
            ? 'Animated'
            : 'Set'
          : 'Default',
        inline: true,
      },
      {
        name: 'Avatar color',
        value:
          userData.avatar_color != null
            ? `#${Number(userData.avatar_color).toString(16).padStart(6, '0')}`
            : '—',
        inline: true,
      },
      {
        name: 'User banner',
        value: userData.banner != null && userData.banner !== '' ? 'Set' : '—',
        inline: true,
      },
    ];

    const flags = userData.flags ?? userData.public_flags;
    if (flags != null) {
      const badgeNames = getBadgeNames(flags);
      fields.push({
        name: 'Badges',
        value: badgeNames.length ? badgeNames.join(', ') : '—',
        inline: false,
      });
      fields.push({
        name: 'Flags (raw)',
        value: `\`${flags}\``,
        inline: true,
      });
    }

    if (globalProfileData) {
      fields.push({ name: '\u200B', value: '**Global Profile**', inline: false });
      addProfileFields(fields, globalProfileUserProfile, globalProfileData);
    }

    if (message.guildId && (serverProfileData || memberData)) {
      const guild = client.guilds.get(message.guildId);
      const guildName = guild?.name ?? 'this server';
      fields.push({
        name: '\u200B',
        value: `**Server Profile** (${guildName})`,
        inline: false,
      });
      if (serverProfileUserProfile && typeof serverProfileUserProfile === 'object') {
        addProfileFields(fields, serverProfileUserProfile, serverProfileData, 'Server ');
      }
      if (memberData) {
        const nick = memberData.nick ?? null;
        if (nick)
          fields.push({
            name: 'Nickname',
            value: String(nick).slice(0, 32),
            inline: true,
          });
        if (memberData.joined_at)
          fields.push({
            name: 'Joined',
            value: `<t:${Math.floor(new Date(memberData.joined_at).getTime() / 1000)}:R>`,
            inline: true,
          });
        if (memberData.premium_since)
          fields.push({
            name: 'Boosting since',
            value: `<t:${Math.floor(new Date(memberData.premium_since).getTime() / 1000)}:R>`,
            inline: true,
          });
        if (memberData.communication_disabled_until) {
          const until = new Date(memberData.communication_disabled_until);
          if (until > new Date())
            fields.push({
              name: 'Timeout until',
              value: `<t:${Math.floor(until.getTime() / 1000)}:F>`,
              inline: true,
            });
        }
        if (memberData.roles?.length) {
          const roleIds = memberData.roles.filter((id) => id !== message.guildId);
          const roleNames = guild
            ? roleIds.map((id) => guild.roles.get(id)?.name ?? id).slice(0, 20)
            : roleIds.slice(0, 20);
          const display =
            roleNames.length > 0
              ? roleNames.join(', ') +
                (roleIds.length > 20 ? ` (+${roleIds.length - 20} more)` : '')
              : '—';
          fields.push({ name: 'Roles', value: display.slice(0, 1024) || '—' });
        }
        if (memberData.avatar != null && memberData.avatar !== '')
          fields.push({ name: 'Server avatar', value: 'Set', inline: true });
        if (memberData.banner != null && memberData.banner !== '')
          fields.push({ name: 'Server banner', value: 'Set', inline: true });
        if (memberData.mute !== undefined)
          fields.push({ name: 'Muted', value: memberData.mute ? 'Yes' : 'No', inline: true });
        if (memberData.deaf !== undefined)
          fields.push({ name: 'Deafened', value: memberData.deaf ? 'Yes' : 'No', inline: true });
      }
    }

    embed
      .addFields(...fields)
      .setFooter({ text: `Requested by ${message.author.username}` })
      .setTimestamp();
    try {
      await message.reply({ embeds: [embed.toJSON()] });
    } catch (err) {
      const fallback = `**${userData.username ?? userData.global_name ?? 'User'}** (ID: \`${userData.id}\`) — Could not send full embed (${err?.statusCode === 502 ? 'server error' : 'error'}). Try again.`;
      await message.reply(fallback).catch(() => {});
    }
  },
});

const VERIFICATION_LEVELS = ['None', 'Low', 'Medium', 'High', 'Very High'];
const MFA_LEVELS = ['None', 'Elevated'];
const EXPLICIT_CONTENT_FILTERS = ['Disabled', 'Members without roles', 'All members'];
const DEFAULT_NOTIFICATION_LEVELS = ['All messages', 'Only mentions'];

commands.set('serverinfo', {
  description: "Show this server's details",
  async execute(message, client, args) {
    const guildId = args[0] ?? message.guildId;
    if (!guildId) {
      await message.reply(
        'Use this command in a server or provide a guild ID: `!serverinfo [guild_id]`',
      );
      return;
    }
    let data;
    try {
      data = await client.rest.get(Routes.guild(guildId));
    } catch {
      await message.reply('Could not fetch that server. Check the ID or permissions.');
      return;
    }
    const iconUrl = data.icon
      ? `https://fluxerusercontent.com/icons/${data.id}/${data.icon}.png?size=256`
      : null;
    const embed = new EmbedBuilder()
      .setTitle(data.name ?? 'Server')
      .setColor(BRAND_COLOR)
      .setThumbnail(iconUrl)
      .addFields(
        { name: 'ID', value: `\`${data.id}\``, inline: true },
        { name: 'Owner ID', value: `\`${data.owner_id ?? '—'}\``, inline: true },
        {
          name: 'Verification',
          value: VERIFICATION_LEVELS[data.verification_level] ?? String(data.verification_level),
          inline: true,
        },
        {
          name: 'MFA level',
          value: MFA_LEVELS[data.mfa_level] ?? String(data.mfa_level),
          inline: true,
        },
        {
          name: 'AFK timeout',
          value: data.afk_timeout != null ? `${data.afk_timeout}s` : '—',
          inline: true,
        },
        { name: 'NSFW level', value: String(data.nsfw_level ?? 0), inline: true },
        {
          name: 'Explicit content filter',
          value:
            EXPLICIT_CONTENT_FILTERS[data.explicit_content_filter] ??
            String(data.explicit_content_filter ?? 0),
          inline: true,
        },
        {
          name: 'Default notifications',
          value: DEFAULT_NOTIFICATION_LEVELS[data.default_message_notifications] ?? '—',
          inline: true,
        },
        {
          name: 'Vanity URL',
          value: data.vanity_url_code ? `/${data.vanity_url_code}` : '—',
          inline: true,
        },
        {
          name: 'System channel ID',
          value: data.system_channel_id ? `\`${data.system_channel_id}\`` : '—',
          inline: true,
        },
        {
          name: 'Rules channel ID',
          value: data.rules_channel_id ? `\`${data.rules_channel_id}\`` : '—',
          inline: true,
        },
        {
          name: 'AFK channel ID',
          value: data.afk_channel_id ? `\`${data.afk_channel_id}\`` : '—',
          inline: true,
        },
        { name: 'Features', value: data.features?.length ? data.features.join(', ') : '—' },
      )
      .setFooter({ text: `Requested by ${message.author.username}` })
      .setTimestamp();
    if (data.banner)
      embed.setImage(
        `https://fluxerusercontent.com/banners/${data.id}/${data.banner}.png?size=512`,
      );
    try {
      await message.reply({ embeds: [embed.toJSON()] });
    } catch {
      await message
        .reply(`Server: **${data.name}** (ID: \`${data.id}\`). Could not send embed.`)
        .catch(() => {});
    }
  },
});

function resolveRoleIdOrName(arg) {
  if (!arg) return null;
  const mentionMatch = arg.match(/^<@&(\d+)>$/);
  if (mentionMatch) return { type: 'id', value: mentionMatch[1] };
  if (/^\d{17,19}$/.test(arg)) return { type: 'id', value: arg };
  return { type: 'name', value: arg };
}

commands.set('roleinfo', {
  description: "Show a role's details (role ID, mention, or name)",
  async execute(message, client, args) {
    const guildId = message.guildId;
    if (!guildId) {
      await message.reply('Use this command in a server.');
      return;
    }
    const resolved = resolveRoleIdOrName(args[0]);
    if (!resolved) {
      await message.reply(
        'Provide a role ID, role mention (`@Role`), or role name. Example: `!roleinfo Moderator`',
      );
      return;
    }
    let roles;
    try {
      roles = await client.rest.get(Routes.guildRoles(guildId));
    } catch {
      await message.reply('Could not fetch roles for this server.');
      return;
    }
    const roleList = Array.isArray(roles) ? roles : Object.values(roles ?? {});
    const role =
      roleList.find((r) =>
        resolved.type === 'id'
          ? r.id === resolved.value
          : r.name && r.name.toLowerCase() === resolved.value.toLowerCase(),
      ) ?? null;
    if (!role) {
      await message.reply(
        resolved.type === 'id' ? 'No role found with that ID.' : 'No role found with that name.',
      );
      return;
    }
    const color = role.color != null && role.color !== 0 ? role.color : BRAND_COLOR;
    const permStr = role.permissions ? String(role.permissions).slice(0, 1024) : '—';
    const embed = new EmbedBuilder()
      .setTitle(role.name ?? 'Role')
      .setColor(color)
      .addFields(
        { name: 'ID', value: `\`${role.id}\``, inline: true },
        { name: 'Name', value: role.name ?? '—', inline: true },
        { name: 'Position', value: String(role.position ?? 0), inline: true },
        {
          name: 'Color',
          value:
            role.color != null && role.color !== 0
              ? `#${Number(role.color).toString(16).padStart(6, '0')}`
              : 'Default',
          inline: true,
        },
        { name: 'Hoist', value: role.hoist ? 'Yes' : 'No', inline: true },
        { name: 'Mentionable', value: role.mentionable ? 'Yes' : 'No', inline: true },
        { name: 'Unicode emoji', value: role.unicode_emoji ?? '—', inline: true },
        {
          name: 'Hoist position',
          value: role.hoist_position != null ? String(role.hoist_position) : '—',
          inline: true,
        },
        { name: 'Permissions', value: permStr },
      )
      .setFooter({ text: `Requested by ${message.author.username}` })
      .setTimestamp();
    try {
      await message.reply({ embeds: [embed.toJSON()] });
    } catch {
      await message
        .reply(`Role: **${role.name}** (ID: \`${role.id}\`). Could not send embed.`)
        .catch(() => {});
    }
  },
});

commands.set('dm', {
  description: 'DM yourself (demo of user.send)',
  async execute(message) {
    try {
      await message.author.send('You requested a DM! This is a direct message from the bot.');
      await message.reply('Check your DMs! 📬');
    } catch {
      await message.reply('Could not DM you. You may have DMs disabled.').catch(() => {});
    }
  },
});

commands.set('dmuser', {
  description: 'DM a user: !dmuser @user [message]',
  async execute(message, client, args) {
    const userId = resolveUserId(args[0], null);
    if (!userId) {
      await message.reply('Provide a user mention or ID. Example: `!dmuser @Someone Hello!`');
      return;
    }
    const text = args.slice(1).join(' ') || 'Hello from the bot!';
    try {
      const userData = await client.rest.get(Routes.user(userId));
      const user = new User(client, userData);
      await user.send(text);
      await message.reply(`Sent DM to **${user.globalName ?? user.username}**.`);
    } catch {
      await message
        .reply('Could not send DM. The user may not exist or may have DMs disabled.')
        .catch(() => {});
    }
  },
});

commands.set('replytest', {
  description: 'Test message.reply() - bot replies to your message (shows as reply thread)',
  async execute(message) {
    await message.reply('This message is a reply to yours! You should see it linked/threaded.');
  },
});

commands.set('react', {
  description: 'Reply with a message and add reactions',
  async execute(message) {
    const reply = await message.reply('React below! 👇');
    await reply.react('👍');
    await reply.react('❤️');
    await reply.react('🎉');
  },
});

commands.set('editembed', {
  description: 'Demonstrate editing an existing message embed',
  async execute(message) {
    const embed = new EmbedBuilder()
      .setTitle('Original Embed')
      .setDescription('This embed will be edited in 2 seconds...')
      .setColor(BRAND_COLOR)
      .setFooter({ text: 'Editing embeds demo' })
      .setTimestamp();

    const reply = await message.reply({ embeds: [embed.toJSON()] });

    // Wait 2 seconds, then edit the embed
    await new Promise((r) => setTimeout(r, 2000));

    const updatedEmbed = new EmbedBuilder()
      .setTitle('Edited Embed')
      .setDescription(
        'The Fluxer API supports editing message embeds via `message.edit({ embeds: [...] })`.',
      )
      .setColor(0x57f287)
      .addFields(
        { name: 'Original', value: 'First state', inline: true },
        { name: 'Edited', value: 'Updated state', inline: true },
      )
      .setFooter({ text: 'Embed was successfully edited' })
      .setTimestamp();

    await reply.edit({ embeds: [updatedEmbed] });
  },
});

commands.set('help', {
  description: 'List available commands',
  async execute(message) {
    const fields = [...commands.entries()].map(([name, cmd]) => ({
      name: `${PREFIX}${name}`,
      value: cmd.description,
      inline: true,
    }));

    const embed = new EmbedBuilder()
      .setTitle('Commands')
      .setDescription(`Use \`${PREFIX}<command>\` to run a command.`)
      .setColor(BRAND_COLOR)
      .addFields(...fields)
      .setFooter({ text: `Prefix: ${PREFIX}` })
      .setTimestamp();

    await message.reply({ embeds: [embed.toJSON()] });
  },
});

commands.set('play', {
  description: 'Join your voice channel and play music (WebM/Opus, no FFmpeg)',
  async execute(message, client) {
    const guildId = message.guildId;
    if (!guildId) {
      await message.reply('This command only works in a server.');
      return;
    }
    const voiceManager = getVoiceManager(client);
    const voiceChannelId = voiceManager.getVoiceChannelId(guildId, message.author.id);
    if (!voiceChannelId) {
      await message.reply('Join a voice channel first.');
      return;
    }
    const channel = client.channels.get(voiceChannelId);
    if (!(channel instanceof VoiceChannel)) {
      await message.reply('Could not find that voice channel.');
      return;
    }
    try {
      const streamUrl = await getStreamUrl(PLAY_URL);
      if (!streamUrl) {
        await message.reply('Could not get stream URL. Is youtube-dl-exec installed?');
        return;
      }
      setPlayState(guildId, channel, streamUrl);
      const connection = await voiceManager.join(channel);
      connection.on?.('serverLeave', async () => {
        const state = playState.get(guildId);
        if (!state) return;
        console.log('[voice] LiveKit server sent leave; auto-reconnecting...');
        try {
          const conn = await voiceManager.join(state.channel);
          await conn.play(state.streamUrl);
        } catch (e) {
          console.error('[voice] Auto-reconnect failed:', e);
          playState.delete(guildId);
        }
      });
      await connection.play(streamUrl);
      await message.reply('Playing in your voice channel.');
    } catch (err) {
      console.error('Play error:', err);
      await message.reply('Failed to join or play.').catch(() => {});
    }
  },
});

commands.set('playvideo', {
  description:
    'Stream video in your VC (default 720p; !playvideo [url] [480p|720p|1080p|1440p|4k])',
  async execute(message, client, args) {
    const guildId = message.guildId;
    if (!guildId) {
      await message.reply('This command only works in a server.');
      return;
    }
    const voiceManager = getVoiceManager(client);
    const voiceChannelId = voiceManager.getVoiceChannelId(guildId, message.author.id);
    if (!voiceChannelId) {
      await message.reply('Join a voice channel first.');
      return;
    }
    const channel = client.channels.get(voiceChannelId);
    if (!(channel instanceof VoiceChannel)) {
      await message.reply('Could not find that voice channel.');
      return;
    }
    const firstArg = args[0]?.trim();
    const secondArg = args[1]?.trim();
    const RESOLUTIONS = ['480p', '720p', '1080p', '1440p', '4k'];
    const resolutionPreset = (s) => s && RESOLUTIONS.includes(s.toLowerCase());
    let inputUrl;
    let resolution;
    if (resolutionPreset(firstArg)) {
      inputUrl = DEFAULT_VIDEO_URL;
      resolution = firstArg.toLowerCase();
    } else if (firstArg && (firstArg.startsWith('http://') || firstArg.startsWith('https://'))) {
      inputUrl = firstArg;
      resolution = resolutionPreset(secondArg) ? secondArg.toLowerCase() : '720p';
    } else {
      inputUrl = DEFAULT_VIDEO_URL;
      resolution = resolutionPreset(secondArg) ? secondArg.toLowerCase() : '720p';
    }
    try {
      let videoUrl = inputUrl;
      if (YOUTUBE_LIKE.test(inputUrl)) {
        await message.reply('Fetching video URL from YouTube...').catch(() => {});
        const resolved = await getVideoUrl(inputUrl);
        if (!resolved) {
          await message
            .reply('Could not get video URL. Is youtube-dl-exec installed?')
            .catch(() => {});
          return;
        }
        videoUrl = resolved;
      }
      const connection = await voiceManager.join(channel);
      if (!(connection instanceof LiveKitRtcConnection)) {
        await message.reply(
          'Video requires LiveKit voice (this server may use a different voice backend).',
        );
        return;
      }
      if (!connection.isConnected()) {
        await message.reply('Voice connection not ready. Try again in a moment.');
        return;
      }
      await connection.playVideo(videoUrl, {
        source: 'screenshare',
        resolution,
      });
      const fps = 30;
      await message.reply(
        `Streaming video in your voice channel at ${resolution} ${fps}fps. Use \`${PREFIX}stop\` to leave.`,
      );
    } catch (err) {
      console.error('Playvideo error:', err);
      await message.reply('Failed to join or stream video.').catch(() => {});
    }
  },
});

commands.set('stop', {
  description: 'Stop audio/video playback and leave voice channel',
  async execute(message, client) {
    const guildId = message.guildId;
    if (!guildId) {
      await message.reply('This command only works in a server.');
      return;
    }
    const voiceManager = getVoiceManager(client);
    const connection = voiceManager.getConnection(guildId);
    if (connection) {
      clearPlayState(guildId);
      connection.stop();
      voiceManager.leave(guildId);
      await message.reply('Stopped and left the voice channel.');
    } else {
      await message.reply('Not in a voice channel in this server.');
    }
  },
});

// ─────────────────────────────────────────────────────────────────────────────
// Client Setup
// ─────────────────────────────────────────────────────────────────────────────

const token = process.env.FLUXER_BOT_TOKEN;
if (!token) {
  console.error('Error: Set FLUXER_BOT_TOKEN environment variable');
  process.exit(1);
}

const client = new Client({
  intents: 0,
  rest: process.env.FLUXER_API_URL ? { api: process.env.FLUXER_API_URL } : undefined,
  presence: {
    status: 'online',
    custom_status: { text: 'Watching the server' },
  },
});

// Create VoiceManager before login so it receives VoiceStatesSync from READY/GUILD_CREATE
// and can see users who were already in a voice channel when the bot started.
getVoiceManager(client);

client.on(Events.Ready, () => {
  console.log(`Logged in as ${client.user?.username}`);
  console.log(`Serving ${client.guilds.size} guild(s)`);
});

client.on(Events.MessageCreate, async (message) => {
  // Ignore bots and messages without content
  if (message.author.bot || !message.content) return;

  // Ignore messages that don't start with the prefix
  const content = message.content.trim();
  if (!content.startsWith(PREFIX)) return;

  // Parse command and arguments
  const args = content.slice(PREFIX.length).split(/\s+/);
  const commandName = args.shift()?.toLowerCase();
  if (!commandName) return;

  // Execute command if it exists
  const command = commands.get(commandName);
  if (command) {
    try {
      await command.execute(message, client, args);
    } catch (err) {
      console.error(`Error executing ${commandName}:`, err);
      await message.reply('An error occurred while running that command.').catch(() => {});
    }
  }
});

client.on(Events.Error, (err) => console.error('Client error:', err));
client.on(Events.Debug, (msg) => console.log('[debug]', msg));

// Optional: log voice gateway events when VOICE_DEBUG=1 (helps diagnose connection timeouts)
if (process.env.VOICE_DEBUG === '1' || process.env.VOICE_DEBUG === 'true') {
  client.on(Events.VoiceStateUpdate, (d) =>
    console.log('[voice] VoiceStateUpdate', {
      guild_id: d.guild_id,
      user_id: d.user_id,
      channel_id: d.channel_id,
    }),
  );
  client.on(Events.VoiceServerUpdate, (d) =>
    console.log('[voice] VoiceServerUpdate', {
      guild_id: d.guild_id,
      endpoint: d.endpoint ? 'present' : 'null',
    }),
  );
}

// ─────────────────────────────────────────────────────────────────────────────
// Start
// ─────────────────────────────────────────────────────────────────────────────

process.on('unhandledRejection', (err) => {
  console.error('Unhandled rejection:', err);
  process.exit(1);
});

try {
  await client.login(token);
  console.log('Gateway connected');
} catch (err) {
  console.error('Login failed:', err);
  process.exit(1);
}