index.js

const { Client, GatewayDispatchEvents, ActionRowBuilder, ButtonBuilder, ButtonStyle, EmbedBuilder, ActivityType } = require("discord.js");
const { Riffy } = require("riffy");
const { Spotify } = require("riffy-spotify");
const config = require("./config.js");
const messages = require("./utils/messages.js");
const emojis = require("./emojis.js");

const client = new Client({
    intents: [
        "Guilds",
        "GuildMessages",
        "GuildVoiceStates",
        "GuildMessageReactions",
        "MessageContent",
        "DirectMessages",
    ],
});

const spotify = new Spotify({
    clientId: config.spotify.clientId,
    clientSecret: config.spotify.clientSecret
});

client.riffy = new Riffy(client, config.nodes, {
    send: (payload) => {
        const guild = client.guilds.cache.get(payload.d.guild_id);
        if (guild) guild.shard.send(payload);
    },
    defaultSearchPlatform: "ytmsearch",
    restVersion: "v4",
    plugins: [spotify]
});

// Image card generation helper
async function generateImageCard(trackInfo) {
    try {
        // Check if track has a YouTube URL
        if (!trackInfo.uri || (!trackInfo.uri.includes('youtube.com') && !trackInfo.uri.includes('youtu.be'))) {
            console.log('[Image Card] Not a YouTube URL, skipping image generation');
            return null;
        }

        // Extract artist and title from track info
        const title = encodeURIComponent(trackInfo.title || 'Unknown Title');
        const artist = encodeURIComponent(trackInfo.author || 'Unknown Artist');
        const duration = encodeURIComponent(formatDuration(trackInfo.length) || '0:00');
        const thumbnail = encodeURIComponent(trackInfo.uri || '');

        // Construct the image card API URL
        const imageCardUrl = `https://imggen-api.ankitgupta.com.np/api/image-card?title=${title}&artist=${artist}&thumbnail=${thumbnail}&duration=${duration}&returnType=image`;

        console.log(`[Image Card] Generating for: ${trackInfo.title}`);
        
        // Use built-in fetch (available in Node.js 18+)
        const controller = new AbortController();
        const timeout = setTimeout(() => controller.abort(), 10000); // 10 second timeout
        
        const response = await fetch(imageCardUrl, {
            signal: controller.signal,
            headers: {
                'User-Agent': 'DTEmpire-Music-Bot/1.0'
            }
        });
        
        clearTimeout(timeout);
        
        if (!response.ok) {
            console.error(`[Image Card] Failed: ${response.status} ${response.statusText}`);
            return null;
        }

        // Get the image buffer
        const imageBuffer = await response.arrayBuffer();
        
        // Check if it's actually an image
        const contentType = response.headers.get('content-type');
        if (!contentType || !contentType.startsWith('image/')) {
            console.error('[Image Card] Response is not an image');
            return null;
        }
        
        console.log(`[Image Card] Successfully generated`);
        return { buffer: Buffer.from(imageBuffer), url: imageCardUrl };
        
    } catch (error) {
        if (error.name === 'AbortError') {
            console.error('[Image Card] Timeout: Took too long to generate image');
        } else {
            console.error('[Image Card] Error:', error.message);
        }
        return null;
    }
}

// Helper function to format duration
function formatDuration(ms) {
    // Return 'LIVE' for streams
    if (!ms || ms <= 0 || ms === 'Infinity') return 'LIVE';

    // Convert to seconds
    const seconds = Math.floor((ms / 1000) % 60);
    const minutes = Math.floor((ms / (1000 * 60)) % 60);
    const hours = Math.floor(ms / (1000 * 60 * 60));

    // Format based on length
    if (hours > 0) {
        return `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
    }
    return `${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
}

// Command definitions with emojis
const commands = [
    { name: 'play <query>', description: 'Play a song or playlist', emoji: '🎵' },
    { name: 'pause', description: 'Pause the current track', emoji: '⏸️' },
    { name: 'resume', description: 'Resume the current track', emoji: '▶️' },
    { name: 'skip', description: 'Skip the current track', emoji: '⏭️' },
    { name: 'stop', description: 'Stop playback and clear queue', emoji: '⏹️' },
    { name: 'queue', description: 'Show the current queue', emoji: '📜' },
    { name: 'volume <0-100>', description: 'Adjust player volume', emoji: '🔊' },
    { name: 'shuffle', description: 'Shuffle the current queue', emoji: '🔀' },
    { name: 'loop', description: 'Toggle queue loop mode', emoji: '🔁' },
    { name: 'remove <position>', description: 'Remove a track from queue', emoji: '❌' },
    { name: 'clear', description: 'Clear the current queue', emoji: '🧹' },
    { name: 'status', description: 'Show player status', emoji: 'ℹ️' },
    { name: 'nowplaying', description: 'Show current track with image card', emoji: '🖼️' },
    { name: 'help', description: 'Show this help message', emoji: '❓' }
];

// Function to update bot presence
function updatePresence(track = null) {
    try {
        client.user.setPresence({
            activities: [{
                name: `${config.prefix}help | Music`,
                type: ActivityType.Listening
            }],
            status: 'online'
        });
    } catch (error) {
        console.error('Error updating presence:', error);
    }
}

client.on("ready", () => {
    client.riffy.init(client.user.id);
    console.log(`${emojis.success} Logged in as ${client.user.tag}`);
    updatePresence();
});

function createMusicButtons() {
    return new ActionRowBuilder().addComponents(
        new ButtonBuilder()
            .setCustomId('pause_resume')
            .setLabel('⏯️ Pause/Resume')
            .setStyle(ButtonStyle.Secondary),
        new ButtonBuilder()
            .setCustomId('skip')
            .setLabel('⏭️ Skip')
            .setStyle(ButtonStyle.Secondary),
        new ButtonBuilder()
            .setCustomId('stop')
            .setLabel('⏹️ Stop')
            .setStyle(ButtonStyle.Danger),
        new ButtonBuilder()
            .setCustomId('shuffle')
            .setLabel('🔀 Shuffle')
            .setStyle(ButtonStyle.Secondary),
        new ButtonBuilder()
            .setCustomId('loop')
            .setLabel('🔁 Loop')
            .setStyle(ButtonStyle.Secondary)
    );
}

function createHelpEmbed() {
    return new EmbedBuilder()
        .setColor('#0099ff')
        .setTitle(`${client.user.username} Music Bot Help`)
        .setDescription(`**Prefix:** \`${config.prefix}\`\n**Example:** \`${config.prefix}play <song name>\``)
        .addFields(
            commands.map(cmd => ({
                name: `${cmd.emoji} ${config.prefix}${cmd.name}`,
                value: cmd.description,
                inline: true
            }))
        )
        .setFooter({ text: `DTEmpire Music Bot`, iconURL: client.user.displayAvatarURL() })
        .setTimestamp();
}

client.on("messageCreate", async (message) => {
    if (!message.content.startsWith(config.prefix) || message.author.bot) return;

    const args = message.content.slice(config.prefix.length).trim().split(/ +/);
    const command = args.shift().toLowerCase();

    const musicCommands = ["play", "skip", "stop", "pause", "resume", "queue", "nowplaying", "volume", "shuffle", "loop", "remove", "clear"];
    if (musicCommands.includes(command) && !message.member.voice.channel) {
        return message.reply({
            embeds: [
                new EmbedBuilder()
                    .setColor('#ff0000')
                    .setDescription(`${emojis.error} You must be in a voice channel!`)
            ]
        });
    }

    try {
        switch (command) {
            case "help":
                return message.reply({ embeds: [createHelpEmbed()] });

            case "play": {
                const query = args.join(" ");
                if (!query) return messages.error(message.channel, "Please provide a search query!");

                const player = client.riffy.createConnection({
                    guildId: message.guild.id,
                    voiceChannel: message.member.voice.channel.id,
                    textChannel: message.channel.id,
                    deaf: true,
                });

                const resolve = await client.riffy.resolve({ query, requester: message.author });
                const { loadType, tracks, playlistInfo } = resolve;

                if (loadType === "playlist") {
                    tracks.forEach(track => {
                        track.info.requester = message.author;
                        player.queue.add(track);
                    });
                    messages.addedPlaylist(message.channel, playlistInfo, tracks);
                } else if (loadType === "search" || loadType === "track") {
                    const track = tracks[0];
                    track.info.requester = message.author;
                    player.queue.add(track);
                    messages.addedToQueue(message.channel, track, player.queue.length);
                } else {
                    return messages.error(message.channel, "No results found!");
                }

                if (!player.playing && !player.paused) player.play();
                break;
            }

            case "skip": {
                const player = client.riffy.players.get(message.guild.id);
                if (!player) return messages.error(message.channel, "Nothing is playing!");
                if (!player.queue.length) return messages.error(message.channel, "No more tracks in queue!");
                
                player.stop();
                messages.success(message.channel, "Skipped the current track!");
                break;
            }

            case "stop": {
                const player = client.riffy.players.get(message.guild.id);
                if (!player) return messages.error(message.channel, "Nothing is playing!");
                
                player.destroy();
                updatePresence();
                messages.success(message.channel, "Stopped the music!");
                break;
            }

            case "pause": {
                const player = client.riffy.players.get(message.guild.id);
                if (!player) return messages.error(message.channel, "Nothing is playing!");
                if (player.paused) return messages.error(message.channel, "Already paused!");
                
                player.pause(true);
                messages.success(message.channel, "Paused the music!");
                break;
            }

            case "resume": {
                const player = client.riffy.players.get(message.guild.id);
                if (!player) return messages.error(message.channel, "Nothing is playing!");
                if (!player.paused) return messages.error(message.channel, "Already playing!");
                
                player.pause(false);
                messages.success(message.channel, "Resumed the music!");
                break;
            }

            case "queue": {
                const player = client.riffy.players.get(message.guild.id);
                if (!player) return messages.error(message.channel, "Nothing is playing!");
                
                const queueChunks = [];
                const chunkSize = 10;
                
                for (let i = 0; i < player.queue.length; i += chunkSize) {
                    queueChunks.push(player.queue.slice(i, i + chunkSize));
                }
                
                if (queueChunks.length > 0) {
                    await messages.queueList(message.channel, queueChunks[0], player.queue.current);
                }
                
                for (let i = 1; i < queueChunks.length; i++) {
                    await messages.queueListContinued(message.channel, queueChunks[i]);
                }
                break;
            }

            case "nowplaying": {
                const player = client.riffy.players.get(message.guild.id);
                if (!player?.queue.current) return messages.error(message.channel, "Nothing is playing!");

                try {
                    // Generate image card for current track
                    const imageCard = await generateImageCard(player.queue.current.info);
                    
                    if (imageCard) {
                        const embed = new EmbedBuilder()
                            .setColor('#0099ff')
                            .setTitle('🎶 Now Playing')
                            .setDescription(`**${player.queue.current.info.title}**`)
                            .addFields(
                                { name: 'Artist', value: player.queue.current.info.author || 'Unknown', inline: true },
                                { name: 'Duration', value: formatDuration(player.queue.current.info.length), inline: true },
                                { name: 'Requested by', value: `<@${player.queue.current.info.requester.id}>`, inline: true }
                            )
                            .setImage('attachment://music-card.png')
                            .setFooter({ text: 'DTEmpire Music Bot • Use !help for commands', iconURL: client.user.displayAvatarURL() })
                            .setTimestamp();

                        await message.channel.send({
                            embeds: [embed],
                            files: [{
                                attachment: imageCard.buffer,
                                name: 'music-card.png'
                            }],
                            components: [createMusicButtons()]
                        });
                    } else {
                        // Fallback to original embed
                        const embed = new EmbedBuilder()
                            .setColor('#0099ff')
                            .setTitle('🎶 Now Playing')
                            .setDescription(`[${player.queue.current.info.title}](${player.queue.current.info.uri})`)
                            .addFields(
                                { name: 'Duration', value: formatDuration(player.queue.current.info.length), inline: true },
                                { name: 'Requested by', value: `<@${player.queue.current.info.requester.id}>`, inline: true }
                            )
                            .setThumbnail(player.queue.current.info.thumbnail || null);

                        await message.channel.send({ 
                            embeds: [embed],
                            components: [createMusicButtons()] 
                        });
                    }
                } catch (error) {
                    console.error('[NowPlaying] Error:', error);
                    messages.error(message.channel, "Error generating image card!");
                }
                break;
            }

            case "volume": {
                const player = client.riffy.players.get(message.guild.id);
                if (!player) return messages.error(message.channel, "Nothing is playing!");
                
                const volume = parseInt(args[0]);
                if (isNaN(volume)) return messages.error(message.channel, "Please provide a valid number!");
                if (volume < 0 || volume > 100) return messages.error(message.channel, "Volume must be between 0-100!");

                player.setVolume(volume);
                messages.success(message.channel, `Volume set to ${volume}%`);
                break;
            }

            case "shuffle": {
                const player = client.riffy.players.get(message.guild.id);
                if (!player) return messages.error(message.channel, "Nothing is playing!");
                if (player.queue.length < 2) return messages.error(message.channel, "Need at least 2 tracks to shuffle!");
                
                player.queue.shuffle();
                messages.success(message.channel, "Shuffled the queue!");
                break;
            }

            case "loop": {
                const player = client.riffy.players.get(message.guild.id);
                if (!player) return messages.error(message.channel, "Nothing is playing!");
                
                const newMode = player.loop === "none" ? "queue" : "none";
                player.setLoop(newMode);
                messages.success(message.channel, `Loop ${newMode === "queue" ? "enabled" : "disabled"}!`);
                break;
            }

            case "remove": {
                const player = client.riffy.players.get(message.guild.id);
                if (!player) return messages.error(message.channel, "Nothing is playing!");
                
                const position = parseInt(args[0]);
                if (isNaN(position) || position < 1 || position > player.queue.length) {
                    return messages.error(message.channel, `Please provide a valid position (1-${player.queue.length})!`);
                }

                const removed = player.queue.remove(position - 1);
                messages.success(message.channel, `Removed **${removed.info.title}** from queue!`);
                break;
            }

            case "clear": {
                const player = client.riffy.players.get(message.guild.id);
                if (!player) return messages.error(message.channel, "Nothing is playing!");
                if (!player.queue.length) return messages.error(message.channel, "Queue is already empty!");
                
                player.queue.clear();
                messages.success(message.channel, "Cleared the queue!");
                break;
            }

            case "status": {
                const player = client.riffy.players.get(message.guild.id);
                if (!player) return messages.error(message.channel, "No active player!");
                
                messages.playerStatus(message.channel, player);
                break;
            }

            default:
                return messages.error(message.channel, `Unknown command! Use ${config.prefix}help for commands.`);
        }
    } catch (error) {
        console.error(error);
        messages.error(message.channel, "An error occurred!");
    }
});

client.on('interactionCreate', async interaction => {
    if (!interaction.isButton()) return;
    
    const player = client.riffy.players.get(interaction.guild.id);
    if (!player) return interaction.reply({ content: "No music playing!", ephemeral: true });

    const member = interaction.guild.members.cache.get(interaction.user.id);
    if (member.voice.channelId !== player.voiceChannel) {
        return interaction.reply({ content: "Join the voice channel first!", ephemeral: true });
    }

    try {
        switch (interaction.customId) {
            case 'pause_resume':
                player.pause(!player.paused);
                await interaction.reply({ 
                    content: player.paused ? "⏸️ Paused!" : "▶️ Resumed!", 
                    ephemeral: true 
                });
                break;

            case 'skip':
                if (!player.queue.length) throw new Error("No more tracks!");
                player.stop();
                await interaction.reply({ content: "⏭️ Skipped!", ephemeral: true });
                break;

            case 'stop':
                player.destroy();
                updatePresence();
                await interaction.reply({ content: "⏹️ Stopped!", ephemeral: true });
                break;

            case 'shuffle':
                if (player.queue.length < 2) throw new Error("Need 2+ tracks!");
                player.queue.shuffle();
                await interaction.reply({ content: "🔀 Shuffled!", ephemeral: true });
                break;

            case 'loop':
                const newMode = player.loop === "none" ? "queue" : "none";
                player.setLoop(newMode);
                await interaction.reply({ 
                    content: newMode === "queue" ? "🔁 Loop enabled!" : "🔁 Loop disabled!", 
                    ephemeral: true 
                });
                break;
        }
    } catch (error) {
        await interaction.reply({ 
            content: error.message || "Error!", 
            ephemeral: true 
        });
    }
});

// Track start event with image card generation
client.riffy.on("trackStart", async (player, track) => {
    const channel = client.channels.cache.get(player.textChannel);
    if (!channel) return;
    
    updatePresence(track);
    
    try {
        // Generate image card for the track
        const imageCard = await generateImageCard(track.info);
        
        if (imageCard) {
            // Create embed with image attachment
            const embed = new EmbedBuilder()
                .setColor('#0099ff')
                .setTitle('🎶 Now Playing')
                .setDescription(`**${track.info.title}**`)
                .addFields(
                    { name: 'Artist', value: track.info.author || 'Unknown', inline: true },
                    { name: 'Duration', value: formatDuration(track.info.length), inline: true },
                    { name: 'Requested by', value: `<@${track.info.requester.id}>`, inline: true }
                )
                .setImage('attachment://music-card.png')
                .setFooter({ 
                    text: 'DTEmpire Music Bot • Use !help for commands', 
                    iconURL: client.user.displayAvatarURL() 
                })
                .setTimestamp();

            // Send message with image attachment
            await channel.send({
                embeds: [embed],
                files: [{
                    attachment: imageCard.buffer,
                    name: 'music-card.png'
                }],
                components: [createMusicButtons()]
            });
            
        } else {
            // Fallback to original message if image generation fails
            console.log('[Track Start] Using fallback embed');
            const embed = new EmbedBuilder()
                .setColor('#0099ff')
                .setTitle('🎶 Now Playing')
                .setDescription(`[${track.info.title}](${track.info.uri})`)
                .addFields(
                    { name: 'Artist', value: track.info.author || 'Unknown', inline: true },
                    { name: 'Duration', value: formatDuration(track.info.length), inline: true },
                    { name: 'Requested by', value: `<@${track.info.requester.id}>`, inline: true }
                )
                .setThumbnail(track.info.thumbnail || null)
                .setFooter({ 
                    text: 'DTEmpire Music Bot • Use !help for commands', 
                    iconURL: client.user.displayAvatarURL() 
                })
                .setTimestamp();

            await channel.send({
                embeds: [embed],
                components: [createMusicButtons()]
            });
        }
        
    } catch (error) {
        console.error('[Track Start] Error:', error);
        // Ultimate fallback
        const embed = new EmbedBuilder()
            .setColor('#0099ff')
            .setTitle('🎶 Now Playing')
            .setDescription(`**${track.info.title}**`)
            .addFields(
                { name: 'Requested by', value: `<@${track.info.requester.id}>`, inline: true }
            )
            .setFooter({ text: 'DTEmpire Music Bot' })
            .setTimestamp();
        
        await channel.send({
            embeds: [embed],
            components: [createMusicButtons()]
        });
    }
});

client.riffy.on("nodeConnect", node => {
    console.log(`${emojis.success} Node "${node.name}" connected`);
});

client.riffy.on("nodeError", (node, error) => {
    console.log(`${emojis.error} Node "${node.name}" error: ${error.message}`);
});

client.riffy.on("queueEnd", player => {
    const channel = client.channels.cache.get(player.textChannel);
    if (channel) {
        player.destroy();
        updatePresence();
        messages.queueEnded(channel);
    }
});

client.on("raw", d => {
    if (![GatewayDispatchEvents.VoiceStateUpdate, GatewayDispatchEvents.VoiceServerUpdate].includes(d.t)) return;
    client.riffy.updateVoiceState(d);
});

client.login(config.botToken);