git-cli-yt 1.1.9 → 2.0.0

package/app.py

@@ -0,0 +1,1322 @@
+"""Aplicação principal — interface Textual do player de música V2."""
+
+from __future__ import annotations
+
+import threading
+import os
+import time
+from typing import Any, Optional
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.widgets import (
+    Button,
+    Footer,
+    Input,
+    Label,
+    ListItem,
+    ListView,
+    ProgressBar,
+)
+from rich.markup import escape
+
+from audio.audio_player import AudioPlayer
+from mix.mix_service import MixService
+from utils.helpers import format_time
+from youtube import auth, liked, playlist as youtube_playlist, search
+
+
+class YouTubePlayer(App):
+    CSS = """
+    Screen {
+        layout: vertical;
+        background: #0f0f0f;
+        color: #f1f1f1;
+    }
+
+    #sidebar {
+        width: 20;
+        background: #121212;
+        padding: 1 0;
+        height: 1fr;
+        border-right: solid #272727;
+    }
+
+    #sidebar Label {
+        text-style: bold;
+        margin-bottom: 1;
+        padding-left: 1;
+        color: #ffffff;
+    }
+
+    .nav-btn {
+        width: 100%;
+        margin-bottom: 1;
+        text-align: left;
+        background: transparent;
+        color: #aaaaaa;
+        border: none;
+    }
+
+    .nav-btn:hover {
+        background: #272727;
+        color: #ffffff;
+    }
+
+    .nav-btn:focus {
+        background: #212121;
+        color: #ff4e45;
+        text-style: bold;
+    }
+
+    #sidebar-account-info {
+        padding-left: 1;
+        color: #aaaaaa;
+    }
+
+    #user-playlists-sidebar {
+        width: 32;
+        height: 1fr;
+        background: #121212;
+        border-left: solid #272727;
+        padding: 1 0;
+    }
+
+    #user-playlists-title {
+        height: 2;
+        padding: 0 1;
+        text-style: bold;
+        color: #ffffff;
+    }
+
+    #user-playlists-list {
+        height: 1fr;
+        background: #121212;
+        scrollbar-size-vertical: 1;
+        scrollbar-color: #ff4e45 #181818;
+    }
+
+    #user-playlists-status {
+        height: 2;
+        padding: 0 1;
+        color: #aaaaaa;
+    }
+
+    #main {
+        height: 1fr;
+        background: #0f0f0f;
+    }
+
+    #content {
+        width: 1fr;
+        height: 1fr;
+        padding: 0;
+        margin: 0;
+        background: #0f0f0f;
+    }
+
+    #section-browser {
+        height: 1fr;
+        width: 100%;
+        padding: 0;
+        margin: 0;
+    }
+
+    #search-row {
+        height: 3;
+        width: 100%;
+        margin: 0;
+        padding: 0;
+        background: #0f0f0f;
+    }
+
+    #search-input {
+        width: 100%;
+        height: 3;
+        margin: 0;
+        padding: 0 1;
+        background: #121212;
+        color: #f1f1f1;
+        border: tall #272727;
+    }
+
+    #search-input:focus {
+        border: tall #ff0000;
+    }
+
+    #results-row {
+        height: 1fr;
+        width: 100%;
+        margin: 0;
+        padding: 0;
+    }
+
+    #results-pane {
+        width: 1fr;
+        height: 100%;
+        border: solid #272727;
+        padding: 0;
+        margin: 0;
+        background: #0f0f0f;
+    }
+
+    #playlist-pane {
+        width: 1fr;
+        height: 100%;
+        border: solid #272727;
+        padding: 0;
+        margin: 0 0 0 1;
+        background: #0f0f0f;
+    }
+
+    #results-title, #playlist-title {
+        height: 1;
+        width: 100%;
+        padding: 0 1;
+        text-style: bold;
+        background: #181818;
+        color: #ffffff;
+        border-bottom: solid #ff0000;
+    }
+
+    #results-list {
+        height: 1fr;
+        background: #0f0f0f;
+        scrollbar-size-vertical: 1;
+        scrollbar-color: #ff0000 #181818;
+    }
+
+    #playlist-list {
+        height: 1fr;
+        background: #0f0f0f;
+        scrollbar-size-vertical: 1;
+        scrollbar-color: #ff0000 #181818;
+    }
+
+    ListItem {
+        padding: 0 1;
+        background: #0f0f0f;
+        color: #f1f1f1;
+    }
+
+    ListItem:hover {
+        background: #272727;
+        color: #ffffff;
+    }
+
+    ListItem.-selected {
+        background: #212121;
+        color: #ffffff;
+        text-style: bold;
+    }
+
+    #btn-load-more {
+        width: 100%;
+        margin-top: 0;
+        margin-bottom: 0;
+        height: 3;
+        background: #181818;
+        color: #aaaaaa;
+        border: solid #272727;
+    }
+
+    #btn-load-more:hover {
+        background: #272727;
+        color: #ff4e45;
+        border: solid #ff0000;
+    }
+
+    #player-panel {
+        height: 7;
+        min-height: 7;
+        max-height: 7;
+        background: #181818;
+        border-top: heavy #ff0000;
+        padding: 0 1;
+    }
+
+    #player-info-row {
+        height: 1;
+        width: 100%;
+        align: center middle;
+    }
+
+    #player-info-row Button {
+        min-width: 3;
+        height: 1;
+        border: none;
+        padding: 0 1;
+        margin: 0;
+        background: transparent;
+        color: #aaaaaa;
+    }
+
+    #player-info-row Button:hover {
+        color: #ffffff;
+        background: #272727;
+    }
+
+    #now-playing {
+        text-style: bold;
+        width: 1fr;
+        text-align: left;
+        color: #f1f1f1;
+    }
+
+    #status {
+        width: 1fr;
+        color: #ff4e45;
+        text-align: center;
+    }
+
+    #vol-label {
+        width: 6;
+        text-align: center;
+        text-style: bold;
+        color: #aaaaaa;
+    }
+
+    #progress-row {
+        height: 1;
+        width: 100%;
+        align: center middle;
+        margin-top: 1;
+    }
+
+    #progress-row Label {
+        width: 7;
+        text-align: center;
+        color: #aaaaaa;
+    }
+
+    #progress-row ProgressBar {
+        width: 1fr;
+    }
+
+    Bar > .bar--bar {
+        color: #ff0000;
+        background: #272727;
+    }
+
+    Bar > .bar--complete {
+        color: #ff0000;
+        background: #272727;
+    }
+
+    #controls {
+        height: 3;
+        width: 100%;
+        align: center middle;
+        margin-top: 0;
+    }
+
+    #controls Button {
+        margin: 0 1;
+        min-width: 8;
+        background: #272727;
+        color: #f1f1f1;
+        border: none;
+    }
+
+    #controls Button:hover {
+        background: #3f3f3f;
+        color: #ffffff;
+    }
+
+    #btn-toggle {
+        background: #ff0000;
+        color: #ffffff;
+        text-style: bold;
+    }
+
+    #btn-toggle:hover {
+        background: #cc0000;
+        color: #ffffff;
+    }
+
+    #btn-stop {
+        background: #212121;
+        color: #888888;
+    }
+
+    #btn-stop:hover {
+        background: #272727;
+        color: #ff4e45;
+    }
+
+    #login-pane {
+        width: 100%;
+        height: 100%;
+        align: center middle;
+        padding: 2;
+        background: #0f0f0f;
+    }
+
+    #login-pane Button {
+        margin: 1;
+    }
+
+    #btn-do-login {
+        background: #ff0000;
+        color: #ffffff;
+        text-style: bold;
+    }
+
+    #config-pane {
+        width: 100%;
+        height: 100%;
+        align: center middle;
+        padding: 2;
+        background: #0f0f0f;
+    }
+
+    Footer {
+        background: #0f0f0f;
+        color: #aaaaaa;
+    }
+
+    Footer > .footer--key {
+        background: #272727;
+        color: #ff0000;
+        text-style: bold;
+    }
+    """
+
+    BINDINGS = [
+        Binding("space", "toggle_play", "Play/Pause", show=True),
+        Binding("up", "volume_up", "Volume +", show=True),
+        Binding("down", "volume_down", "Volume -", show=True),
+        Binding("q", "quit", "Sair", show=True),
+        Binding("n", "next_track", "Próxima", show=True),
+        Binding("p", "prev_track", "Anterior", show=True),
+        Binding("f", "seek_forward", "+10s", show=True),
+        Binding("b", "seek_back", "-10s", show=True),
+    ]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.player = AudioPlayer()
+        self.mix = MixService(self._fetch_for_mix)
+
+        self._liked_next_page: Optional[str] = None
+        self._search_next_page: Optional[str] = None
+        self._search_query = ""
+        self._current_section = "inicio"
+        self._last_results: list[dict[str, Any]] = []
+        self._active_source = "search"
+        self._search_generation = 0
+        self._liked_generation = 0
+        self._mix_generation = 0
+        self._mix_lock = threading.Lock()
+        self._last_selection_key: Optional[str] = None
+        self._last_selection_at = 0.0
+        self._user_playlists: list[dict[str, Any]] = []
+        self._playlists_loaded = False
+        self._playlist_generation = 0
+        self._playlist_next_page: Optional[str] = None
+        self._active_playlist_url = ""
+        self._active_playlist_title = ""
+
+        # Callbacks do player para sincronização
+        self.player.on_state_change = self._on_player_state
+        self.player.on_progress = self._on_player_progress
+        self.player.on_finished = self._on_track_finished
+
+    # ------------------------------------------------------------------ #
+    # Interface Visual
+    # ------------------------------------------------------------------ #
+
+    def compose(self) -> ComposeResult:
+
+        with Horizontal(id="main"):
+            # Barra lateral de navegação (exatamente as 5 seções pedidas)
+            with Vertical(id="sidebar"):
+                yield Label("[bold]Menu Principal[/bold]")
+                yield Button("🏠 Início", id="nav-inicio", classes="nav-btn", variant="primary")
+                yield Button("📂 Playlists", id="nav-playlists", classes="nav-btn")
+                yield Button("🔑 Login", id="nav-login", classes="nav-btn")
+                yield Button("⚙️ Configurações", id="nav-config", classes="nav-btn")
+                yield Button("🚪 Sair", id="nav-sair", classes="nav-btn", variant="error")
+                yield Label("", id="sidebar-account-info")
+
+            # Área de conteúdo central
+            with Vertical(id="content"):
+                # Seção INÍCIO / CURTIDAS (área com busca, resultados e playlist lado a lado)
+                with Vertical(id="section-browser"):
+                    with Horizontal(id="search-row"):
+                        yield Input(
+                            placeholder="🔍 Digite uma música ou artista e pressione Enter...",
+                            id="search-input",
+                        )
+
+                    with Horizontal(id="results-row"):
+                        with Vertical(id="results-pane"):
+                            yield Label("[bold]Resultados da Busca[/bold]", id="results-title")
+                            yield ListView(id="results-list")
+                            yield Button("➕ Carregar Mais", id="btn-load-more", variant="default")
+
+                        with Vertical(id="playlist-pane"):
+                            yield Label("[bold]Fila / Mix Automática[/bold]", id="playlist-title")
+                            yield ListView(id="playlist-list")
+
+                # Seção LOGIN (oculta por padrão)
+                with Vertical(id="section-login", classes="hidden"):
+                    with Vertical(id="login-pane"):
+                        yield Label("[bold cyan]Gerenciamento de Conta YouTube / Google[/bold cyan]", id="login-title")
+                        yield Label("Verificando credenciais...", id="login-account-label")
+                        yield Button("🔑 Fazer Login com Google", id="btn-do-login", variant="primary")
+                        yield Button("🔄 Trocar de Conta", id="btn-switch-account", variant="warning")
+                        yield Button("🚪 Sair da Conta", id="btn-logout", variant="error")
+
+                # Seção CONFIGURAÇÕES (oculta por padrão)
+                with Vertical(id="section-config", classes="hidden"):
+                    with Vertical(id="config-pane"):
+                        yield Label("[bold]Configurações[/bold]")
+                        yield Label("Em construção...")
+
+                # Player persistente no rodapé compacto
+                with Vertical(id="player-panel"):
+                    with Horizontal(id="player-info-row"):
+                        yield Label("Nenhuma música tocando", id="now-playing")
+                        yield Label("Status: Pronto.", id="status")
+                        yield Button("🔉", id="btn-vol-down")
+                        yield Label("80%", id="vol-label")
+                        yield Button("🔊", id="btn-vol-up")
+
+                    with Horizontal(id="progress-row"):
+                        yield Label("00:00", id="time-current")
+                        yield ProgressBar(
+                            id="song-progress",
+                            total=100,
+                            show_percentage=False,
+                        )
+                        yield Label("00:00", id="time-total")
+
+                    with Horizontal(id="controls"):
+                        yield Button("⏮", id="btn-prev")
+                        yield Button("⏪ 10s", id="btn-back")
+                        yield Button("▶ / ⏸", id="btn-toggle", variant="primary")
+                        yield Button("10s ⏩", id="btn-forward")
+                        yield Button("⏭", id="btn-next")
+                        yield Button("⏹", id="btn-stop", variant="error")
+            with Vertical(id="user-playlists-sidebar"):
+                yield Label("[bold]Minhas Playlists[/bold]", id="user-playlists-title")
+                yield ListView(id="user-playlists-list")
+                yield Label("", id="user-playlists-status")
+
+        yield Footer()
+
+    # ------------------------------------------------------------------ #
+    # Inicialização e Monitoramento
+    # ------------------------------------------------------------------ #
+
+    def on_mount(self) -> None:
+        self._show_section("inicio")
+        self.query_one("#user-playlists-sidebar").display = False
+        self._check_account_async()
+        self.query_one("#search-input", Input).focus()
+
+    def _show_section(self, section: str) -> None:
+        """Alterna a visibilidade dos containers conforme a seção selecionada."""
+        self._current_section = section
+        self.query_one("#section-browser").display = False
+        self.query_one("#section-login").display = False
+        self.query_one("#section-config").display = False
+
+        if section in ("inicio", "curtidas"):
+            self.query_one("#section-browser").display = True
+            search_row = self.query_one("#search-row")
+            if section == "inicio":
+                search_row.display = True
+                self.query_one("#results-title", Label).update(
+                    "[bold]Músicas Encontradas[/bold]"
+                )
+            else:
+                search_row.display = False
+                self.query_one("#results-title", Label).update(
+                    "[bold]Músicas Curtidas[/bold]"
+                )
+        elif section == "login":
+            self.query_one("#section-login").display = True
+            self._update_login_view()
+        elif section == "config":
+            self.query_one("#section-config").display = True
+
+    def _check_account_async(self) -> None:
+        """Verifica a conta conectada sem bloquear a interface."""
+
+        def worker() -> None:
+            logged = auth.is_logged_in()
+            name = auth.get_account_name() if logged else None
+            self.call_from_thread(self._update_sidebar_account, logged, name)
+
+        threading.Thread(target=worker, daemon=True).start()
+
+    def _update_sidebar_account(self, logged: bool, name: Optional[str]) -> None:
+        info_label = self.query_one("#sidebar-account-info", Label)
+        if logged:
+            info_label.update(f"[green]● {name or 'Conectado'}[/green]")
+        else:
+            info_label.update("[yellow]○ Não conectado[/yellow]")
+
+    def _toggle_user_playlists(self) -> None:
+        sidebar = self.query_one("#user-playlists-sidebar")
+        sidebar.display = not sidebar.display
+        if sidebar.display and not self._playlists_loaded:
+            self._load_user_playlists()
+
+    def _load_user_playlists(self) -> None:
+        self._playlist_generation += 1
+        generation = self._playlist_generation
+        status = self.query_one("#user-playlists-status", Label)
+        status.update("[yellow]Carregando playlists...[/yellow]")
+        self.query_one("#user-playlists-list", ListView).clear()
+
+        def worker() -> None:
+            try:
+                if not auth.is_logged_in():
+                    self.call_from_thread(
+                        self._show_user_playlists_error,
+                        generation,
+                        "Faça login para ver suas playlists.",
+                    )
+                    return
+                channel = auth.get_channel_info()
+                if not channel:
+                    self.call_from_thread(
+                        self._show_user_playlists_error,
+                        generation,
+                        "Não foi possível identificar o canal.",
+                    )
+                    return
+                items = youtube_playlist.fetch_user_playlists(
+                    channel["id"],
+                    cookies_file=os.environ.get("YTDLP_COOKIES_FILE"),
+                )
+                self.call_from_thread(self._show_user_playlists, generation, items)
+            except Exception as exc:
+                self.call_from_thread(
+                    self._show_user_playlists_error, generation, str(exc)
+                )
+
+        threading.Thread(target=worker, daemon=True).start()
+
+    def _show_user_playlists(
+        self, generation: int, items: list[dict[str, Any]]
+    ) -> None:
+        if generation != self._playlist_generation:
+            return
+        self._user_playlists = items
+        self._playlists_loaded = True
+        playlist_list = self.query_one("#user-playlists-list", ListView)
+        playlist_list.clear()
+        for item in items:
+            title = escape(str(item.get("title", "Playlist")))
+            count = item.get("count")
+            suffix = f" ({count})" if count else ""
+            icon = "★" if item.get("kind") == "liked" else "♫"
+            playlist_list.append(ListItem(Label(f"{icon} {title}{suffix}")))
+        self.query_one("#user-playlists-status", Label).update(
+            f"[green]{len(items)} playlists[/green]"
+        )
+
+    def _show_user_playlists_error(self, generation: int, message: str) -> None:
+        if generation == self._playlist_generation:
+            self.query_one("#user-playlists-status", Label).update(
+                f"[red]{escape(message)}[/red]"
+            )
+
+    def _open_user_playlist(self, item: dict[str, Any]) -> None:
+        if item.get("kind") == "liked":
+            self._show_section("curtidas")
+            self._load_liked()
+            return
+
+        url = str(item.get("url", ""))
+        if not url:
+            return
+        self._active_source = "playlist"
+        self._active_playlist_url = url
+        self._active_playlist_title = str(item.get("title", "Playlist"))
+        self._playlist_generation += 1
+        generation = self._playlist_generation
+        self._show_playlist_tracks(self._active_playlist_title)
+        self._playlist_next_page = None
+        self._last_results = []
+        self.query_one("#results-list", ListView).clear()
+        self.query_one("#btn-load-more", Button).disabled = True
+
+        def worker() -> None:
+            try:
+                tracks, next_page = youtube_playlist.fetch_playlist(url, count=50)
+                self.call_from_thread(
+                    self._apply_playlist_results, generation, tracks, next_page, False
+                )
+            except Exception as exc:
+                self.call_from_thread(self._show_playlist_error, generation, str(exc))
+
+        threading.Thread(target=worker, daemon=True).start()
+
+    def _show_playlist_tracks(self, title: str) -> None:
+        self._current_section = "inicio"
+        self.query_one("#section-browser").display = True
+        self.query_one("#search-row").display = False
+        self.query_one("#results-title", Label).update(
+            f"[bold]{escape(title)}[/bold]"
+        )
+
+    def _apply_playlist_results(
+        self,
+        generation: int,
+        tracks: list[dict[str, Any]],
+        next_page: Optional[str],
+        append: bool,
+    ) -> None:
+        if generation != self._playlist_generation:
+            return
+        if append:
+            self._append_results(tracks)
+        else:
+            self._show_results(tracks)
+        self._playlist_next_page = next_page
+        self.query_one("#btn-load-more", Button).disabled = not bool(next_page)
+        self.query_one("#status", Label).update(
+            f"[green]+{len(tracks)} músicas da playlist.[/green]"
+        )
+
+    def _load_more_playlist(self) -> None:
+        if not self._active_playlist_url or not self._playlist_next_page:
+            self.query_one("#status", Label).update("Fim da playlist.")
+            return
+        self.query_one("#btn-load-more", Button).disabled = True
+        generation = self._playlist_generation
+
+        def worker() -> None:
+            try:
+                tracks, next_page = youtube_playlist.fetch_playlist(
+                    self._active_playlist_url,
+                    count=50,
+                    page_token=self._playlist_next_page,
+                )
+                self.call_from_thread(
+                    self._apply_playlist_results, generation, tracks, next_page, True
+                )
+            except Exception as exc:
+                self.call_from_thread(self._show_playlist_error, generation, str(exc))
+
+        threading.Thread(target=worker, daemon=True).start()
+
+    def _show_playlist_error(self, generation: int, message: str) -> None:
+        if generation == self._playlist_generation:
+            self.query_one("#status", Label).update(
+                f"[red]Não foi possível carregar a playlist: {escape(message)}[/red]"
+            )
+
+    # ------------------------------------------------------------------ #
+    # Eventos de Teclado e Input
+    # ------------------------------------------------------------------ #
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        if event.input.id != "search-input":
+            return
+        query = event.value.strip()
+        if query:
+            self._do_search(query)
+
+    # ------------------------------------------------------------------ #
+    # Navegação e Botões
+    # ------------------------------------------------------------------ #
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        bid = event.button.id
+
+        if bid == "nav-inicio":
+            self._show_section("inicio")
+            self.query_one("#search-input", Input).focus()
+        elif bid == "nav-playlists":
+            self._toggle_user_playlists()
+        elif bid == "nav-login":
+            self._show_section("login")
+        elif bid == "nav-config":
+            self._show_section("config")
+        elif bid == "nav-sair":
+            self.player.stop()
+            self.exit()
+        elif bid == "btn-do-login":
+            self._execute_login(switch=False)
+        elif bid == "btn-switch-account":
+            self._reset_user_playlists()
+            self._execute_login(switch=True)
+        elif bid == "btn-logout":
+            auth.clear_session()
+            self._reset_user_playlists()
+            self._update_login_view()
+            self._check_account_async()
+            self.query_one("#status", Label).update("[yellow]Desconectado da conta.[/yellow]")
+        elif bid == "btn-toggle":
+            self.action_toggle_play()
+        elif bid == "btn-stop":
+            self.player.stop()
+            self.query_one("#status", Label).update("Reprodução parada.")
+            self.query_one("#now-playing", Label).update("Nenhuma música tocando no momento")
+        elif bid == "btn-forward":
+            self.action_seek_forward()
+        elif bid == "btn-back":
+            self.action_seek_back()
+        elif bid == "btn-vol-up":
+            self.action_volume_up()
+        elif bid == "btn-vol-down":
+            self.action_volume_down()
+        elif bid == "btn-next":
+            self.action_next_track()
+        elif bid == "btn-prev":
+            self.action_prev_track()
+        elif bid == "btn-load-more":
+            if self._active_source == "search":
+                self._load_more_search()
+            elif self._active_source == "liked":
+                self._load_more_liked()
+            else:
+                self._load_more_playlist()
+
+
+    def _reset_user_playlists(self) -> None:
+        self._playlist_generation += 1
+        self._playlists_loaded = False
+        self._user_playlists = []
+        sidebar = self.query_one("#user-playlists-sidebar")
+        sidebar.display = False
+        sidebar.query_one("#user-playlists-list", ListView).clear()
+        sidebar.query_one("#user-playlists-status", Label).update("")
+    # ------------------------------------------------------------------ #
+    # Lógica de Login
+    # ------------------------------------------------------------------ #
+
+    def _update_login_view(self) -> None:
+        account_label = self.query_one("#login-account-label", Label)
+        btn_login = self.query_one("#btn-do-login", Button)
+        btn_switch = self.query_one("#btn-switch-account", Button)
+        btn_logout = self.query_one("#btn-logout", Button)
+
+        logged = auth.is_logged_in()
+        if logged:
+            name = auth.get_account_name() or "Conta do YouTube"
+            account_label.update(f"[green]Conta conectada:[/green] [bold]{name}[/bold]")
+            btn_login.display = False
+            btn_switch.display = True
+            btn_logout.display = True
+        else:
+            account_label.update("[yellow]Nenhuma conta conectada no momento.[/yellow]")
+            btn_login.display = True
+            btn_switch.display = False
+            btn_logout.display = False
+
+    def _execute_login(self, switch: bool = False) -> None:
+        status = self.query_one("#status", Label)
+        status.update("[yellow]Abra o navegador para autorizar acesso ao YouTube...[/yellow]")
+
+        def worker() -> None:
+            try:
+                service = auth.switch_account() if switch else auth.get_youtube_service(interactive=True)
+                message = (
+                    "[green]Login realizado com sucesso![/green]"
+                    if service
+                    else "[red]Não foi possível obter credenciais válidas.[/red]"
+                )
+            except Exception as exc:
+                message = f"[red]Erro no login: {exc}[/red]"
+            self.call_from_thread(self._finish_login, message)
+
+        threading.Thread(target=worker, daemon=True).start()
+
+    def _finish_login(self, message: str) -> None:
+        self._reset_user_playlists()
+        self.query_one("#status", Label).update(message)
+        self._update_login_view()
+        self._check_account_async()
+
+    # ------------------------------------------------------------------ #
+    # Lógica de Busca (YouTube Data API v3)
+    # ------------------------------------------------------------------ #
+
+    def _do_search(self, query: str) -> None:
+        query = query.strip()
+        if not query:
+            return
+
+        self._search_generation += 1
+        self._liked_generation += 1
+        self._playlist_generation += 1
+        generation = self._search_generation
+        self._search_query = query
+        self._search_next_page = None
+        self._active_source = "search"
+        self.query_one("#status", Label).update(
+            f"[yellow]Buscando músicas para '{escape(query)}'...[/yellow]"
+        )
+        results_list = self.query_one("#results-list", ListView)
+        results_list.clear()
+        self._last_results = []
+        self.query_one("#btn-load-more", Button).disabled = True
+
+        def worker() -> None:
+            try:
+                results, next_page = search.fetch_page(query, count=15)
+                self.call_from_thread(
+                    self._apply_search_results, generation, results, next_page, False
+                )
+            except Exception as exc:
+                self.call_from_thread(
+                    self._show_search_error, generation, str(exc)
+                )
+
+        threading.Thread(target=worker, daemon=True).start()
+
+    def _load_more_search(self) -> None:
+        if not self._search_query:
+            self.query_one("#status", Label).update(
+                "[yellow]Nenhuma pesquisa ativa. Faça uma nova busca.[/yellow]"
+            )
+            return
+        if not self._search_next_page:
+            self.query_one("#status", Label).update("Fim dos resultados da busca.")
+            return
+
+        self.query_one("#btn-load-more", Button).disabled = True
+        generation = self._search_generation
+        query = self._search_query
+        page_token = self._search_next_page
+
+        def worker() -> None:
+            try:
+                results, next_page = search.fetch_page(
+                    query, count=15, page_token=page_token
+                )
+                self.call_from_thread(
+                    self._apply_search_results, generation, results, next_page, True
+                )
+            except Exception as exc:
+                self.call_from_thread(
+                    self._show_search_error, generation, str(exc)
+                )
+
+        threading.Thread(target=worker, daemon=True).start()
+
+    def _apply_search_results(
+        self,
+        generation: int,
+        results: list[dict[str, Any]],
+        next_page: Optional[str],
+        append: bool,
+    ) -> None:
+        if generation != self._search_generation:
+            return
+        if append:
+            self._append_results(results)
+        else:
+            self._show_results(results)
+        self._search_next_page = next_page
+        self.query_one("#btn-load-more", Button).disabled = not bool(next_page)
+        if results:
+            suffix = "adicionados" if append else "encontrados"
+            self.query_one("#status", Label).update(
+                f"[green]+{len(results)} resultados {suffix}.[/green]"
+            )
+        else:
+            self.query_one("#status", Label).update("Nenhum resultado adicional encontrado.")
+
+    def _show_search_error(self, generation: int, message: str) -> None:
+        if generation != self._search_generation:
+            return
+        self.query_one("#btn-load-more", Button).disabled = True
+        self.query_one("#status", Label).update(
+            f"[red]Não foi possível buscar no YouTube: {message}[/red]"
+        )
+
+    def _load_liked(self) -> None:
+        self._liked_generation += 1
+        self._search_generation += 1
+        self._playlist_generation += 1
+        generation = self._liked_generation
+        self._active_source = "liked"
+        self._liked_next_page = None
+        self.query_one("#status", Label).update(
+            "[yellow]Carregando músicas curtidas do YouTube...[/yellow]"
+        )
+        self.query_one("#results-list", ListView).clear()
+        self._last_results = []
+        self.query_one("#btn-load-more", Button).disabled = True
+
+        def worker() -> None:
+            if not auth.is_logged_in():
+                self.call_from_thread(
+                    self._show_liked_error,
+                    generation,
+                    "faça login antes de abrir as curtidas",
+                )
+                return
+            try:
+                service = auth.get_youtube_service(interactive=False)
+                results, next_page = liked.fetch_liked(service)
+                self.call_from_thread(
+                    self._apply_liked_results, generation, results, next_page, False
+                )
+            except Exception as exc:
+                self.call_from_thread(self._show_liked_error, generation, str(exc))
+
+        threading.Thread(target=worker, daemon=True).start()
+
+    def _load_more_liked(self) -> None:
+        if not self._liked_next_page:
+            self.query_one("#status", Label).update("Fim das músicas curtidas.")
+            return
+
+        self.query_one("#btn-load-more", Button).disabled = True
+        generation = self._liked_generation
+        page_token = self._liked_next_page
+
+        def worker() -> None:
+            try:
+                service = auth.get_youtube_service(interactive=False)
+                results, next_page = liked.fetch_liked(
+                    service, page_token=page_token
+                )
+                self.call_from_thread(
+                    self._apply_liked_results, generation, results, next_page, True
+                )
+            except Exception as exc:
+                self.call_from_thread(self._show_liked_error, generation, str(exc))
+
+        threading.Thread(target=worker, daemon=True).start()
+
+    def _apply_liked_results(
+        self,
+        generation: int,
+        results: list[dict[str, Any]],
+        next_page: Optional[str],
+        append: bool,
+    ) -> None:
+        if generation != self._liked_generation:
+            return
+        if append:
+            self._append_results(results)
+        else:
+            self._show_results(results)
+        self._liked_next_page = next_page
+        self.query_one("#btn-load-more", Button).disabled = not bool(next_page)
+        if results:
+            self.query_one("#status", Label).update(
+                f"[green]+{len(results)} curtidas carregadas.[/green]"
+            )
+        else:
+            self.query_one("#status", Label).update("Nenhuma curtida encontrada.")
+
+    def _show_liked_error(self, generation: int, message: str) -> None:
+        if generation != self._liked_generation:
+            return
+        self.query_one("#btn-load-more", Button).disabled = True
+        self.query_one("#status", Label).update(
+            f"[red]Não foi possível carregar as curtidas: {message}[/red]"
+        )
+
+    # ------------------------------------------------------------------ #
+    # Mix e Playlist
+    # ------------------------------------------------------------------ #
+
+    def _fetch_for_mix(
+        self, query: str, count: int, page_token: Optional[str] = None
+    ) -> tuple[list[dict[str, Any]], Optional[str]]:
+        """Provedor paginado de busca usado pelo MixService."""
+        return search.fetch_page(query, count=count, page_token=page_token)
+
+    def _should_ignore_selection(self, track: dict[str, Any]) -> bool:
+        track_key = str(
+            track.get("id") or track.get("url") or track.get("title", "")
+        )
+        if not track_key:
+            return False
+        now = time.monotonic()
+        if (
+            track_key == self._last_selection_key
+            and now - self._last_selection_at < 0.8
+        ):
+            return True
+        self._last_selection_key = track_key
+        self._last_selection_at = now
+        return False
+
+    def _start_mix_for_track(self, track: dict[str, Any]) -> None:
+        """Toca a faixa imediatamente e prepara a Mix em segundo plano."""
+        if self._should_ignore_selection(track):
+            return
+        status = self.query_one("#status", Label)
+        title = escape(str(track.get("title", "Sem título")))
+        status.update(f"[yellow]Carregando áudio de '{title}'...[/yellow]")
+
+        # A âncora toca fora da fila; a lista começa na primeira relacionada.
+        self.player.set_queue([])
+        self._refresh_playlist_ui()
+        self.player.play_external(track)
+
+        self._mix_generation += 1
+        generation = self._mix_generation
+        seed_tracks = list(self._last_results)
+
+        def worker() -> None:
+            try:
+                with self._mix_lock:
+                    if generation != self._mix_generation:
+                        return
+                    mix_tracks = self.mix.start(
+                        track, seed_tracks=seed_tracks
+                    )
+                self.call_from_thread(self._apply_mix, generation, mix_tracks)
+            except Exception as exc:
+                with self._mix_lock:
+                    partial_tracks = (
+                        list(self.mix.tracks)
+                        if generation == self._mix_generation
+                        else []
+                    )
+                if len(partial_tracks) > 1:
+                    self.call_from_thread(
+                        self._apply_mix, generation, partial_tracks, str(exc)
+                    )
+                else:
+                    self.call_from_thread(self._show_mix_error, generation, str(exc))
+
+        threading.Thread(target=worker, daemon=True).start()
+
+    def _apply_mix(
+        self,
+        generation: int,
+        mix_tracks: list[dict[str, Any]],
+        warning: Optional[str] = None,
+    ) -> None:
+        if generation != self._mix_generation:
+            return
+        related = mix_tracks[1:]
+        if related:
+            self.player.add_to_queue(related)
+            self._refresh_playlist_ui()
+            if warning:
+                self.query_one("#status", Label).update(
+                    f"[yellow]Mix parcial: +{len(related)} músicas locais.[/yellow]"
+                )
+            else:
+                self.query_one("#status", Label).update(
+                    f"[green]Mix ativa: +{len(related)} músicas relacionadas prontas.[/green]"
+                )
+
+    def _show_mix_error(self, generation: int, message: str) -> None:
+        if generation == self._mix_generation:
+            self.query_one("#status", Label).update(
+                f"[yellow]A faixa está tocando, mas a Mix não pôde ser criada: {message}[/yellow]"
+            )
+
+    def _refill_mix_if_needed(self) -> None:
+        current_index = self.player.current_index
+        remaining = (
+            self.player.queue_length()
+            if current_index is None
+            else self.player.queue_length() - (current_index + 1)
+        )
+        if not self.mix.needs_refill(remaining):
+            return
+
+        generation = self._mix_generation
+
+        def worker() -> None:
+            try:
+                with self._mix_lock:
+                    if generation != self._mix_generation:
+                        return
+                    new_tracks = self.mix.refill()
+                self.call_from_thread(self._apply_mix_refill, generation, new_tracks)
+            except Exception as exc:
+                self.call_from_thread(self._show_mix_error, generation, str(exc))
+
+        threading.Thread(target=worker, daemon=True).start()
+
+    def _apply_mix_refill(
+        self, generation: int, new_tracks: list[dict[str, Any]]
+    ) -> None:
+        if generation != self._mix_generation or not new_tracks:
+            return
+        self.player.add_to_queue(new_tracks)
+        self._refresh_playlist_ui()
+        self.query_one("#status", Label).update(
+            f"[green]+{len(new_tracks)} músicas adicionadas à Mix.[/green]"
+        )
+
+    # ------------------------------------------------------------------ #
+    # Callbacks do Player
+    # ------------------------------------------------------------------ #
+
+    def _on_player_state(self, state: dict[str, Any]) -> None:
+        self.call_from_thread(self._sync_player_state_ui, state)
+
+    def _sync_player_state_ui(self, state: dict[str, Any]) -> None:
+        track = state.get("track")
+        if track:
+            title = escape(str(track.get("title", "Sem título")))
+            self.query_one("#now-playing", Label).update(
+                f"[bold red]▶ Tocando:[/bold red] [bold #ffffff]{title}[/bold #ffffff]"
+            )
+        else:
+            self.query_one("#now-playing", Label).update("Nenhuma música tocando")
+
+        status = self.query_one("#status", Label)
+        if state.get("playing"):
+            status.update("[bold red]Reproduzindo ♪[/bold red]")
+        elif state.get("paused"):
+            status.update("[yellow]Pausado ⏸[/yellow]")
+        self._refresh_vol_label()
+        self._refresh_playlist_markers()
+
+    def _on_player_progress(self, progress: dict[str, Any]) -> None:
+        self.call_from_thread(self._sync_player_progress_ui, progress)
+
+    def _sync_player_progress_ui(self, progress: dict[str, Any]) -> None:
+        position = float(progress.get("position", 0.0) or 0.0)
+        duration = float(progress.get("duration", 0.0) or 0.0)
+        self.query_one("#time-current", Label).update(format_time(position))
+        self.query_one("#time-total", Label).update(format_time(duration))
+        bar = self.query_one("#song-progress", ProgressBar)
+        bar.progress = min(100.0, (position / duration) * 100.0) if duration > 0 else 0
+
+    def _on_track_finished(self) -> None:
+        self._refill_mix_if_needed()
+        self.call_from_thread(self._refresh_playlist_markers)
+
+    def _refresh_vol_label(self) -> None:
+        percentage = int(self.player.volume * 100)
+        self.query_one("#vol-label", Label).update(f"{percentage}%")
+
+    # ------------------------------------------------------------------ #
+    # Ações de Atalho (Bindings)
+    # ------------------------------------------------------------------ #
+
+    async def action_quit(self) -> None:
+        self.player.stop()
+        self.exit()
+
+    def action_toggle_play(self) -> None:
+        if self.player.is_playing and not self.player.is_paused:
+            self.player.pause()
+        elif self.player.is_paused or self.player.current_track:
+            self.player.play()
+
+    def action_volume_up(self) -> None:
+        self.player.set_volume(self.player.volume + 0.05)
+        self._refresh_vol_label()
+
+    def action_volume_down(self) -> None:
+        self.player.set_volume(self.player.volume - 0.05)
+        self._refresh_vol_label()
+
+    def action_next_track(self) -> None:
+        if self.player.play_next():
+            self._refill_mix_if_needed()
+            self._refresh_playlist_markers()
+
+    def action_prev_track(self) -> None:
+        if self.player.play_prev():
+            self._refresh_playlist_markers()
+
+    def action_seek_forward(self) -> None:
+        self.player.seek(10)
+
+    def action_seek_back(self) -> None:
+        self.player.seek(-10)
+
+    # ------------------------------------------------------------------ #
+    # Eventos das Listas (Seleção de Música)
+    # ------------------------------------------------------------------ #
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        if event.list_view.id == "user-playlists-list":
+            index = event.index
+            if 0 <= index < len(self._user_playlists):
+                self._open_user_playlist(self._user_playlists[index])
+            return
+
+        if event.list_view.id == "results-list":
+            index = event.index
+            if 0 <= index < len(self._last_results):
+                self._start_mix_for_track(self._last_results[index])
+            return
+
+        if event.list_view.id == "playlist-list":
+            index = event.index
+            queue = self.player.queue
+            if 0 <= index < len(queue) and not self._should_ignore_selection(
+                queue[index]
+            ):
+                self.player.play(queue[index])
+                self._refill_mix_if_needed()
+                self._refresh_playlist_markers()
+
+    def _result_item(self, result: dict[str, Any]) -> ListItem:
+        icon = "🎵" if result.get("is_music") else "🎬"
+        duration = format_time(result.get("duration", 0))
+        title = escape(str(result.get("title", "Sem título")))
+        artist = result.get("artist")
+        suffix = f" — {escape(str(artist))}" if artist else ""
+        return ListItem(
+            Label(f"{icon} {title}{suffix} [dim #aaaaaa][{duration}][/dim #aaaaaa]")
+        )
+
+    def _show_results(self, results: list[dict[str, Any]]) -> None:
+        self._last_results = list(results)
+        results_list = self.query_one("#results-list", ListView)
+        results_list.clear()
+        for result in results:
+            results_list.append(self._result_item(result))
+
+    def _append_results(self, results: list[dict[str, Any]]) -> None:
+        results_list = self.query_one("#results-list", ListView)
+        for result in results:
+            self._last_results.append(result)
+            results_list.append(self._result_item(result))
+
+    def _refresh_playlist_ui(self) -> None:
+        playlist = self.query_one("#playlist-list", ListView)
+        playlist.clear()
+        queue = self.player.queue
+        current_index = self.player.current_index
+        for index, track in enumerate(queue):
+            marker = "[bold red]▶[/bold red] " if index == current_index else "   "
+            title = escape(str(track.get("title", "Sem título")))
+            styled = (
+                f"[bold #ffffff]{title}[/bold #ffffff]"
+                if index == current_index
+                else f"[#aaaaaa]{title}[/#aaaaaa]"
+            )
+            playlist.append(ListItem(Label(f"{marker}{styled}")))
+        if current_index is not None and 0 <= current_index < len(queue):
+            playlist.index = current_index
+        else:
+            playlist.index = None
+
+    def _refresh_playlist_markers(self) -> None:
+        playlist = self.query_one("#playlist-list", ListView)
+        queue = self.player.queue
+        if len(playlist.children) != len(queue):
+            self._refresh_playlist_ui()
+            return
+        current_index = self.player.current_index
+        if current_index is not None and 0 <= current_index < len(queue):
+            playlist.index = current_index
+        else:
+            playlist.index = None
+        for index, child in enumerate(playlist.children):
+            marker = "[bold red]▶[/bold red] " if index == current_index else "   "
+            title = escape(str(queue[index].get("title", "Sem título")))
+            styled = (
+                f"[bold #ffffff]{title}[/bold #ffffff]"
+                if index == current_index
+                else f"[#aaaaaa]{title}[/#aaaaaa]"
+            )
+            child.query_one(Label).update(f"{marker}{styled}")