refactor music

1 files changed, 81 insertions, 64 deletions

diff --git a/cogs/music/play.py b/cogs/music/play_commands.py
index c7dd9f1..b25ce84 100644
--- a/cogs/music/play.py
+++ b/cogs/music/play_commands.py
@@ -9,14 +9,16 @@ import mutagen
 from typing import List, Tuple, Callable, Awaitable
 from os import PathLike
 
-from cogs.music import play_utils
+from cogs.music import search_utils, audio_playback, media_processing
 from discord.ext import commands
 from discord.commands import OptionChoice
 import logging
 
 logger = logging.getLogger(__name__)
 
-class Play(commands.Cog):
+class PlayCommands(commands.Cog):
+    """Discord slash commands for music playback."""
+    
     def __init__(self, bot):
         self.bot = bot
         self.temp_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "temp")
@@ -83,38 +85,38 @@ class Play(commands.Cog):
             
         await ctx.respond(embed=embed, view=view, ephemeral=True)
 
+    def _get_display_name_from_metadata(self, path: str, filename: str) -> str:
+        """Extract display name from audio file metadata."""
+        try:
+            if os.path.splitext(path)[1].lower() in ['.mp3', '.wav', '.opus', '.m4a']:
+                metadata = mutagen.File(path, easy=True)
+                
+                title = metadata.get('title', [filename])[0]
+                artist = metadata.get('artist', [''])[0]
+                album_artist = metadata.get('albumartist', [artist])[0]
+                
+                if album_artist and title:
+                    return f"{album_artist} - {title}"
+                elif artist and title:
+                    return f"{artist} - {title}"
+                elif title:
+                    return title
+        except Exception as e:
+            logger.debug(f"Could not read metadata for {filename}: {str(e)}")
+        
+        return filename
+
     async def _search_autocomplete(self, ctx: discord.AutocompleteContext) -> List[OptionChoice]:
         """Autocomplete handler for search queries."""
         query = ctx.value.lower()
         try:
-            results = await play_utils.PlayUtils.search_local_autocomplete(query, max_results=25)
+            results = await search_utils.AudioSearcher.search_local_autocomplete(query, max_results=25)
             choices = []
             self.path_mapping = {}  # Reset the mapping for each new query
             
             for path in results:
                 filename = os.path.splitext(os.path.basename(path))[0]  # Remove extension
-                display = filename  # Default display name
-                
-                # Try to get metadata for display
-                try:
-                    if os.path.splitext(path)[1].lower() in ['.mp3', '.wav', '.opus', '.m4a']:
-                        metadata = mutagen.File(path, easy=True)
-                        
-                        # Get metadata fields, falling back to filename if not available
-                        title = metadata.get('title', [filename])[0]
-                        artist = metadata.get('artist', [''])[0]
-                        album_artist = metadata.get('albumartist', [artist])[0]
-                        
-                        # Build display name based on available metadata
-                        if album_artist and title:
-                            display = f"{album_artist} - {title}"
-                        elif artist and title:
-                            display = f"{artist} - {title}"
-                        elif title:
-                            display = title
-                            
-                except Exception as e:
-                    logger.debug(f"Could not read metadata for {filename}: {str(e)}")
+                display = self._get_display_name_from_metadata(path, filename)
                 
                 # Clean up the display name (remove any extra whitespace or brackets)
                 display = display.strip()
@@ -138,6 +140,55 @@ class Play(commands.Cog):
             logger.error(f"Error in autocomplete: {str(e)}", exc_info=True)
             return []
 
+    def _validate_play_inputs(self, file: str, stream: str, ctx: discord.ApplicationContext) -> bool:
+        """Validate input parameters for play command."""
+        if not file and not stream:
+            ctx.respond("Musisz podać plik do odtworzenia lub adres streamu.", ephemeral=True)
+            return False
+            
+        if file and stream:
+            ctx.respond("Możesz podać tylko plik LUB stream, nie oba naraz.", ephemeral=True)
+            return False
+            
+        return True
+
+    async def _handle_stream_play(self, ctx: discord.ApplicationContext, stream: str) -> None:
+        """Handle internet stream playback."""
+        await audio_playback.AudioPlaybackManager.play(ctx, stream)
+
+    async def _handle_compressed_file_play(self, ctx: discord.ApplicationContext, full_path: str) -> None:
+        """Handle compressed file playback with cleanup."""
+        compressed_path = await media_processing.AudioCompressor.compress(ctx, full_path)
+        if not compressed_path:
+            await ctx.respond("Nie udało się skompresować pliku.", ephemeral=True)
+            return
+            
+        try:
+            await audio_playback.AudioPlaybackManager.play(ctx, compressed_path, delete_after_play=True)
+        except Exception as e:
+            # Clean up the compressed file if play fails
+            if os.path.exists(compressed_path):
+                try:
+                    os.remove(compressed_path)
+                    logger.info(f"Cleaned up temporary file after play error: {compressed_path}")
+                except Exception as cleanup_error:
+                    logger.error(f"Error cleaning up file {compressed_path}: {str(cleanup_error)}")
+            raise e
+
+    async def _handle_local_file_play(self, ctx: discord.ApplicationContext, file: str, compressed: bool) -> None:
+        """Handle local file playback."""
+        full_path = self.path_mapping.get(file, file)
+        
+        if not os.path.exists(full_path):
+            logger.warning(f"File not found: {full_path} (display name: {file})")
+            await ctx.respond("Wybrany plik nie istnieje.", ephemeral=True)
+            return
+        
+        if compressed:
+            await self._handle_compressed_file_play(ctx, full_path)
+        else:
+            await audio_playback.AudioPlaybackManager.play(ctx, full_path)
+
     @discord.slash_command(name="grajcuj", description="grajcujmy wszyscy!")
     async def play(
             self,
@@ -162,48 +213,14 @@ class Play(commands.Cog):
         """Odtwarza wybrany plik dźwiękowy lub stream internetowy."""
         await ctx.defer()
         
-        # Check if either file or stream is provided
-        if not file and not stream:
-            await ctx.respond("Musisz podać plik do odtworzenia lub adres streamu.", ephemeral=True)
-            return
-            
-        if file and stream:
-            await ctx.respond("Możesz podać tylko plik LUB stream, nie oba naraz.", ephemeral=True)
+        if not self._validate_play_inputs(file, stream, ctx):
             return
             
         try:
             if stream:
-                # Handle internet stream
-                await play_utils.PlayUtils(self.bot).play(ctx, stream)
+                await self._handle_stream_play(ctx, stream)
             else:
-                # Handle local file
-                full_path = self.path_mapping.get(file, file)
-                
-                if not os.path.exists(full_path):
-                    logger.warning(f"File not found: {full_path} (display name: {file})")
-                    await ctx.respond("Wybrany plik nie istnieje.", ephemeral=True)
-                    return
-                
-                if compressed:
-                    # Compress the file before playing
-                    compressed_path = await play_utils.PlayUtils(self.bot).compress(ctx, full_path)
-                    if not compressed_path:
-                        await ctx.respond("Nie udało się skompresować pliku.", ephemeral=True)
-                        return
-                        
-                    try:
-                        await play_utils.PlayUtils(self.bot).play(ctx, compressed_path, delete_after_play=True)
-                    except Exception as e:
-                        # Clean up the compressed file if play fails
-                        if os.path.exists(compressed_path):
-                            try:
-                                os.remove(compressed_path)
-                                logger.info(f"Cleaned up temporary file after play error: {compressed_path}")
-                            except Exception as cleanup_error:
-                                logger.error(f"Error cleaning up file {compressed_path}: {str(cleanup_error)}")
-                        raise e
-                else:
-                    await play_utils.PlayUtils(self.bot).play(ctx, full_path)
+                await self._handle_local_file_play(ctx, file, compressed)
         except Exception as e:
             logger.error(f"Error playing: {str(e)}", exc_info=True)
             await ctx.respond(f"Wystąpił błąd podczas odtwarzania: {str(e)}", ephemeral=True)
@@ -213,7 +230,7 @@ class Play(commands.Cog):
         await ctx.defer()
         file_path: PathLike[str] | str = os.path.join(self.temp_dir, attachment.filename)
         await attachment.save(file_path)
-        await play_utils.PlayUtils(self.bot).play(ctx, file_path)
+        await audio_playback.AudioPlaybackManager.play(ctx, file_path)
 
 def setup(bot):
-    bot.add_cog(Play(bot))
\ No newline at end of file
+    bot.add_cog(PlayCommands(bot))