The Most Advanced Lavalink Client for Discord.js

// Synced lyrics with real-time display
eura.on('trackStart', async (player, track) => {
  const lyrics = await player.getLyrics();
  
  if (lyrics && lyrics.lines.length > 0) {
    const channel = client.channels.cache.get(player.textChannel);
    channel?.send(`🎤 **Synced lyrics available for:** ${track.info.title}`);
    
    // Create lyrics display interval
    const lyricsInterval = setInterval(() => {
      const currentLine = player.getCurrentLyricLine();
      
      if (currentLine && currentLine.text.trim()) {
        console.log(`🎵 ${currentLine.text}`);
        
        // Send to Discord channel every 10 seconds
        if (Date.now() % 10000 < 1000) {
          channel?.send(`🎵 \`${currentLine.text}\``);
        }
      }
    }, 1000);
    
    // Clear interval when track ends
    player.once('trackEnd', () => {
      clearInterval(lyricsInterval);
    });
  }
});

// Manual lyrics command
client.on('messageCreate', async (message) => {
  if (message.content === '!lyrics') {
    const player = eura.players.get(message.guildId);
    
    if (player && player.current) {
      const currentLine = player.getCurrentLyricLine();
      
      if (currentLine) {
        message.reply(`🎵 **Current lyric:** ${currentLine.text}`);
      } else {
        message.reply('❌ No synced lyrics available for this track');
      }
    }
  }
});

// Filter preset commands
client.on('messageCreate', async (message) => {
  if (message.content.startsWith('!preset ')) {
    const preset = message.content.split(' ')[1];
    const player = eura.players.get(message.guildId);
    
    if (!player) return message.reply('❌ No active player');
    
    try {
      // Apply preset with automatic filter clearing
      await player.setPreset(preset, { clearFilters: true });
      message.reply(`✅ Applied **${preset}** preset!`);
    } catch (error) {
      message.reply(`❌ Invalid preset. Available: ${availablePresets.join(', ')}`);
    }
  }
  
  if (message.content === '!presets') {
    const presetsList = availablePresets.map(preset => `\`${preset}\``).join(', ');
    message.reply(`🎛️ **Available presets:** ${presetsList}`);
  }
  
  if (message.content === '!clear-filters') {
    const player = eura.players.get(message.guildId);
    if (player) {
      await player.clearFilters();
      message.reply('🔄 Cleared all audio filters');
    }
  }
});

const availablePresets = [
  'nightcore', 'vaporwave', 'bassboost', 'karaoke',
  'pop', 'rock', 'classical', 'electronic',
  'gaming-fps', 'gaming-moba', 'podcast', 'vocal-boost',
  'cinema', 'radio', 'studio', 'live'
];

// Automatic error recovery setup
const eura = new Euralink(client, nodes, {
  send: (data) => {
    const guild = client.guilds.cache.get(data.d.guild_id);
    if (guild) guild.shard.send(data);
  },
  autoResume: true,
  restVersion: 'v4',
  // Enhanced error recovery options
  retryLimit: 5,
  retryDelay: 1000,
  failoverTimeout: 30000
});

// Node error handling
eura.on('nodeError', async (node, error) => {
  console.log(`❌ Node ${node.name} error:`, error.message);
  
  // Perform health check
  const healthStatus = await eura.performHealthCheck();
  console.log('🏥 Health status:', healthStatus);
  
  // Migrate players if needed
  const players = [...eura.players.values()].filter(p => p.node === node);
  for (const player of players) {
    const bestNode = eura.getBestNode();
    if (bestNode && bestNode !== node) {
      await eura.migratePlayer(player.guildId, bestNode);
      console.log(`🔄 Migrated player ${player.guildId} to ${bestNode.name}`);
    }
  }
});

// Player error recovery
eura.on('playerError', async (player, error) => {
  console.log(`❌ Player error in ${player.guildId}:`, error.message);
  
  // Attempt automatic recovery
  try {
    if (player.current) {
      await player.restart();
      console.log(`🔄 Restarted player ${player.guildId}`);
    }
  } catch (recoveryError) {
    console.log(`❌ Recovery failed for ${player.guildId}`);
    // Implement fallback strategy
    player.stop();
  }
});

// Save/load player states for persistence
process.on('SIGINT', async () => {
  await eura.savePlayersState('./players.json');
  console.log('💾 Saved player states');
  process.exit(0);
});

client.on('ready', async () => {
  eura.init(client.user.id);
  
  try {
    const loadedCount = await eura.loadPlayersState('./players.json');
    console.log(`📂 Loaded ${loadedCount} player states`);
  } catch (error) {
    console.log('ℹ️ No saved states found');
  }
});