Yumi/src/discord/MusicPlayer/PlayMy.ts

import { I18n } from 'i18n';
import { Message, CommandInteraction, ActivityType, ActionRowBuilder, ButtonBuilder, ButtonStyle } from 'discord.js';

import DiscordMusicPlayer, { TrackUtils, ValidTracks } from '../../providers/DiscordMusicPlayerTempFix';
import Locale from '../../services/Locale';

import { makeSuccessEmbed, makeErrorEmbed, sendHybridInteractionMessageResponse } from '../../utils/DiscordMessage';
import DiscordModule, { HybridInteractionMessage } from '../../utils/DiscordModule';
import { joinVoiceChannelProcedure } from './Join';

const EMBEDS = {
    NOT_DETECTED: (data: HybridInteractionMessage, locale: I18n) => {
        return makeErrorEmbed({
            title: locale.__('musicplayer_playmy.not_detected'),
            user: data.getUser()
        });
    },
    USER_NOT_IN_VOICECHANNEL: (data: HybridInteractionMessage, locale: I18n) => {
        return makeErrorEmbed({
            title: locale.__('musicplayer.not_in_voice'),
            user: data.getUser()
        });
    },
    USER_NOT_IN_SAME_VOICECHANNEL: (data: HybridInteractionMessage, locale: I18n) => {
        return makeErrorEmbed({
            title: locale.__('musicplayer.different_voice_channel'),
            user: data.getUser()
        });
    },
    ADDED_QUEUE: async (data: HybridInteractionMessage, locale: I18n, track: ValidTracks) => {
        const title = TrackUtils.getTitle(track);
        const thumbnails = await TrackUtils.getThumbnails(track);

        let embed = makeSuccessEmbed({
            title: locale.__('musicplayer_play.queue_added_song'),
            description: title,
            user: data.getUser()
        });

        if (TrackUtils.getHighestResolutionThumbnail(thumbnails))
            embed.setImage(TrackUtils.getHighestResolutionThumbnail(thumbnails).url);

        return embed;
    },
    TOO_LONG: (data: HybridInteractionMessage, locale: I18n) => {
        return makeErrorEmbed({
            title: locale.__('musicplayer_playmy.too_long'),
            user: data.getUser()
        });
    }
};

export default class PlayMy extends DiscordModule {
    public id = 'Discord_MusicPlayer_PlayMy';
    public commands = ['playmy'];
    public commandInteractionName = 'playmy';

    async GuildOnModuleCommand(args: any, message: Message) {
        await this.run(new HybridInteractionMessage(message), args);
    }

    async GuildModuleCommandInteractionCreate(interaction: CommandInteraction) {
        await this.run(new HybridInteractionMessage(interaction), interaction.options);
    }

    async run(data: HybridInteractionMessage, args: any) {
        const guild = data.getGuild();
        const member = data.getMember();

        if (!guild || !member) return;

        const locale = await Locale.getGuildLocale(guild.id);

        if (!member.voice.channel)
            return await sendHybridInteractionMessageResponse(data, {
                embeds: [EMBEDS.USER_NOT_IN_VOICECHANNEL(data, locale)]
            });

        const voiceChannel = member.voice.channel;

        if (!DiscordMusicPlayer.isGuildInstanceExists(guild.id)) {
            await joinVoiceChannelProcedure(data, null, voiceChannel);
        }

        let instance = DiscordMusicPlayer.getGuildInstance(guild.id);
        if (!instance) return;

        if (instance!.voiceChannel.id !== member.voice.channel.id)
            return await sendHybridInteractionMessageResponse(
                data,
                { embeds: [EMBEDS.USER_NOT_IN_SAME_VOICECHANNEL(data, locale)] },
                true
            );

        if (!instance!.isConnected()) {
            await joinVoiceChannelProcedure(data, instance!, voiceChannel);
            instance = DiscordMusicPlayer.getGuildInstance(guild.id);
        }

        if (!instance) return;
        if (!member.presence) return;
        if (!member.presence.activities) return;

        let query;
        let found = false;
        for (const activity of member.presence.activities) {
            if (activity.type === ActivityType.Listening) {
                if (!activity.details) continue;
                found = true;

                if (activity.name == 'Spotify') query = `${activity.state} - ${activity.details}`;
                else query = `${activity.state} - ${activity.details}`; // TODO: Find better query formula

                const result = await DiscordMusicPlayer.searchYouTubeByQuery(query);
                if (!result) continue;
                instance.addTrackToQueue(result[0]);

                // Max 1 hour
                if (result[0].durationInSec > 3600)
                    return await sendHybridInteractionMessageResponse(data, {
                        embeds: [EMBEDS.TOO_LONG(data, locale)]
                    });

                let row;
                if (result.length > 1) {
                    // TODO: Find a better logic than this
                    // If the first result title is exact match with the query or first title contains half the space of the query, it's probably a sentence
                    // then we don't need to show the search results
                    // if(result[0].title === query || result[0].title && (Math.ceil((result[0].title.split(" ").length - 1) / 2) === Math.ceil((query.split(" ").length - 1) / 2))) return;

                    // The query length is too long to fit in json
                    if (query.length > 100 - 51) return;

                    row = new ActionRowBuilder<ButtonBuilder>().addComponents([
                        new ButtonBuilder()
                            .setEmoji('🔎')
                            .setCustomId(
                                JSON.stringify({
                                    m: 'MP_S',
                                    a: 'search',
                                    d: {
                                        q: query
                                    }
                                })
                            )
                            .setLabel('  Not this? Search!')
                            .setStyle(ButtonStyle.Primary)
                    ]);
                }

                if (!row)
                    await sendHybridInteractionMessageResponse(data, {
                        embeds: [await EMBEDS.ADDED_QUEUE(data, locale, result[0])]
                    });
                else
                    await sendHybridInteractionMessageResponse(data, {
                        embeds: [await EMBEDS.ADDED_QUEUE(data, locale, result[0])],
                        components: [row]
                    });
            }
        }

        if (!found) await sendHybridInteractionMessageResponse(data, { embeds: [EMBEDS.NOT_DETECTED(data, locale)] });

        return;
    }
}