1 files changed, 105 insertions, 3 deletions

diff --git a/cogs/music/play_commands.py b/cogs/music/play_commands.py
index a82fa9d..5373436 100644
--- a/cogs/music/play_commands.py
+++ b/cogs/music/play_commands.py
@@ -9,16 +9,22 @@ import urllib.parse
 import asyncio
 from os import PathLike
 from typing import Awaitable, Callable, List, Tuple
+import re
+from yt_dlp import YoutubeDL
 
 import discord
 from discord.commands import OptionChoice
 from discord.ext import commands
 
 from cogs.music import audio_playback, media_processing
-from cogs.utils import file_search as search_utils
+from cogs.utils.file_search import UniversalSearcher
 
 logger = logging.getLogger(__name__)
 
+EXTERNAL_URL_PATTERN = re.compile(
+    r"^https://(?=.*(?:youtube|youtu\.be|soundcloud|bandcamp))"
+)
+
 
 class PlayCommands(commands.Cog):
     """Discord slash commands for music playback."""
@@ -89,9 +95,12 @@ class PlayCommands(commands.Cog):
         self, ctx: discord.AutocompleteContext
     ) -> List[OptionChoice]:
         """Autocomplete handler for search queries."""
+        if ctx.value.lower().startswith(("http://", "https://")):
+            return []
+
         query = ctx.value.lower()
         try:
-            results = await search_utils.UniversalSearcher.search_copyparty_autocomplete_audio(
+            results = await UniversalSearcher.search_copyparty_autocomplete_audio(
                 query, max_results=25
             )
             choices = []
@@ -164,6 +173,96 @@ class PlayCommands(commands.Cog):
                 except Exception:
                     pass
 
+    async def _handle_external_url_play(
+        self, ctx: discord.ApplicationContext, url: str
+    ) -> None:
+        """Download from external URL, upload to copyparty, then play."""
+        local_path = None
+        try:
+            ytdl_opts = {
+                "outtmpl": os.path.join(self.temp_dir, "%(title)s.%(ext)s"),
+                "postprocessors": [
+                    {
+                        "key": "FFmpegExtractAudio",
+                        "preferredcodec": "mp3",
+                        "preferredquality": "192",
+                    }
+                ],
+                "force_ipv4": True,
+            }
+
+            loop = asyncio.get_event_loop()
+            with YoutubeDL(ytdl_opts) as ydl:
+                info_dict = await loop.run_in_executor(
+                    None, lambda: ydl.extract_info(url, download=True)
+                )
+                title = info_dict.get("title", "nieznany")
+                base_filename = os.path.splitext(ydl.prepare_filename(info_dict))[0]
+                local_path = f"{base_filename}.mp3"
+
+            if not os.path.exists(local_path):
+                await ctx.respond("Nie udało się pobrać pliku.", ephemeral=True)
+                return
+
+            upload_task = asyncio.create_task(self._upload_to_copyparty_async(local_path))
+
+            await audio_playback.AudioPlaybackManager.play(
+                ctx, local_path, delete_after_play=True
+            )
+
+            try:
+                await asyncio.wait_for(upload_task, timeout=30.0)
+            except asyncio.TimeoutError:
+                logger.warning("Upload timed out")
+        except Exception as e:
+            logger.error(f"Error downloading external URL: {str(e)}", exc_info=True)
+            if local_path and os.path.exists(local_path):
+                try:
+                    os.remove(local_path)
+                except Exception:
+                    pass
+            await ctx.respond(f"Błąd pobierania: {str(e)}", ephemeral=True)
+
+    async def _upload_to_copyparty_async(self, file_path: str) -> None:
+        """Upload file to copyparty asynchronously (fire and forget)."""
+        import aiohttp
+
+        try:
+            logger.info(f"Starting async upload: {file_path}")
+            baseurl = os.getenv("COPYPARTY_URL_UPLOAD")
+            password = os.getenv("COPYPARTY_PASSWORD", "")
+
+            logger.info(f"Upload - baseurl: {baseurl}, password set: {bool(password)}")
+
+            if not baseurl:
+                logger.error("COPYPARTY_URL_UPLOAD not set!")
+                return
+
+            with open(file_path, "rb") as f:
+                content = f.read()
+
+            files = aiohttp.FormData()
+            files.add_field(
+                "f",
+                content,
+                filename=os.path.basename(file_path),
+                content_type="application/octet-stream",
+            )
+            headers = {"Cookie": f"cppwd={password}"}
+            params = {"j": "1", "ck": "b2"}
+
+            logger.info(f"Posting to {baseurl}")
+            async with aiohttp.ClientSession() as session:
+                async with session.post(baseurl, data=files, headers=headers, params=params) as response:
+                    text = await response.text()
+                    logger.info(f"Upload response: {response.status} - {text[:200] if text else 'empty'}")
+
+                    if response.status in [200, 201]:
+                        result = await response.json()
+                        logger.info(f"Uploaded to copyparty: {result.get('fileurl')}")
+        except Exception as e:
+            logger.error(f"Async upload failed: {e}", exc_info=True)
+
     async def _handle_local_file_play(
         self, ctx: discord.ApplicationContext, file: str, compressed: bool
     ) -> None:
@@ -211,7 +310,10 @@ class PlayCommands(commands.Cog):
             await audio_playback.AudioPlaybackManager.play(ctx, file_path)
         else:
             try:
-                await self._handle_local_file_play(ctx, melodia, compressed)
+                if EXTERNAL_URL_PATTERN.match(melodia.lower()):
+                    await self._handle_external_url_play(ctx, melodia)
+                else:
+                    await self._handle_local_file_play(ctx, melodia, compressed)
             except Exception as e:
                 logger.error(f"Error playing: {str(e)}", exc_info=True)
                 await ctx.respond(