Trixy7/plugins/music/main.py

# -*- coding: utf-8 -*-
"""
Music-Plugin fuer Trixy.

Ermoeglicht Musikwiedergabe ueber YouTube, Spotify, Radio und lokale Dateien.
Registriert Intent-Handler fuer Sprachsteuerung.
"""

import random
from pathlib import Path
from typing import Any

from trixy_core.plugins import TrixyPlugin
from trixy_core.nlp.intent_registry import IntentRegistry, IntentDefinition, IntentSlot
from trixy_core.nlp.decorators import intent, pattern, example
from trixy_core.nlp.handler import IntentReceivedData, IntentResult
from trixy_core.music.track import Track, TrackState
from trixy_core.music.playlist import Playlist, ShuffleMode
from trixy_core.music.sources.local import LocalFileSource
from trixy_core.utils.debug import pinfo, pdebug, perror, pwarn

from plugins.music.sources.youtube import YouTubeSource
from plugins.music.sources.spotify import SpotifySource
from plugins.music.sources.soundcloud import SoundCloudSource
from plugins.music.sources.deezer import DeezerSource
from plugins.music.sources.radio import RadioSource


class MusicPlugin(TrixyPlugin):
    """
    Music-Plugin.

    Bietet:
    - YouTube-Suche und -Download (optional, via yt-dlp)
    - Spotify-Suche und -Download (optional, via spotipy + spotdl)
    - SoundCloud-Suche und -Download (optional, via yt-dlp)
    - Deezer-Suche und -Download (optional, via aiohttp + yt-dlp)
    - Radio-Streams (Icecast/Shoutcast, via aiohttp)
    - Lokale Musikdateien
    - Intent-Handler fuer Sprachsteuerung
    """

    NAME = "music"
    VERSION = "3.0.0"
    DESCRIPTION = "Musikwiedergabe ueber YouTube, Spotify, SoundCloud, Deezer, Radio und lokale Dateien"
    AUTHOR = "Trixy"

    def __init__(self, application, plugin_path, config=None):
        super().__init__(application, plugin_path, config)
        self._youtube: YouTubeSource | None = None
        self._spotify: SpotifySource | None = None
        self._soundcloud: SoundCloudSource | None = None
        self._deezer: DeezerSource | None = None
        self._radio: RadioSource | None = None
        self._local: LocalFileSource | None = None
        self._registry = IntentRegistry.get_instance()

    @property
    def _music_service(self):
        """Zugriff auf den MusicPlayerService."""
        return self.application.services.get_service("music_player")

    async def on_load(self) -> None:
        """Initialisiert Quellen und registriert Intents."""
        pinfo(f"MusicPlugin: Lade Plugin v{self.VERSION}")

        yt_available = False
        spotify_available = False
        sc_available = False
        dz_available = False
        radio_available = False
        local_available = False

        # YouTube-Source initialisieren (optional)
        yt_config = self.get_config_value("youtube", {})
        if yt_config.get("enabled", True):
            self._youtube = YouTubeSource(
                cache_dir=yt_config.get("cache_dir", "cache/youtube"),
                max_cache_size_mb=yt_config.get("max_cache_size_mb", 500),
                preferred_format=yt_config.get(
                    "preferred_format", "bestaudio[ext=m4a]/bestaudio/best"
                ),
                max_results=yt_config.get("max_results", 5),
                search_mode=yt_config.get("search_mode", "music_fallback"),
            )
            yt_available = await self._youtube.connect()
            if not yt_available:
                pwarn("MusicPlugin: YouTube nicht verfuegbar (yt-dlp nicht installiert?)")
                self._youtube = None

        # Spotify-Source initialisieren (optional)
        sp_config = self.get_config_value("spotify", {})
        if sp_config.get("enabled", False):
            self._spotify = SpotifySource(
                client_id=sp_config.get("client_id", ""),
                client_secret=sp_config.get("client_secret", ""),
                cache_dir=sp_config.get("cache_dir", "cache/spotify"),
                max_cache_size_mb=sp_config.get("max_cache_size_mb", 500),
                max_results=sp_config.get("max_results", 5),
                market=sp_config.get("market", "DE"),
            )
            spotify_available = await self._spotify.connect()
            if not spotify_available:
                pwarn("MusicPlugin: Spotify nicht verfuegbar")
                self._spotify = None

        # SoundCloud-Source initialisieren (optional)
        sc_config = self.get_config_value("soundcloud", {})
        if sc_config.get("enabled", False):
            self._soundcloud = SoundCloudSource(
                cache_dir=sc_config.get("cache_dir", "cache/soundcloud"),
                max_cache_size_mb=sc_config.get("max_cache_size_mb", 500),
                max_results=sc_config.get("max_results", 5),
            )
            sc_available = await self._soundcloud.connect()
            if not sc_available:
                pwarn("MusicPlugin: SoundCloud nicht verfuegbar")
                self._soundcloud = None

        # Deezer-Source initialisieren (optional)
        dz_config = self.get_config_value("deezer", {})
        if dz_config.get("enabled", False):
            self._deezer = DeezerSource(
                cache_dir=dz_config.get("cache_dir", "cache/deezer"),
                max_cache_size_mb=dz_config.get("max_cache_size_mb", 500),
                max_results=dz_config.get("max_results", 5),
                download_mode=dz_config.get("download_mode", "full"),
            )
            dz_available = await self._deezer.connect()
            if not dz_available:
                pwarn("MusicPlugin: Deezer nicht verfuegbar")
                self._deezer = None

        # Radio-Source initialisieren (optional)
        radio_config = self.get_config_value("radio", {})
        if radio_config.get("enabled", True):
            self._radio = RadioSource(
                favorites=radio_config.get("favorites", []),
                include_defaults=radio_config.get("include_defaults", True),
                icy_metadata=radio_config.get("icy_metadata", True),
            )
            radio_available = await self._radio.connect()
            if not radio_available:
                pwarn("MusicPlugin: Radio nicht verfuegbar")
                self._radio = None

        # Lokale Source initialisieren
        local_config = self.get_config_value("local", {})
        if local_config.get("enabled", True):
            music_dirs = self._get_music_dirs(local_config)
            if music_dirs:
                self._local = LocalFileSource(
                    name="Lokale Musik",
                    paths=music_dirs,
                    recursive=True,
                )
                local_available = await self._local.connect()
                if local_available and local_config.get("scan_on_load", True):
                    count = await self._local.scan()
                    pdebug(f"MusicPlugin: {count} lokale Tracks gefunden")

        # Status-Uebersicht
        sources = []
        if yt_available: sources.append("YouTube")
        if spotify_available: sources.append("Spotify")
        if sc_available: sources.append("SoundCloud")
        if dz_available: sources.append("Deezer")
        if radio_available: sources.append(f"Radio({self._radio.station_count})")
        if local_available: sources.append("Lokal")
        pinfo(f"MusicPlugin: Geladen — Quellen: {', '.join(sources) or 'keine'}")

    async def on_unload(self) -> None:
        """Entlaedt das Plugin und deregistriert Intents."""
        # Intents deregistrieren
        self._registry.unregister_plugin(self.NAME)

        # Quellen trennen
        for source in (self._youtube, self._spotify, self._soundcloud, self._deezer, self._radio, self._local):
            if source:
                await source.disconnect()

        self._youtube = None
        self._spotify = None
        self._soundcloud = None
        self._deezer = None
        self._radio = None
        self._local = None

        pdebug("MusicPlugin: Entladen")

    async def on_enable(self) -> None:
        """Aktiviert das Plugin."""
        pinfo("MusicPlugin: Aktiviert")

    async def on_disable(self) -> None:
        """Deaktiviert das Plugin."""
        pinfo("MusicPlugin: Deaktiviert")

    # ==========================================================================
    # Intent-Handler
    # ==========================================================================

    @intent("play_music", description="Musik abspielen (mit optionalem Suchbegriff)")
    @pattern("(spiele|spiel|abspielen) {query}")
    @pattern("(spiele|spiel) [etwas] musik")
    @pattern("(spiele|spiel) [etwas] musik von {query}")
    @pattern("musik von {query}")
    @pattern("musik abspielen")
    @example("Spiele Bohemian Rhapsody", "Spiel Musik")
    @example("Spiele etwas von Mozart", "Musik abspielen")
    async def handle_play_music(self, data: IntentReceivedData, query: str = "", source: str = "auto") -> IntentResult:
        """Verarbeitet den play_music Intent."""
        service = self._music_service
        if not service:
            return IntentResult.failure(
                "MusicPlayerService nicht verfuegbar",
                response_text="Der Musik-Dienst ist gerade nicht verfuegbar.",
            )

        query = data.get_slot("query", "")
        source = data.get_slot("source", "auto")
        satellite_id = data.satellite_id

        # Falls kein query-Slot, aus artist/title/album/genre zusammenbauen
        if not query:
            parts = []
            for slot_name in ("artist", "title", "song", "album", "genre"):
                val = data.get_slot(slot_name, "")
                if val:
                    parts.append(val)
            if parts:
                query = " ".join(parts)

        # Kein Query + Musik pausiert → Resume
        if not query and service.is_paused:
            await self.application.events.emit("music_resumed", {
                "satellite_id": satellite_id,
            })
            return IntentResult.success_with_response("Wird fortgesetzt.")

        # Kein Query → Shuffle lokale Bibliothek
        if not query:
            return await self._play_local_shuffle(satellite_id)

        # Query vorhanden → Suchen und abspielen
        return await self._search_and_play(query, source, satellite_id)

    @intent("next_track", description="Zum naechsten Track springen")
    @pattern("(naechster|naechstes) (song|lied|track)")
    @pattern("(skip|weiter)")
    @example("Naechster Song", "Skip", "Weiter", "Naechstes Lied")
    async def handle_next_track(self, data: IntentReceivedData) -> IntentResult:
        """Springt zum naechsten Track."""
        service = self._music_service
        if not service or not service.player:
            return IntentResult.failure(
                "Kein aktiver Player",
                response_text="Es laeuft gerade keine Musik.",
            )

        await self.application.events.emit("music_next", {
            "satellite_id": data.satellite_id,
        })
        return IntentResult.success_with_response("Naechster Song.")

    @intent("previous_track", description="Zum vorherigen Track springen")
    @pattern("(vorheriger|vorheriges) (song|lied|track)")
    @pattern("zurueck")
    @example("Zurueck", "Vorheriger Song", "Vorheriges Lied")
    async def handle_previous_track(self, data: IntentReceivedData) -> IntentResult:
        """Springt zum vorherigen Track."""
        service = self._music_service
        if not service or not service.player:
            return IntentResult.failure(
                "Kein aktiver Player",
                response_text="Es laeuft gerade keine Musik.",
            )

        await self.application.events.emit("music_previous", {
            "satellite_id": data.satellite_id,
        })
        return IntentResult.success_with_response("Vorheriger Song.")

    @intent("play_radio", description="Radio-Sender abspielen")
    @pattern("(spiele|spiel) radio {query}")
    @pattern("(spiele|spiel) [den] [sender] {query}")
    @pattern("radio {query} [einschalten|abspielen|spielen]")
    @pattern("mach [mal] {query} an")
    @pattern("(schalte|schalt) {query} ein")
    @example("Spiele Radio SWR3", "Spiel den Sender 1LIVE")
    @example("Radio Klassik Radio einschalten", "Mach mal Fritz an")
    async def handle_play_radio(self, data: IntentReceivedData, query: str = "") -> IntentResult:
        """Verarbeitet den play_radio Intent."""
        if not self._radio:
            return IntentResult.failure(
                "Radio nicht verfuegbar",
                response_text="Radio ist gerade nicht verfuegbar.",
            )

        query = data.get_slot("query", "")
        if not query:
            return IntentResult.failure(
                "Kein Sender angegeben",
                response_text="Welchen Sender moechtest du hoeren?",
            )

        return await self._search_and_play(query, "radio", data.satellite_id)

    @intent("what_is_playing", description="Aktuellen Track abfragen")
    @pattern("was laeuft [gerade]")
    @pattern("wie heisst [der] (song|lied|track)")
    @pattern("welches lied ist [das]")
    @pattern("was hoere ich [gerade]")
    @example("Was laeuft?", "Wie heisst der Song?")
    @example("Welches Lied ist das?", "Was hoere ich gerade?")
    async def handle_what_is_playing(self, data: IntentReceivedData) -> IntentResult:
        """Gibt Informationen zum aktuellen Track zurueck."""
        service = self._music_service
        if not service:
            return IntentResult.failure(
                "MusicPlayerService nicht verfuegbar",
                response_text="Der Musik-Dienst ist gerade nicht verfuegbar.",
            )

        track = service.current_track
        if not track:
            return IntentResult.success_with_response(
                "Es laeuft gerade keine Musik."
            )

        # Track-Info zusammenbauen
        title = track.metadata.display_title
        artist = track.metadata.display_artist
        duration = track.metadata.duration_formatted

        if artist and artist != "Unbekannter Kuenstler":
            response = f"Es laeuft '{title}' von {artist}."
        else:
            response = f"Es laeuft '{title}'."

        if duration and duration != "0:00":
            response += f" Dauer: {duration}."

        return IntentResult.success_with_response(response)

    # ==========================================================================
    # Hilfsmethoden
    # ==========================================================================

    async def _play_local_shuffle(self, satellite_id: str) -> IntentResult:
        """Spielt lokale Musik im Shuffle-Modus."""
        if not self._local or not self._local.tracks:
            # Auch Assets-Musik pruefen
            service = self._music_service
            if service:
                success = await service._start_assets_playlist(satellite_id)
                if success:
                    return IntentResult.success_with_response(
                        "Musik wird abgespielt."
                    )

            return IntentResult.failure(
                "Keine lokale Musik gefunden",
                response_text="Ich habe keine Musik in der lokalen Bibliothek gefunden.",
            )

        # Playlist aus lokalen Tracks erstellen
        tracks = list(self._local.tracks)
        random.shuffle(tracks)

        playlist = Playlist(name="Lokale Musik (Shuffle)")
        playlist.shuffle_mode = ShuffleMode.ON
        for track in tracks:
            playlist.add(track)

        service = self._music_service
        if not service:
            return IntentResult.failure(
                "MusicPlayerService nicht verfuegbar",
                response_text="Der Musik-Dienst ist gerade nicht verfuegbar.",
            )

        satellite_ids = self._get_target_satellites(satellite_id)
        success = await service.play_playlist(playlist, satellite_ids)

        if success:
            return IntentResult.success_with_response("Musik wird abgespielt.")
        else:
            return IntentResult.failure(
                "Wiedergabe fehlgeschlagen",
                response_text="Die Wiedergabe konnte nicht gestartet werden.",
            )

    async def _search_and_play(
        self, query: str, source: str, satellite_id: str
    ) -> IntentResult:
        """Sucht nach Musik und startet die Wiedergabe."""
        tracks: list[Track] = []

        # Quelle bestimmen
        search_youtube = source in ("auto", "youtube") and self._youtube
        search_spotify = source in ("auto", "spotify") and self._spotify
        search_soundcloud = source in ("soundcloud",) and self._soundcloud
        search_deezer = source in ("auto", "deezer") and self._deezer
        search_local = source in ("auto", "lokal", "local") and self._local
        search_radio = source in ("radio",) and self._radio

        # Radio-Suche (wenn explizit "radio" als Quelle)
        if search_radio and self._radio:
            radio_results = await self._radio.search(query, limit=5)
            tracks.extend(radio_results)

        # SoundCloud-Suche (wenn explizit "soundcloud")
        if search_soundcloud and self._soundcloud:
            sc_results = await self._soundcloud.search(query, limit=5)
            tracks.extend(sc_results)

        # Lokal suchen
        if search_local and self._local:
            local_results = await self._local.search(query, limit=10)
            tracks.extend(local_results)

        # Deezer suchen (wenn lokal nichts/wenig oder explizit)
        if search_deezer and self._deezer and (len(tracks) < 3 or source == "deezer"):
            dz_results = await self._deezer.search(query, limit=5)
            tracks.extend(dz_results)

        # Spotify suchen (wenn immer noch nichts/wenig oder explizit)
        if search_spotify and self._spotify and (len(tracks) < 3 or source == "spotify"):
            sp_results = await self._spotify.search(query, limit=5)
            tracks.extend(sp_results)

        # YouTube suchen (wenn immer noch nichts/wenig oder explizit)
        if search_youtube and self._youtube and (len(tracks) < 3 or source == "youtube"):
            yt_results = await self._youtube.search(query, limit=5)
            tracks.extend(yt_results)

        if not tracks:
            return IntentResult.failure(
                f"Keine Ergebnisse fuer: {query}",
                response_text=f"Ich konnte keine Musik fuer '{query}' finden.",
            )

        # Ersten Track vorbereiten und abspielen
        first_track = tracks[0]
        prepared = await self._prepare_track(first_track)
        if not prepared:
            return IntentResult.failure(
                "Download fehlgeschlagen",
                response_text=f"Der Download von '{first_track.title}' ist fehlgeschlagen.",
            )

        service = self._music_service
        if not service:
            return IntentResult.failure(
                "MusicPlayerService nicht verfuegbar",
                response_text="Der Musik-Dienst ist gerade nicht verfuegbar.",
            )

        satellite_ids = self._get_target_satellites(satellite_id)
        success = await service.play_track(first_track, satellite_ids)

        if not success:
            return IntentResult.failure(
                "Wiedergabe fehlgeschlagen",
                response_text="Die Wiedergabe konnte nicht gestartet werden.",
            )

        # Weitere Tracks in die Queue (im Hintergrund vorbereiten)
        if len(tracks) > 1:
            import asyncio
            asyncio.create_task(
                self._queue_remaining_tracks(tracks[1:], satellite_ids)
            )

        # Antwort
        artist = first_track.metadata.display_artist
        title = first_track.metadata.display_title
        if len(tracks) > 1:
            if artist and artist != "Unbekannter Kuenstler":
                return IntentResult.success_with_response(
                    f"Spiele '{title}' von {artist}. "
                    f"{len(tracks) - 1} weitere Titel in der Warteschlange."
                )
            return IntentResult.success_with_response(
                f"Spiele '{title}'. "
                f"{len(tracks) - 1} weitere Titel in der Warteschlange."
            )
        else:
            if artist and artist != "Unbekannter Kuenstler":
                return IntentResult.success_with_response(
                    f"Spiele '{title}' von {artist}."
                )
            return IntentResult.success_with_response(f"Spiele '{title}'.")

    async def _prepare_track(self, track: Track) -> bool:
        """Bereitet einen Track fuer die Wiedergabe vor (Download/Cache)."""
        source_map = {
            "youtube": self._youtube,
            "spotify": self._spotify,
            "soundcloud": self._soundcloud,
            "deezer": self._deezer,
            "radio": self._radio,
        }
        source = source_map.get(track.source_type)
        if source:
            if track.source_type not in ("radio",):
                pinfo(f"MusicPlugin: Lade {track.source_type.title()}-Track: {track.title}")
            return await source.prepare_track(track)
        elif track.source_type == "local":
            return True
        return True

    async def _queue_remaining_tracks(
        self, tracks: list, satellite_ids: list[str],
    ) -> None:
        """Bereitet weitere Tracks vor und fuegt sie zur Queue hinzu."""
        service = self._music_service
        if not service:
            return

        for track in tracks:
            try:
                prepared = await self._prepare_track(track)
                if not prepared:
                    pdebug(f"MusicPlugin: Skip '{track.title}' (Download fehlgeschlagen)")
                    continue

                if hasattr(service, "_player") and service._player:
                    await service._player.add_to_queue(track)
                else:
                    pdebug(f"MusicPlugin: Kein Player fuer Queue")
                pdebug(f"MusicPlugin: Zur Queue: {track.title}")
            except Exception as e:
                pdebug(f"MusicPlugin: Queue-Fehler fuer '{track.title}': {e}")

    def _get_music_dirs(self, local_config: dict) -> list[Path]:
        """Ermittelt die Musik-Verzeichnisse."""
        dirs: list[Path] = []

        # Konfigurierte Verzeichnisse
        for dir_str in local_config.get("music_dirs", []):
            path = Path(dir_str)
            if path.exists() and path.is_dir():
                dirs.append(path)

        # Assets-Musik als Fallback
        if hasattr(self.application, "server_config"):
            assets_dir = Path(self.application.server_config.assets_directory)
            profile = self.application.server_config.profile

            for search_dir in [
                assets_dir / profile / "music",
                assets_dir / "default" / "music",
            ]:
                if search_dir.exists() and search_dir not in dirs:
                    dirs.append(search_dir)

        return dirs

    def _get_target_satellites(self, satellite_id: str) -> list[str]:
        """Ermittelt Ziel-Satellites fuer die Wiedergabe."""
        # Anfragenden Satellite bevorzugen
        if satellite_id:
            satellites = getattr(self.application, "satellites", None)
            if satellites:
                sat = satellites.get(satellite_id)
                if sat and sat.is_connected and sat.sockets.music_out:
                    return [satellite_id]

        # Fallback: Alle verbundenen Satellites mit Musik-Socket
        satellites = getattr(self.application, "satellites", None)
        if satellites:
            return [
                sat.id for sat in satellites.all()
                if sat.is_connected and sat.sockets.music_out
            ]

        return []