const { REST } = require('@discordjs/rest');
const { Routes, ApplicationCommandOptionType } = require('discord.js');

const commands = [
    {
        name: 'play',
        description: 'Plays a song!',
        options: [
            {
                name: 'query',
                type: ApplicationCommandOptionType.String,
                description: 'The song you want to play',
                required: true
            }
        ]
    }
];

const rest = new REST({ version: '10' }).setToken('BOT_TOKEN');

(async () => {
    try {
        console.log('Started refreshing application [/] commands.');

        await rest.put(Routes.applicationGuildCommands(CLIENT_ID, GUILD_ID), { body: commands });

        console.log('Successfully reloaded application [/] commands.');
    } catch (error) {
        console.error(error);
    }
})();

const { Client } = require('discord.js');
const client = new Discord.Client({
    intents: ['Guilds', 'GuildVoiceStates']
});
const { Player } = require('discord-player');

// Create a new Player (you don't need any API Key)
const player = new Player(client);

// add the start and finish event so when a song will be played this message will be sent
player.events.on('playerStart', (queue, track) => queue.metadata.channel.send(`🎶 | Now playing **${track.title}**!`));
player.events.on('playerFinish', (queue, track) => queue.metadata.channel.send(`🎶 | Now playing **${track.title}**!`));

client.once('ready', () => {
    console.log("I'm ready !");
});

client.on('interactionCreate', async (interaction) => {
    if (!interaction.isChatInputCommand()) return;

    // /play track:Despacito
    // will play "Despacito" in the voice channel
    if (interaction.commandName === 'play') {
        const voiceChannel = interaction.member.voice.channelId;
        if (!voiceChannel) return await interaction.reply({ content: 'You are not in a voice channel!', ephemeral: true });
        if (interaction.guild.members.me.voice.channelId && voiceChannel !== interaction.guild.members.me.voice.channelId)
            return await interaction.reply({ content: 'You are not in my voice channel!', ephemeral: true });
        await interaction.deferReply({ ephemeral: true });
        const query = interaction.options.getString('query');

        try {
            const res = await player.play(voiceChannel, query, {
                nodeOptions: {
                    metadata: {
                        channel: interaction.channel
                    }
                }
            });

            return await interaction.followUp({ content: `⏱️ | Loading track **${res.track.title}**!` });
        } catch(e) {
            return await interaction.followUp({ content: `Could not play: ${e.message}`, ephemeral: true });
        }
    }
});

client.login('BOT_TOKEN');

client.player = player;

import { Player } from 'discord-player';
import { YouTubeExtractor } from '@discord-player/extractor';

const player = new Player(client, {
    blockStreamFrom: [
        // now your bot will no longer be able to use
        // youtube extractor to play audio even if the track was
        // extracted from youtube
        YouTubeExtractor.identifier
    ],
    blockExtractors: [
        // this will block the listed extractors from being
        // able to query metadata (aka search results parsing)
        // This example disables youtube search, spotify bridge
        // and apple music bridge
        YouTubeExtractor.identifier
    ]
});

import { SoundCloudExtractor } from '@discord-player/extractor';

const result = await player.search(query, {
    // always use soundcloud extractor
    searchEngine: SoundCloudExtractor.identifier
});

await queue.filters.ffmpeg.toggle(['bassboost', 'nightcore']);

queue.filters.equalizer.setEQ([
    { band: 0, gain: 0.25 },
    { band: 1, gain: 0.25 },
    { band: 2, gain: 0.25 }
]);

import { BiquadFilterType } from 'discord-player';

queue.filters.biquad.setFilter(BiquadFilterType.LowPass);
// similarly, you can use other filters such as HighPass, BandPass, Notch, PeakEQ, LowShelf, HighShelf, etc.

queue.filters.filters.setFilters(['8D']);

const player = new Player(client, {
    ytdlOptions: {
        requestOptions: {
            headers: {
                cookie: 'YOUR_YOUTUBE_COOKIE'
            }
        }
    }
});

const HttpsProxyAgent = require('https-proxy-agent');

// Remove "user:pass@" if you don't need to authenticate to your proxy.
const proxy = 'http://user:pass@111.111.111.111:8080';
const agent = HttpsProxyAgent(proxy);

const player = new Player(client, {
    ytdlOptions: {
        requestOptions: { agent }
    }
});

const fs = require('fs');

// other code
const queue = player.nodes.create(..., {
    ...,
    async onBeforeCreateStream(track, source, _queue) {
        if (track.title === 'some title') {
            return fs.createReadStream('./playThisInstead.mp3');
        }
    }
});

const queue = player.nodes.create(..., {
    ...,
    async onAfterCreateStream(pcmStream, queue) {
        // return opus encoded stream
        const encoder = new OpusEncoder();
        return {
            stream: encoder.encode(pcmStream),
            type: StreamType.Opus
        };
    }
});