bot.gateway.ts

import { BotService } from '@bot/bot.service';
import { PlayerButtonActionId } from '@bot/constants/player.constants';
import { PlayerService } from '@bot/services/player/player.service';
import { ConfigService } from '@config/config.service';
import { MemberDocument } from '@database/schemas/member.schema';
import { InjectDiscordClient, InteractionEvent, On, Once } from '@discord-nestjs/core';
import { Injectable, Logger } from '@nestjs/common';
import { IMemberVoiceState } from '@shared/interfaces/memberVoiceState.interface';
import { ActivityType, ButtonInteraction, Client, MessageFlags, VoiceState } from 'discord.js';
import { FRIENDLY_ERROR_MESSAGES } from './constants/messages.constant';
import { getNowPlayingButtons } from './utils/player.utils';

@Injectable()
export class BotGateway {
  private readonly logger = new Logger(BotGateway.name);

  constructor(
    @InjectDiscordClient() private readonly client: Client,
    private readonly _botService: BotService,
    private readonly _playerService: PlayerService,
    private readonly _configService: ConfigService,
  ) {}

  @Once('ready')
  onReady(): void {
    this.logger.log(`Bot ${this.client.user.tag} was started!`);
    this.initPresence();
  }

  @On('voiceStateUpdate')
  async onVoiceStateUpdate(lastState: VoiceState, newState: VoiceState): Promise<MemberDocument> {
    if (lastState.channelId === newState.channelId) return; // Ignore if the user is in the same channel
    if (newState.member.user.bot) return; // Ignore if the user is a bot
    this.logger.log(`Handling VoiceStateUpdate for ${newState.member.user.username}`);
    const { channelId, guild, member } = newState;
    const memberVoiceState: IMemberVoiceState = {
      userId: member.user.id,
      username: member.user.username,
      discriminator: member.user.discriminator,
      guildId: guild.id,
      guildName: guild.name,
      currentChannelId: channelId,
    };
    return this._botService.updateMemberVoiceState({ memberVoiceState });
  }

  @On('interactionCreate')
  async onButtonInteractionCreate(@InteractionEvent() interaction: ButtonInteraction) {
    if (!interaction.isButton()) return;
    const { customId, guildId, channel } = interaction;
    const guildQueue = this._playerService.getGuildQueue(guildId);
    if (!guildQueue) {
      await this.handleInvalidButtonInteraction(interaction);
      return;
    }
    switch (customId) {
      case PlayerButtonActionId.PLAY_PAUSE: {
        this._playerService.togglePause({ guildId });
        await interaction.deferUpdate();
        return;
      }
      case PlayerButtonActionId.SKIP: {
        await channel.sendTyping();
        this._playerService.skip({ guildId });
        await interaction.deferUpdate();
        return;
      }
    }
  }

  private async disableButtonInteraction(interaction: ButtonInteraction): Promise<void> {
    const { message } = interaction;
    const disabledButtons = getNowPlayingButtons({ disabled: true });
    await message.edit({ components: [disabledButtons] });
  }

  private async handleInvalidButtonInteraction(interaction: ButtonInteraction): Promise<void> {
    await this.disableButtonInteraction(interaction);
    await interaction.reply({ content: FRIENDLY_ERROR_MESSAGES.NO_ACTIVE_QUEUE, flags: MessageFlags.Ephemeral });
  }

  private async initPresence(): Promise<void> {
    const version = this._configService.getAppVersion();
    this.client.user.setPresence({
      status: 'dnd',
      activities: [{ name: `v${version}-RELEASE`, type: ActivityType.Custom }],
    });
  }
}