"""
Example usage of Pomice's new advanced features.

This example demonstrates:
- Track History
- Queue Statistics
- Playlist Export/Import
- Track Filtering and Search
"""

import asyncio
import discord
from discord.ext import commands
import pomice

# Initialize bot
bot = commands.Bot(command_prefix='!', intents=discord.Intents.all())


class AdvancedMusic(commands.Cog):
    """Music cog with advanced features."""

    def __init__(self, bot):
        self.bot = bot
        self.pomice = pomice.NodePool()
        
        # Track history for each guild
        self.track_histories = {}

    async def start_nodes(self):
        """Start Lavalink nodes."""
        await self.pomice.create_node(
            bot=self.bot,
            host='127.0.0.1',
            port='3030',
            password='youshallnotpass',
            identifier='MAIN'
        )

    @commands.Cog.listener()
    async def on_pomice_track_end(self, player, track, _):
        """Add track to history when it ends."""
        if player.guild.id not in self.track_histories:
            self.track_histories[player.guild.id] = pomice.TrackHistory(max_size=100)
        
        self.track_histories[player.guild.id].add(track)

    @commands.command(name='play')
    async def play(self, ctx, *, search: str):
        """Play a track."""
        if not ctx.voice_client:
            await ctx.author.voice.channel.connect(cls=pomice.Player)

        player = ctx.voice_client
        results = await player.get_tracks(query=search, ctx=ctx)

        if not results:
            return await ctx.send('No results found.')

        if isinstance(results, pomice.Playlist):
            await player.queue.put(results.tracks)
            await ctx.send(f'Added playlist **{results.name}** with {len(results.tracks)} tracks.')
        else:
            track = results[0]
            await player.queue.put(track)
            await ctx.send(f'Added **{track.title}** to queue.')

        if not player.is_playing:
            await player.do_next()

    @commands.command(name='history')
    async def history(self, ctx, limit: int = 10):
        """Show recently played tracks."""
        if ctx.guild.id not in self.track_histories:
            return await ctx.send('No history available.')

        history = self.track_histories[ctx.guild.id]
        
        if history.is_empty:
            return await ctx.send('No tracks in history.')

        tracks = history.get_last(limit)
        
        embed = discord.Embed(
            title='🎵 Recently Played',
            color=discord.Color.blue()
        )
        
        for i, track in enumerate(tracks, 1):
            embed.add_field(
                name=f'{i}. {track.title}',
                value=f'by {track.author}',
                inline=False
            )
        
        await ctx.send(embed=embed)

    @commands.command(name='stats')
    async def queue_stats(self, ctx):
        """Show detailed queue statistics."""
        if not ctx.voice_client:
            return await ctx.send('Not connected to voice.')

        player = ctx.voice_client
        stats = pomice.QueueStats(player.queue)
        summary = stats.get_summary()

        embed = discord.Embed(
            title='📊 Queue Statistics',
            color=discord.Color.green()
        )
        
        embed.add_field(
            name='Total Tracks',
            value=summary['total_tracks'],
            inline=True
        )
        embed.add_field(
            name='Total Duration',
            value=summary['total_duration_formatted'],
            inline=True
        )
        embed.add_field(
            name='Average Duration',
            value=summary['average_duration_formatted'],
            inline=True
        )
        
        if summary['longest_track']:
            embed.add_field(
                name='Longest Track',
                value=f"{summary['longest_track'].title} ({stats.format_duration(summary['longest_track'].length)})",
                inline=False
            )
        
        # Duration breakdown
        breakdown = summary['duration_breakdown']
        embed.add_field(
            name='Duration Breakdown',
            value=f"Short (<3min): {breakdown['short']}\n"
                  f"Medium (3-6min): {breakdown['medium']}\n"
                  f"Long (6-10min): {breakdown['long']}\n"
                  f"Very Long (>10min): {breakdown['very_long']}",
            inline=False
        )
        
        # Top requesters
        top_requesters = stats.get_top_requesters(3)
        if top_requesters:
            requesters_text = '\n'.join(
                f'{i}. {req.display_name}: {count} tracks'
                for i, (req, count) in enumerate(top_requesters, 1)
            )
            embed.add_field(
                name='Top Requesters',
                value=requesters_text,
                inline=False
            )
        
        await ctx.send(embed=embed)

    @commands.command(name='export')
    async def export_queue(self, ctx, filename: str = 'playlist.json'):
        """Export current queue to a file."""
        if not ctx.voice_client:
            return await ctx.send('Not connected to voice.')

        player = ctx.voice_client
        
        if player.queue.is_empty:
            return await ctx.send('Queue is empty.')

        try:
            pomice.PlaylistManager.export_queue(
                player.queue,
                f'playlists/{filename}',
                name=f"{ctx.guild.name}'s Playlist",
                description=f'Exported from {ctx.guild.name}'
            )
            await ctx.send(f'✅ Queue exported to `playlists/{filename}`')
        except Exception as e:
            await ctx.send(f'❌ Error exporting queue: {e}')

    @commands.command(name='import')
    async def import_playlist(self, ctx, filename: str):
        """Import a playlist from a file."""
        if not ctx.voice_client:
            await ctx.author.voice.channel.connect(cls=pomice.Player)

        player = ctx.voice_client

        try:
            data = pomice.PlaylistManager.import_playlist(f'playlists/{filename}')
            
            # Get URIs and search for tracks
            uris = [track['uri'] for track in data['tracks'] if track.get('uri')]
            
            added = 0
            for uri in uris:
                try:
                    results = await player.get_tracks(query=uri, ctx=ctx)
                    if results:
                        if isinstance(results, pomice.Playlist):
                            await player.queue.put(results.tracks)
                            added += len(results.tracks)
                        else:
                            await player.queue.put(results[0])
                            added += 1
                except:
                    continue
            
            await ctx.send(f'✅ Imported {added} tracks from `{data["name"]}`')
            
            if not player.is_playing:
                await player.do_next()
                
        except FileNotFoundError:
            await ctx.send(f'❌ Playlist file `{filename}` not found.')
        except Exception as e:
            await ctx.send(f'❌ Error importing playlist: {e}')

    @commands.command(name='filter')
    async def filter_queue(self, ctx, filter_type: str, *, value: str):
        """Filter queue by various criteria.
        
        Examples:
        !filter author Imagine Dragons
        !filter duration 180000-300000 (3-5 minutes in ms)
        !filter title Thunder
        """
        if not ctx.voice_client:
            return await ctx.send('Not connected to voice.')

        player = ctx.voice_client
        queue_tracks = list(player.queue)

        if filter_type == 'author':
            filtered = pomice.TrackFilter.by_author(queue_tracks, value)
        elif filter_type == 'title':
            filtered = pomice.TrackFilter.by_title(queue_tracks, value)
        elif filter_type == 'duration':
            # Parse duration range (e.g., "180000-300000")
            if '-' in value:
                min_dur, max_dur = map(int, value.split('-'))
                filtered = pomice.TrackFilter.by_duration(
                    queue_tracks,
                    min_duration=min_dur,
                    max_duration=max_dur
                )
            else:
                return await ctx.send('Duration format: min-max (in milliseconds)')
        else:
            return await ctx.send('Valid filters: author, title, duration')

        if not filtered:
            return await ctx.send('No tracks match the filter.')

        embed = discord.Embed(
            title=f'🔍 Filtered Results ({len(filtered)} tracks)',
            color=discord.Color.purple()
        )
        
        for i, track in enumerate(filtered[:10], 1):
            stats = pomice.QueueStats(player.queue)
            embed.add_field(
                name=f'{i}. {track.title}',
                value=f'by {track.author} - {stats.format_duration(track.length)}',
                inline=False
            )
        
        if len(filtered) > 10:
            embed.set_footer(text=f'Showing 10 of {len(filtered)} results')
        
        await ctx.send(embed=embed)

    @commands.command(name='search_history')
    async def search_history(self, ctx, *, query: str):
        """Search through play history."""
        if ctx.guild.id not in self.track_histories:
            return await ctx.send('No history available.')

        history = self.track_histories[ctx.guild.id]
        results = history.search(query)

        if not results:
            return await ctx.send(f'No tracks found matching "{query}"')

        embed = discord.Embed(
            title=f'🔍 History Search: "{query}"',
            description=f'Found {len(results)} tracks',
            color=discord.Color.gold()
        )
        
        for i, track in enumerate(results[:10], 1):
            embed.add_field(
                name=f'{i}. {track.title}',
                value=f'by {track.author}',
                inline=False
            )
        
        if len(results) > 10:
            embed.set_footer(text=f'Showing 10 of {len(results)} results')
        
        await ctx.send(embed=embed)

    @commands.command(name='sort')
    async def sort_queue(self, ctx, sort_by: str = 'duration'):
        """Sort the queue.
        
        Options: duration, title, author
        """
        if not ctx.voice_client:
            return await ctx.send('Not connected to voice.')

        player = ctx.voice_client
        
        if player.queue.is_empty:
            return await ctx.send('Queue is empty.')

        queue_tracks = list(player.queue)

        if sort_by == 'duration':
            sorted_tracks = pomice.SearchHelper.sort_by_duration(queue_tracks)
        elif sort_by == 'title':
            sorted_tracks = pomice.SearchHelper.sort_by_title(queue_tracks)
        elif sort_by == 'author':
            sorted_tracks = pomice.SearchHelper.sort_by_author(queue_tracks)
        else:
            return await ctx.send('Valid options: duration, title, author')

        # Clear and refill queue
        player.queue._queue.clear()
        for track in sorted_tracks:
            await player.queue.put(track)

        await ctx.send(f'✅ Queue sorted by {sort_by}')


@bot.event
async def on_ready():
    print(f'{bot.user} is ready!')
    await bot.get_cog('AdvancedMusic').start_nodes()


# Add cog
bot.add_cog(AdvancedMusic(bot))

# Run bot
bot.run('YOUR_BOT_TOKEN')