1 files changed, 363 insertions, 141 deletions

diff --git a/cogs/voice.py b/cogs/voice.py
index 046c2a8..a224336 100644
--- a/cogs/voice.py
+++ b/cogs/voice.py
@@ -4,12 +4,15 @@
 # https://codeberg.org/salmonik/senator-sperma
 
 import discord
-from discord.ext import commands
 import logging
 import asyncio
+import os
+import urllib.parse
 from dataclasses import dataclass, field
 from typing import Any
 
+import mutagen
+
 logger = logging.getLogger(__name__)
 
 
@@ -24,60 +27,171 @@ def get_voice_manager(bot) -> "VoiceManager":
     return _voice_managers[bot_id]
 
 
+def is_voice_client_alive(voice_client, guild):
+    """Check if a voice client connection is healthy."""
+    if voice_client is None:
+        return False
+    if not voice_client.is_connected():
+        return False
+    if voice_client.channel is None:
+        return False
+    if guild.get_channel(voice_client.channel.id) is None:
+        return False
+
+    try:
+        ws = voice_client._connection
+        s = ws.socket
+        if s is None or s.fileno() == -1:
+            return False
+    except Exception:
+        return False
+
+    return True
+
+
 @dataclass
 class VoiceManager:
-    bot: Any  # type: ignore[no-any-import]
-    _voice_lock: asyncio.Lock = field(default_factory=asyncio.Lock, init=False)
+    bot: Any
+    _lock: asyncio.Lock = field(default_factory=asyncio.Lock, init=False)
+    _connecting: set[int] = field(default_factory=set, init=False)
 
-    async def join_channel(self, channel):
-        """Join a voice channel by channel object."""
-        async with self._voice_lock:
-            guild = channel.guild
-            voice_client = discord.utils.get(self.bot.voice_clients, guild=guild)
-
-            if voice_client and voice_client.is_connected():
-                if voice_client.channel == channel:
-                    logger.info(f"Already connected to {channel}")
-                    return voice_client
-                try:
-                    await voice_client.move_to(channel)
-                    logger.info(f"Moved to voice channel: {channel}")
-                    return voice_client
-                except Exception as e:
-                    logger.error(f"Failed to move voice client: {e}")
-                    logger.info("Disconnecting after failed move attempt")
+    # --- Connection -----------------------------------------------------------
+
+    async def _ensure_voice_client(self, channel):
+        """Unified connect/move/reconnect logic.
+
+        Returns a healthy VoiceClient connected to *channel*, or None on failure.
+        """
+        guild = channel.guild
+        guild_id = guild.id
+
+        async with self._lock:
+            if guild_id in self._connecting:
+                logger.info(f"Connection already in progress for guild {guild_id}, skipping")
+                return None
+
+            vc = discord.utils.get(self.bot.voice_clients, guild=guild)
+
+            # --- resolve existing client --------------------------------------
+            if vc is not None:
+                if vc.is_connected():
+                    if vc.channel == channel:
+                        if is_voice_client_alive(vc, guild):
+                            logger.info(f"Already connected to {channel}")
+                            return vc
+                        logger.warning(f"Stale connection to {channel}, reconnecting")
+                        # Disconnect resets the state machine to 'disconnected'
+                        # but keeps the VoiceClient alive.  Reusing it avoids a
+                        # race where Discord sends VOICE_SERVER_UPDATE between
+                        # the destroy and the fresh-connect below, causing the
+                        # new client to timeout waiting for the event (since the
+                        # old one already consumed it).
+                        try:
+                            await vc.disconnect()
+                        except Exception:
+                            pass
+                        try:
+                            await vc.connect(
+                                reconnect=False, timeout=10.0, self_deaf=False, self_mute=False
+                            )
+                            logger.info(f"Reconnected to voice channel: {channel}")
+                            return vc
+                        except Exception as e:
+                            logger.error(f"Failed to reconnect stale voice client: {e}")
+                            try:
+                                channel._state._remove_voice_client(guild.id)
+                            except Exception:
+                                pass
+                            vc = None
+                    else:
+                        try:
+                            await vc.move_to(channel)
+                            logger.info(f"Moved to voice channel: {channel}")
+                            return vc
+                        except Exception as e:
+                            logger.error(f"Failed to move voice client: {e}")
+                            try:
+                                await vc.disconnect()
+                            except Exception:
+                                pass
+                            try:
+                                await vc.connect(
+                                    reconnect=False, timeout=10.0, self_deaf=False, self_mute=False
+                                )
+                                logger.info(f"Reconnected after failed move: {channel}")
+                                return vc
+                            except Exception:
+                                pass
+                            try:
+                                channel._state._remove_voice_client(guild.id)
+                            except Exception:
+                                pass
+                            vc = None
+                else:
+                    logger.info("Voice client exists but disconnected, reconnecting")
                     try:
-                        await voice_client.disconnect()
+                        await vc.disconnect()
                     except Exception:
                         pass
-
-            await asyncio.sleep(0.3)
-            try:
-                voice_client = await channel.connect(timeout=30.0, reconnect=False)
-                logger.info(f"Connected to voice channel: {channel}")
-                return voice_client
-            except discord.ClientException as e:
-                if "Already connected" in str(e):
-                    logger.warning(f"Stale voice state detected, forcing disconnect and reconnect: {e}")
-                    voice_client = discord.utils.get(self.bot.voice_clients, guild=guild)
-                    if voice_client:
+                    try:
+                        await vc.connect(
+                            reconnect=False, timeout=10.0, self_deaf=False, self_mute=False
+                        )
+                        logger.info(f"Reconnected disconnected client: {channel}")
+                        return vc
+                    except Exception as e:
+                        logger.error(f"Failed to reconnect disconnected client: {e}")
                         try:
-                            await voice_client.disconnect()
+                            channel._state._remove_voice_client(guild.id)
                         except Exception:
                             pass
-                    await asyncio.sleep(0.3)
-                    try:
-                        voice_client = await channel.connect(timeout=30.0, reconnect=False)
-                        logger.info(f"Reconnected to voice channel: {channel}")
-                        return voice_client
-                    except Exception as e2:
-                        logger.error(f"Failed to reconnect after stale cleanup: {e2}")
-                        return None
-                logger.error(f"Failed to connect to voice channel: {e}")
-                return None
-            except Exception as e:
-                logger.error(f"Failed to connect to voice channel: {e}")
-                return None
+                        vc = None
+
+            # --- create fresh connection --------------------------------------
+            self._connecting.add(guild_id)
+            try:
+                await asyncio.sleep(0.3)
+                try:
+                    vc = await channel.connect(timeout=10.0, reconnect=False)
+                    logger.info(f"Connected to voice channel: {channel}")
+                    return vc
+                except discord.ClientException as e:
+                    if "Already connected" in str(e):
+                        logger.warning(f"Stale voice state detected, forcing reconnect: {e}")
+                        vc = discord.utils.get(self.bot.voice_clients, guild=guild)
+                        if vc:
+                            try:
+                                await vc.disconnect()
+                            except Exception:
+                                pass
+                        else:
+                            try:
+                                channel._state._remove_voice_client(guild.id)
+                            except Exception:
+                                pass
+                        await asyncio.sleep(0.3)
+                        try:
+                            vc = await channel.connect(timeout=10.0, reconnect=False)
+                            logger.info(f"Reconnected to voice channel: {channel}")
+                            return vc
+                        except Exception as e2:
+                            logger.error(f"Failed to reconnect after stale cleanup: {e2}")
+                            return None
+                    logger.error(f"Failed to connect to voice channel: {e}")
+                    return None
+                except Exception as e:
+                    logger.error(f"Failed to connect to voice channel: {e}")
+                    return None
+            finally:
+                self._connecting.discard(guild_id)
+
+    async def connect(self, channel):
+        """Join a voice channel (public alias)."""
+        return await self._ensure_voice_client(channel)
+
+    async def join_channel(self, channel):
+        """Backward-compatible alias for connect()."""
+        return await self.connect(channel)
 
     async def join_by_channel_id(self, channel_id):
         """Join a voice channel by channel ID."""
@@ -88,135 +202,243 @@ class VoiceManager:
         if not isinstance(channel, discord.VoiceChannel):
             logger.error(f"Channel {channel_id} is not a voice channel")
             return None
-        return await self.join_channel(channel)
+        return await self.connect(channel)
 
-    async def get_voice_client(self, guild):
+    async def get_client(self, guild):
         """Get existing voice client for a guild."""
         return discord.utils.get(self.bot.voice_clients, guild=guild)
 
-    async def get_voice_status(self, guild):
-        """Get voice client status including connection and playback state.
+    async def get_voice_client(self, guild):
+        """Backward-compatible alias for get_client()."""
+        return await self.get_client(guild)
+
+    async def get_status(self, guild):
+        """Get voice client status.
 
         Returns:
-            tuple: (voice_client, is_connected, is_playing) or (None, False, False) if no client
+            tuple: (voice_client, is_connected, is_playing) or (None, False, False)
         """
-        voice_client = await self.get_voice_client(guild)
-        if voice_client is None:
+        vc = await self.get_client(guild)
+        if vc is None:
             return None, False, False
+        return vc, vc.is_connected(), vc.is_playing()
 
-        is_connected = voice_client.is_connected()
-        is_playing = voice_client.is_playing() if is_connected else False
+    async def get_voice_status(self, guild):
+        """Backward-compatible alias for get_status()."""
+        return await self.get_status(guild)
+
+    async def disconnect(self, guild):
+        """Stop playback and disconnect from voice."""
+        vc = await self.get_client(guild)
+        if vc:
+            vc.stop()
+            logger.info("Disconnecting from voice")
+            await vc.disconnect()
+            logger.info(f"Disconnected from guild {guild}")
 
-        return voice_client, is_connected, is_playing
+    async def stop(self, guild):
+        """Backward-compatible alias for disconnect()."""
+        await self.disconnect(guild)
 
-    async def play_audio(self, channel, audio_source, volume=1.0):
-        """Play audio in a voice channel."""
-        voice_client = await self.join_channel(channel)
-        if not voice_client:
-            return False
+    # --- Playback ------------------------------------------------------------
 
-        if abs(volume - 1.0) > 1e-9:
-            audio_source = discord.PCMVolumeTransformer(audio_source)
-            audio_source.volume = volume
+    async def _play_await(self, vc, audio_source):
+        """Play an audio source and wait for completion using an asyncio.Future.
+
+        Returns True on success, False on error.  No polling, no magic sleeps.
+        """
+        loop = asyncio.get_event_loop()
+        future = loop.create_future()
+
+        def after(error):
+            if not future.done():
+                if error:
+                    future.set_exception(Exception(str(error)))
+                else:
+                    future.set_result(True)
+
+        vc.play(audio_source, after=after)
 
         try:
-            voice_client.play(audio_source)
-            while voice_client.is_playing():
-                await asyncio.sleep(0.1)
+            await future
             return True
         except Exception as e:
-            logger.error(f"Error playing audio: {e}")
+            logger.error(f"Playback error: {e}")
             return False
 
-    async def stop(self, guild):
-        """Stop playing and disconnect from voice."""
-        voice_client = await self.get_voice_client(guild)
-        if voice_client:
-            voice_client.stop()
-            logger.info("stop() called - disconnecting from voice")
-            await voice_client.disconnect()
-            logger.info(f"Stopped and disconnected from guild {guild}")
+    async def play_source(self, channel, audio_source, interrupt=True, volume=1.0):
+        """Connect to *channel* and play a pre-made audio source.
 
+        Returns True on success, False on failure.
+        """
+        vc = await self.connect(channel)
+        if not vc:
+            logger.error("play_source: could not connect to voice channel")
+            return False
 
-class Voice(commands.Cog):
-    def __init__(self, bot):
-        self.bot = bot
-        self._voice_lock = asyncio.Lock()
+        if interrupt and (vc.is_playing() or vc.is_paused()):
+            vc.stop()
 
-    async def _validate_user_voice_state(self, ctx):
-        if not ctx.author.voice or not ctx.author.voice.channel:
-            await ctx.send("You need to be in a voice channel first!")
-            return False
-        return True
+        if abs(volume - 1.0) > 1e-9:
+            audio_source = discord.PCMVolumeTransformer(audio_source)
+            audio_source.volume = volume
 
-    async def _create_voice_client(self, ctx):
-        async with self._voice_lock:
-            try:
-                await asyncio.sleep(0.5)
-                voice_client = await ctx.author.voice.channel.connect(timeout=30.0, reconnect=False)
-                logger.info(f"Connected to voice channel: {ctx.author.voice.channel}")
-                return voice_client
-            except asyncio.TimeoutError:
-                await ctx.send("Connection to voice channel timed out.")
-                return None
-            except discord.ClientException as e:
-                logger.error(f"Failed to connect to voice channel: {e}")
-                await ctx.send("Failed to connect to voice channel. Please try again.", ephemeral=True)
-                return None
+        logger.info("Playing via play_source")
+        return await self._play_await(vc, audio_source)
 
-    async def _move_voice_client(self, voice_client, ctx):
-        try:
-            await voice_client.move_to(ctx.author.voice.channel)
-            logger.info(f"Moved to voice channel: {ctx.author.voice.channel}")
-            return voice_client
-        except asyncio.TimeoutError:
-            await ctx.send("Connection to voice channel timed out.")
-            return None
-        except discord.ClientException as e:
-            logger.error(f"Failed to move to voice channel: {e}")
-            await ctx.send("Failed to move to your voice channel. Please try again.", ephemeral=True)
+    # --- Source preparation (folded from AudioPlaybackManager) ---------------
+
+    @staticmethod
+    async def validate_voice_channel(ctx):
+        """Validate user is in a voice channel. Returns the channel or None."""
+        if not ctx.author.voice or not ctx.author.voice.channel:
+            await ctx.respond(
+                "Musisz być na kanale głosowym, żebym mógł dołączyć!", ephemeral=True
+            )
             return None
+        return ctx.author.voice.channel
 
-    async def _verify_connection(self, voice_client):
-        if not voice_client.is_connected():
+    @staticmethod
+    async def prepare_file_source(source):
+        """Validate a local file and return (display_name, absolute_path) or (None, None)."""
+        logger.info(f"Attempting to play local file: {source}")
+
+        if not os.path.isabs(source):
+            source = os.path.abspath(source)
+            logger.debug(f"Converted to absolute path: {source}")
+
+        if not os.path.exists(source):
+            logger.error(f"File not found: {source}")
+            return None, None
+
+        filename = os.path.basename(source)
+        display_name = os.path.splitext(filename)[0]
+        return display_name, source
+
+    @staticmethod
+    async def prepare_audio_source(source, is_url, display_name):
+        """Prepare FFmpegPCMAudio from a URL or local file.
+
+        Returns (audio_source, final_display_name).
+        """
+        if is_url:
+            before_options = "-reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5"
+            audio_source = discord.FFmpegPCMAudio(source, before_options=before_options)
+            filename = os.path.basename(source.split("?")[0])
+            filename = urllib.parse.unquote(filename)
+            clean_filename = os.path.splitext(filename)[0]
+            return audio_source, clean_filename
+        else:
+            audio_source = discord.FFmpegPCMAudio(source=source)
             try:
-                await voice_client.connect(reconnect=False, timeout=10.0)
-                return voice_client
+                metadata = mutagen.open(source)
+                if metadata:
+                    title = (
+                        metadata.get("title", [None])[0]
+                        if hasattr(metadata, "get")
+                        else None
+                    )
+                    if title:
+                        display_name = title
+                        logger.debug(f"Read metadata - title: {title}")
+                else:
+                    display_name = os.path.splitext(os.path.basename(source))[0]
             except Exception as e:
-                logger.error(f"Failed to reconnect to voice: {e}")
-                return None
-        return voice_client
+                logger.warning(f"Could not read metadata from {source}: {str(e)}")
+                display_name = os.path.splitext(os.path.basename(source))[0]
 
-    async def ensure_voice_client(self, ctx):
-        if not await self._validate_user_voice_state(ctx):
-            return None
+            return audio_source, display_name
+
+    @staticmethod
+    async def prepare_source(source):
+        """Determine whether *source* is a URL or local file.
+
+        Returns (source_path, display_name, is_url) or (None, None, None) on failure.
+        """
+        is_url = source.startswith(("http://", "https://"))
+
+        if is_url:
+            logger.info(f"Attempting to play stream from URL: {source}")
+            return source, source, is_url
 
-        voice_client = discord.utils.get(self.bot.voice_clients, guild=ctx.guild)
+        display_name, absolute_source = await VoiceManager.prepare_file_source(source)
+        if not display_name:
+            return None, None, None
 
-        if voice_client and not voice_client.is_connected():
+        return absolute_source, display_name, is_url
+
+    @staticmethod
+    async def cleanup_temp_file(source):
+        """Remove a temporary file if it exists."""
+        if source and os.path.exists(source):
             try:
-                logger.info("Voice client exists but not connected - disconnecting stale client")
-                await voice_client.disconnect()
-            except Exception:
-                pass
-            voice_client = None
+                os.remove(source)
+                logger.info(f"Cleaned up temporary file: {source}")
+            except Exception as e:
+                logger.error(f"Error cleaning up file {source}: {str(e)}")
 
-        if not voice_client or not voice_client.is_connected():
-            if not await self._validate_user_voice_state(ctx):
-                return None
-            return await self._create_voice_client(ctx)
+    @staticmethod
+    async def cleanup_if_needed(source, delete_after_play, is_url):
+        """Conditionally clean up a file after playback."""
+        if delete_after_play and not is_url:
+            await VoiceManager.cleanup_temp_file(source)
 
-        if voice_client.channel != ctx.author.voice.channel:
-            return await self._move_voice_client(voice_client, ctx)
+    # --- High-level play (full flow) -----------------------------------------
 
-        return await self._verify_connection(voice_client)
+    async def play(self, ctx, source, delete_after_play=False, interrupt=True):
+        """High-level playback: validate context, prepare source, connect, play, cleanup.
 
-    async def connect(self, ctx):
-        voice_client = await self.ensure_voice_client(ctx)
-        if not voice_client:
-            return None
-        return voice_client
+        Sends ``grom: {name}`` immediately on start, and an error follow-up
+        if playback fails.
+
+        Args:
+            ctx: Discord application context (used for channel resolution & error messages).
+            source: Local file path or URL to stream.
+            delete_after_play: Remove local file after playback (no-op for URLs).
+            interrupt: Stop currently playing audio before starting.
+
+        Returns:
+            bool: True if playback completed successfully, False otherwise.
+        """
+        prepared_source, display_name, is_url = await VoiceManager.prepare_source(source)
+        if not prepared_source:
+            await VoiceManager.cleanup_if_needed(source, delete_after_play, False)
+            return False
+
+        target_channel = await VoiceManager.validate_voice_channel(ctx)
+        if not target_channel:
+            await VoiceManager.cleanup_if_needed(prepared_source, delete_after_play, is_url)
+            return False
+
+        vc = await self.connect(target_channel)
+        if not vc:
+            await VoiceManager.cleanup_if_needed(prepared_source, delete_after_play, is_url)
+            return False
+
+        if interrupt and (vc.is_playing() or vc.is_paused()):
+            vc.stop()
+
+        audio_source, final_display_name = await VoiceManager.prepare_audio_source(
+            prepared_source, is_url, display_name
+        )
+
+        try:
+            await ctx.followup.send(f"grom: {final_display_name}")
+        except Exception as e:
+            logger.error(e)
+
+        success = await self._play_await(vc, audio_source)
 
+        if success:
+            logger.info(f"Playback completed: {final_display_name}")
+        else:
+            logger.error(f"Playback failed: {prepared_source}")
+            try:
+                await ctx.followup.send(
+                    "eror: Timeout - nie udało się połączyć ze streamem", ephemeral=True
+                )
+            except Exception:
+                pass
+            await VoiceManager.cleanup_if_needed(prepared_source, delete_after_play, is_url)
 
-def setup(bot):
-    bot.add_cog(Voice(bot))
+        return success