commands.js

const axios = require('axios');
const yts = require('yt-search');
const premiumManager = require('./premiumManager');

// Configuration axios
const axiosInstance = axios.create({
    headers: {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    },
    timeout: 30000,
    validateStatus: false
});


// COMMANDES PUBLIQUES


/**
 * Commande /start
 */
async function handleStart(bot, chatId, username) {
    const welcomeMessage = `
 ❍ *Bienvenue ${username ? '@' + username : ''} sur ꜱᴛᴇᴘʜ ᴛᴇᴄʜ ʙᴏᴛ!*

❏Utilisez /help pour voir toutes les commandes disponibles.

*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ꜱᴛᴇᴘʜ ᴛᴇᴄʜ*
    `;
    const photoPath = './media/start.jpeg';
    
     bot.sendPhoto(chatId, photoPath, {
        caption: welcomeMessage,
        parse_mode: 'Markdown'
    });
}

/**
 * Commande /help
 */
async function handleHelp(bot, chatId) {
    const helpMessage = `
╭━━━━━━━━━━━━━━━
  ❍ ꜱᴛᴇᴘʜ ᴛᴇᴄʜ ʙᴏᴛ
  ❍ ʙᴇ ꜱɪᴍᴘʟᴇ.
╰━━━━━━━━━━━━━━━

ᴄᴏᴍᴍᴀɴᴅꜱ :

╭━━━❏ *ᴍᴜꜱɪQᴜᴇ & ᴀᴜᴅɪᴏ* ❏
┃ \`/play titre\`
┃ \`/spotify lien\` 
┃ \`/applemusic lien\`
╰━━━━━━━━━━━━━━━

╭━━━❏ *ᴠɪᴅᴇ́ᴏꜱ* ❏
┃ \`/video titre\` 
┃ \`/tiktok lien\` 
┃ \`/instagram lien\`
┃ \`/facebook lien\` 
╰━━━━━━━━━━━━━━━

╭━━━❏ *ᴏᴜᴛɪʟꜱ* ❏
┃ \`/myid\` 
┃ \`/qr texte\` 
┃ \`/translate langue texte\`
┃ \`/img recherche\` 
╰━━━━━━━━━━━━━━━

╭━━━❏ *ᴀᴅᴍɪɴ ᴘʀᴇᴍɪᴜᴍ* ❏
┃ \`/addpremium ID durée\`
┃ \`/removepremium ID\`
┃ \`/checkpremium ID\`
┃ \`/listpremium\`
╰━━━━━━━━━━━━━━━

*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ꜱᴛᴇᴘʜ ᴛᴇᴄʜ*
    `;
    const photoPath = './media/menu.jpg';
    
     bot.sendPhoto(chatId, photoPath, {
        caption: helpMessage,
        parse_mode: 'Markdown'
    });
}

/**
 * Commande /play - Télécharger une chanson MP3
 */
async function handlePlay(bot, chatId, args, msg) {
    const query = args.join(' ');
    
    if (!query) {
        return bot.sendMessage(chatId, '❌ Veuillez fournir le nom de la chanson.\nExemple: `/play Faded by Alan Walker`', { parse_mode: 'Markdown' });
    }

    try {
        await bot.sendMessage(chatId, '🔍 Recherche en cours...');
        
        const { videos } = await yts(query);
        if (!videos || videos.length === 0) {
            throw new Error('Aucun résultat trouvé');
        }

        const video = videos[0];
        
        await bot.sendPhoto(chatId, video.thumbnail, {
            caption: `🎶 *Musique trouvée!*\n\n🎵 *Titre:* ${video.title}\n👤 *Artiste:* ${video.author.name}\n⏱️ *Durée:* ${video.timestamp}\n\n📥 Téléchargement en cours...\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ꜱᴛᴇᴘʜ ᴛᴇᴄʜ*`,
            parse_mode: 'Markdown'
        });

        const apiUrl = `https://apis-keith.vercel.app/download/dlmp3?url=${video.url}`;
        const response = await axiosInstance.get(apiUrl);
        
        if (!response.data?.result?.data?.downloadUrl) {
            throw new Error('Erreur lors de l\'extraction audio');
        }

        await bot.sendAudio(chatId, response.data.result.data.downloadUrl, {
            caption: `🎧 *${video.title}*\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ꜱᴛᴇᴘʜ ᴛᴇᴄʜ*`,
            parse_mode: 'Markdown',
            title: video.title,
            performer: video.author.name
        });

    } catch (error) {
        console.error('Erreur /play:', error);
        bot.sendMessage(chatId, '❌ Une erreur s\'est produite lors du téléchargement.');
    }
}

/**
 * Commande /video - Télécharger une vidéo YouTube
 */
async function handleVideo(bot, chatId, args, msg) {
    const query = args.join(' ');
    
    if (!query) {
        return bot.sendMessage(chatId, '❌ Veuillez fournir le titre de la vidéo.\nExemple: `/video Alan Walker Faded`', { parse_mode: 'Markdown' });
    }

    try {
        const searchMsg = await bot.sendMessage(chatId, '🔍 Recherche de votre vidéo...');
        
        const { videos } = await yts(query);
        if (!videos || videos.length === 0) {
            throw new Error('Vidéo non trouvée');
        }

        const video = videos[0];
        
        const apiUrl = `https://apis.davidcyriltech.my.id/youtube/mp4?url=${encodeURIComponent(video.url)}`;
        const response = await axiosInstance.get(apiUrl);
        
        if (!response.data?.result?.url) {
            throw new Error('Erreur lors de l\'extraction vidéo');
        }

        await bot.sendVideo(chatId, response.data.result.url, {
            caption: `🎬 *${video.title}*\n\n👤 Chaîne: ${video.author.name}\n⏱️ Durée: ${video.timestamp}\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ꜱᴛᴇᴘʜ ᴛᴇᴄʜ*`,
            parse_mode: 'Markdown'
        });

        await bot.deleteMessage(chatId, searchMsg.message_id);

    } catch (error) {
        console.error('Erreur /video:', error);
        bot.sendMessage(chatId, '❌ Une erreur s\'est produite lors du téléchargement.');
    }
}

/**
 * Commande /tiktok - Télécharger une vidéo TikTok
 */
async function handleTikTok(bot, chatId, args, msg) {
    const url = args[0];
    
    if (!url) {
        return bot.sendMessage(chatId, '❌ Veuillez fournir un lien TikTok.\nExemple: `/tiktok https://vm.tiktok.com/...`', { parse_mode: 'Markdown' });
    }

    try {
        await bot.sendMessage(chatId, '📥 Téléchargement en cours...');
        
        const apiUrl = `https://apis.davidcyriltech.my.id/download/tiktokv3?url=${encodeURIComponent(url)}`;
        const response = await axiosInstance.get(apiUrl);
        
        if (!response.data.success || !response.data.video) {
            throw new Error('Vidéo non trouvée');
        }

        const videoBuffer = await axiosInstance.get(response.data.video, { responseType: 'arraybuffer' });
        
        await bot.sendVideo(chatId, videoBuffer.data, {
            caption: `🎬 *TikTok Video*\n\n${response.data.description || ''}\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ꜱᴛᴇᴘʜ ᴛᴇᴄʜ*`,
            parse_mode: 'Markdown'
        });

    } catch (error) {
        console.error('Erreur /tiktok:', error);
        bot.sendMessage(chatId, '❌ Impossible de télécharger cette vidéo TikTok.');
    }
}

/**
 * Commande /instagram - Télécharger depuis Instagram
 */
async function handleInstagram(bot, chatId, args, msg) {
    const url = args[0];
    
    if (!url) {
        return bot.sendMessage(chatId, '❌ Veuillez fournir un lien Instagram.\nExemple: `/instagram https://www.instagram.com/p/...`', { parse_mode: 'Markdown' });
    }

    try {
        await bot.sendMessage(chatId, '📥 Téléchargement en cours...');
        
        const apiUrl = `https://api.siputzx.my.id/api/d/igdl?url=${encodeURIComponent(url)}`;
        const response = await axiosInstance.get(apiUrl);
        
        if (!response.data.status || response.data.data.length === 0) {
            throw new Error('Média non trouvé');
        }

        for (const media of response.data.data) {
            const mediaBuffer = await axiosInstance.get(media.url, { responseType: 'arraybuffer' });
            const isVideo = media.url.includes('.mp4');
            
            if (isVideo) {
                await bot.sendVideo(chatId, mediaBuffer.data, {
                    caption: '*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ꜱᴛᴇᴘʜ ᴛᴇᴄʜ*',
                    parse_mode: 'Markdown'
                });
            } else {
                await bot.sendPhoto(chatId, mediaBuffer.data, {
                    caption: '*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ꜱᴛᴇᴘʜ ᴛᴇᴄʜ*',
                    parse_mode: 'Markdown'
                });
            }
            
            await new Promise(resolve => setTimeout(resolve, 1000));
        }

    } catch (error) {
        console.error('Erreur /instagram:', error);
        bot.sendMessage(chatId, '❌ Impossible de télécharger ce contenu Instagram.');
    }
}

/**
 * Commande /facebook - Télécharger depuis Facebook
 */
async function handleFacebook(bot, chatId, args, msg) {
    const url = args[0];
    
    if (!url) {
        return bot.sendMessage(chatId, '❌ Veuillez fournir un lien Facebook.\nExemple: `/facebook https://www.facebook.com/...`', { parse_mode: 'Markdown' });
    }

    try {
        await bot.sendMessage(chatId, '📥 Téléchargement en cours...');
        
        const apiUrl = `https://apis.davidcyriltech.my.id/facebook?url=${encodeURIComponent(url)}`;
        const response = await axiosInstance.get(apiUrl);
        
        const data = response.data.result;
        const videoUrl = data.downloads.hd?.url || data.downloads.sd?.url;
        
        if (!videoUrl) {
            throw new Error('Vidéo non trouvée');
        }

        await bot.sendVideo(chatId, videoUrl, {
            caption: `🎬 *${data.title || 'Facebook Video'}*\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ꜱᴛᴇᴘʜ ᴛᴇᴄʜ*`,
            parse_mode: 'Markdown'
        });

    } catch (error) {
        console.error('Erreur /facebook:', error);
        bot.sendMessage(chatId, '❌ Impossible de télécharger cette vidéo Facebook.');
    }
}

/**
 * Commande /spotify - Télécharger depuis Spotify
 */
async function handleSpotify(bot, chatId, args, msg) {
    const url = args[0];
    
    if (!url) {
        return bot.sendMessage(chatId, '❌ Veuillez fournir un lien Spotify.\nExemple: `/spotify https://open.spotify.com/track/...`', { parse_mode: 'Markdown' });
    }

    try {
        await bot.sendMessage(chatId, '📥 Téléchargement en cours...');
        
        const apiUrl = `https://api.siputzx.my.id/api/download/spotify?url=${encodeURIComponent(url)}`;
        const response = await axiosInstance.get(apiUrl);
        
        const data = response.data.data;
        
        if (!data.mp3DownloadLink) {
            throw new Error('Audio non trouvé');
        }

        if (data.coverImage) {
            await bot.sendPhoto(chatId, data.coverImage, {
                caption: `🎵 *${data.songTitle}*\n\n👤 Artiste: ${data.artist}\n💿 Album: ${data.album}\n📅 Année: ${data.releaseDate}\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ꜱᴛᴇᴘʜ ᴛᴇᴄʜ*`,
                parse_mode: 'Markdown'
            });
        }

        await bot.sendAudio(chatId, data.mp3DownloadLink, {
            caption: `🎧 *${data.songTitle}*\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ꜱᴛᴇᴘʜ ᴛᴇᴄʜ*`,
            parse_mode: 'Markdown',
            title: data.songTitle,
            performer: data.artist
        });

    } catch (error) {
        console.error('Erreur /spotify:', error);
        bot.sendMessage(chatId, '❌ Impossible de télécharger cette musique Spotify.');
    }
}

/**
 * Commande /applemusic - Télécharger depuis Apple Music
 */
async function handleAppleMusic(bot, chatId, args, msg) {
    const url = args[0];
    
    if (!url) {
        return bot.sendMessage(chatId, '❌ Veuillez fournir un lien Apple Music.\nExemple: `/applemusic https://music.apple.com/...`', { parse_mode: 'Markdown' });
    }

    try {
        await bot.sendMessage(chatId, '📥 Téléchargement en cours...');
        
        const apiUrl = `https://api.siputzx.my.id/api/d/musicapple?url=${encodeURIComponent(url)}`;
        const response = await axiosInstance.get(apiUrl);
        
        const data = response.data.data;
        
        if (!data.download) {
            throw new Error('Audio non trouvé');
        }

        if (data.artworkUrl) {
            await bot.sendPhoto(chatId, data.artworkUrl, {
                caption: `🎵 *${data.title}*\n\n👤 Artiste: ${data.artist}\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ꜱᴛᴇᴘʜ ᴛᴇᴄʜ*`,
                parse_mode: 'Markdown'
            });
        }

        await bot.sendAudio(chatId, data.download, {
            caption: `🎧 *${data.title}*\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ꜱᴛᴇᴘʜ ᴛᴇᴄʜ*`,
            parse_mode: 'Markdown',
            title: data.title,
            performer: data.artist
        });

    } catch (error) {
        console.error('Erreur /applemusic:', error);
        bot.sendMessage(chatId, '❌ Impossible de télécharger cette musique Apple Music.');
    }
}

/**
 * Commande /qr - Générer un QR code
 */
async function handleQR(bot, chatId, args, msg) {
    const text = args.join(' ');
    
    if (!text) {
        return bot.sendMessage(chatId, '❌ Veuillez fournir un texte ou une URL.\nExemple: `/qr https://example.com`', { parse_mode: 'Markdown' });
    }

    try {
        const apiUrl = `https://api.siputzx.my.id/api/tools/text2qr?text=${encodeURIComponent(text)}`;
        const response = await axiosInstance.get(apiUrl, { responseType: 'arraybuffer' });
        
        await bot.sendPhoto(chatId, response.data, {
            caption: `📱 *QR Code généré!*\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ꜱᴛᴇᴘʜ ᴛᴇᴄʜ*`,
            parse_mode: 'Markdown'
        });

    } catch (error) {
        console.error('Erreur /qr:', error);
        bot.sendMessage(chatId, '❌ Impossible de générer le QR code.');
    }
}

/**
 * Commande /translate - Traduire du texte
 */
async function handleTranslate(bot, chatId, args, msg) {
    const [targetLang, ...textParts] = args;
    const textToTranslate = textParts.join(' ');
    
    if (!targetLang || !textToTranslate) {
        return bot.sendMessage(chatId, '❌ Veuillez fournir la langue cible et le texte.\nExemple: `/translate en Bonjour le monde`', { parse_mode: 'Markdown' });
    }

    try {
        const apiUrl = `https://api.siputzx.my.id/api/tools/translate?text=${encodeURIComponent(textToTranslate)}&target=${targetLang}&source=auto`;
        const response = await axiosInstance.get(apiUrl);
        
        await bot.sendMessage(chatId, 
            `🌐 *Traduction (${targetLang}):*\n\n${response.data.translatedText}\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ꜱᴛᴇᴘʜ ᴛᴇᴄʜ*`,
            { parse_mode: 'Markdown' }
        );

    } catch (error) {
        console.error('Erreur /translate:', error);
        bot.sendMessage(chatId, '❌ Impossible de traduire le texte.');
    }
}

/**
 * Commande /img - Rechercher des images
 */
async function handleImageSearch(bot, chatId, args, msg) {
    const query = args.join(' ');
    
    if (!query) {
        return bot.sendMessage(chatId, '❌ Veuillez fournir un terme de recherche.\nExemple: `/img nature`', { parse_mode: 'Markdown' });
    }

    try {
        await bot.sendMessage(chatId, '🔍 Recherche d\'images en cours...');
        
        const apiUrl = `https://apis.davidcyriltech.my.id/googleimage?query=${encodeURIComponent(query)}`;
        const response = await axiosInstance.get(apiUrl);
        const images = response.data.results;
        
        if (!images || images.length === 0) {
            throw new Error('Aucune image trouvée');
        }

        const imagesToSend = images.sort(() => 0.5 - Math.random()).slice(0, 4);
        
        for (const imageUrl of imagesToSend) {
            try {
                await bot.sendPhoto(chatId, imageUrl, {
                    caption: '*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ꜱᴛᴇᴘʜ ᴛᴇᴄʜ*',
                    parse_mode: 'Markdown'
                });
                await new Promise(resolve => setTimeout(resolve, 500));
            } catch (imgError) {
                console.error('Erreur envoi image:', imgError);
            }
        }

    } catch (error) {
        console.error('Erreur /img:', error);
        bot.sendMessage(chatId, '❌ Impossible de rechercher des images.');
    }
}

/**
 * Commande /addpremium - Ajouter un utilisateur premium
 */
async function handleAddPremium(bot, chatId, userId, args, msg) {
    if (!premiumManager.isAdmin(userId)) {
        return bot.sendMessage(chatId, '❌ Cette commande est réservée aux administrateurs.');
    }

    if (args.length < 1) {
        return bot.sendMessage(chatId, '❌ Usage: `/addpremium <@username ou ID> [jours]`\nExemple: `/addpremium @user123 30`', { parse_mode: 'Markdown' });
    }

    try {
        let targetUserId;
        let targetUsername = args[0];
        let durationDays = args[1] ? parseInt(args[1]) : null;

       
        if (msg.reply_to_message) {
            targetUserId = msg.reply_to_message.from.id;
            targetUsername = msg.reply_to_message.from.username || msg.reply_to_message.from.first_name;
            
            console.log('📝 Ajout via réponse:');
            console.log('   Target ID:', targetUserId);
            console.log('   Target Username:', targetUsername);
        } 
        
        else if (!isNaN(targetUsername)) {
            targetUserId = parseInt(targetUsername);
            
            console.log('📝 Ajout via ID numérique:');
            console.log('   Target ID:', targetUserId);
        }
        
        else if (targetUsername.startsWith('@')) {
            targetUsername = targetUsername.substring(1);
            
            return bot.sendMessage(chatId, 
                '⚠️ *Impossible d\'ajouter via @username*\n\n' +
                'Veuillez utiliser l\'une de ces méthodes:\n' +
                '1️⃣ Répondre au message de l\'utilisateur avec `/addpremium [jours]`\n' +
                '2️⃣ Utiliser son ID numérique: `/addpremium 123456789 [jours]`\n\n' +
                'Pour obtenir l\'ID, demandez à l\'utilisateur d\'utiliser `/checkpremium`',
                { parse_mode: 'Markdown' }
            );
        }

        const userData = await premiumManager.addPremium(targetUserId, targetUsername, durationDays);
        
        let message = `✅ *Utilisateur ajouté au Premium!*\n\n`;
        message += `❏ Utilisateur: @${targetUsername}\n`;
        message += `❏ ID: \`${targetUserId}\`\n`;
        message += `❏ Ajouté le: ${new Date(userData.addedAt).toLocaleDateString()}\n`;
        
        if (userData.expiresAt) {
            message += `❏ Expire le: ${new Date(userData.expiresAt).toLocaleDateString()}\n`;
            message += `❏ Durée: ${durationDays} jours`;
        } else {
            message += `♾️ Durée: Illimitée`;
        }
        
        message += `\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ꜱᴛᴇᴘʜ ᴛᴇᴄʜ*`;

        await bot.sendMessage(chatId, message, { parse_mode: 'Markdown' });

    } catch (error) {
        console.error('Erreur /addpremium:', error);
        bot.sendMessage(chatId, '❌ Une erreur s\'est produite.');
    }
}

/**
 * Commande /removepremium - Retirer le premium
 */
async function handleRemovePremium(bot, chatId, userId, args, msg) {
    if (!premiumManager.isAdmin(userId)) {
        return bot.sendMessage(chatId, '❌ Cette commande est réservée aux administrateurs.');
    }

    if (args.length < 1) {
        return bot.sendMessage(chatId, '❌ Usage: `/removepremium <@username ou ID>`', { parse_mode: 'Markdown' });
    }

    try {
        let targetUserId;
        let targetUsername = args[0];

        if (msg.reply_to_message) {
            targetUserId = msg.reply_to_message.from.id;
        } else if (targetUsername.startsWith('@')) {
            targetUserId = targetUsername.substring(1);
        } else {
            targetUserId = targetUsername;
        }

        const removed = await premiumManager.removePremium(targetUserId);
        
        if (removed) {
            await bot.sendMessage(chatId, 
                `✅ *Premium retiré!*\n\n👤 Utilisateur: ${targetUsername}\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ꜱᴛᴇᴘʜ ᴛᴇᴄʜ*`,
                { parse_mode: 'Markdown' }
            );
        } else {
            await bot.sendMessage(chatId, '❌ Cet utilisateur n\'est pas premium.');
        }

    } catch (error) {
        console.error('Erreur /removepremium:', error);
        bot.sendMessage(chatId, '❌ Une erreur s\'est produite.');
    }
}

/**
 * Commande /checkpremium - Vérifier le statut premium
 */
async function handleCheckPremium(bot, chatId, args, msg) {
    try {
        let targetUserId;
        let targetUsername;

        if (args.length > 0) {
            targetUsername = args[0];
            if (targetUsername.startsWith('@')) {
                targetUserId = targetUsername.substring(1);
            } else {
                targetUserId = targetUsername;
            }
        } else if (msg.reply_to_message) {
            targetUserId = msg.reply_to_message.from.id;
            targetUsername = msg.reply_to_message.from.username || msg.reply_to_message.from.first_name;
        } else {
            targetUserId = msg.from.id;
            targetUsername = msg.from.username || msg.from.first_name;
        }

        const isPremium = await premiumManager.checkPremium(targetUserId);
        const info = premiumManager.getPremiumInfo(targetUserId);

        let message = `❏ *Statut Premium*\n\n`;
        message += `❏ Utilisateur: @${targetUsername}\n`;
        message += `❏ ID: ${targetUserId}\n`;
        message += `❏ Premium: ${isPremium ? '✅ Oui' : '❌ Non'}\n`;

        if (isPremium && info) {
            message += `❏ Ajouté le: ${new Date(info.addedAt).toLocaleDateString()}\n`;
            if (info.expiresAt) {
                message += `❏ Expire le: ${new Date(info.expiresAt).toLocaleDateString()}`;
            } else {
                message += `♾️ Durée: Illimitée`;
            }
        }

        message += `\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ꜱᴛᴇᴘʜ ᴛᴇᴄʜ*`;

        await bot.sendMessage(chatId, message, { parse_mode: 'Markdown' });

    } catch (error) {
        console.error('Erreur /checkpremium:', error);
        bot.sendMessage(chatId, '❌ Une erreur s\'est produite.');
    }
}

/**
 * Commande /listpremium - Liste des utilisateurs premium
 */
async function handleListPremium(bot, chatId, userId, msg) {
    if (!premiumManager.isAdmin(userId)) {
        return bot.sendMessage(chatId, '❌ Cette commande est réservée aux administrateurs.');
    }

    try {
        const premiumList = premiumManager.getPremiumList();

        if (premiumList.length === 0) {
            return bot.sendMessage(chatId, '📭 Aucun utilisateur premium pour le moment.');
        }

        let message = `❏ *LISTE DES UTILISATEURS PREMIUM*\n`;
        message += `Total: ${premiumList.length}\n\n`;

        premiumList.forEach((user, index) => {
            message += `${index + 1}. @${user.username}\n`;
            message += `   🆔 ${user.userId}\n`;
            
            if (user.expiresAt) {
                const daysLeft = Math.ceil((new Date(user.expiresAt) - new Date()) / (1000 * 60 * 60 * 24));
                message += `   ❏ Expire dans ${daysLeft} jour${daysLeft > 1 ? 's' : ''}\n`;
            } else {
                message += `   ♾️ Illimité\n`;
            }
            message += `\n`;
        });

        message += `*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ꜱᴛᴇᴘʜ ᴛᴇᴄʜ*`;

        await bot.sendMessage(chatId, message, { parse_mode: 'Markdown' });

    } catch (error) {
        console.error('Erreur /listpremium:', error);
        bot.sendMessage(chatId, '❌ Une erreur s\'est produite.');
    }

    /**
 * Commande /myid - Obtenir son ID Telegram
 */

}

async function handleMyId(bot, chatId, args, msg) {
    const userId = msg.from.id;
    const username = msg.from.username || msg.from.first_name;
    const firstName = msg.from.first_name;
    const lastName = msg.from.last_name || '';

    try {
        let message = `❏ *VOS INFORMATIONS TELEGRAM*\n\n`;
        message += `❏ Nom: ${firstName} ${lastName}\n`;
        message += `❏ Username: ${username ? '@' + username : 'Aucun'}\n`;
        message += `❏ ID: \`${userId}\`\n\n`;
        message += `❏ *Pour obtenir le Premium:*\n`;
        message += `Envoyez cet ID à l'administrateur:\n`;
        message += `\`${userId}\`\n\n`;
        message += `*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ꜱᴛᴇᴘʜ ᴛᴇᴄʜ*`;

        await bot.sendMessage(chatId, message, { parse_mode: 'Markdown' });

    } catch (error) {
        console.error('Erreur /myid:', error);
        bot.sendMessage(chatId, '❌ Une erreur s\'est produite.');
    }
}

// ============================================
// EXPORTS
// ============================================

module.exports = {
    handleStart,
    handleHelp,
    handlePlay,
    handleVideo,
    handleTikTok,
    handleInstagram,
    handleFacebook,
    handleSpotify,
    handleAppleMusic,
    handleQR,
    handleMyId,
    handleTranslate,
    handleImageSearch,
    handleAddPremium,
    handleRemovePremium,
    handleCheckPremium,
    handleListPremium
};