app_lib/

tray_menu.rs

//! System tray / menu bar icon: playback controls, dynamic title + tooltip, popup menu,
//! and (non-Linux) a **WebView popover** styled like macOS Now Playing (no artwork).
use std::collections::HashMap;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Mutex;
use std::thread;
use std::time::Duration;
use tauri::image::Image;
use tauri::menu::MenuBuilder;
use tauri::tray::{MouseButton, MouseButtonState, TrayIcon, TrayIconBuilder, TrayIconEvent};
use tauri::{
    App, AppHandle, Emitter, LogicalSize, Manager, PhysicalPosition, Position, Rect,
    Size, State, Wry,
};

use crate::history;

/// Max characters for the first row of the tray dropdown (macOS truncates visually; keep readable).
const TRAY_MENU_NOW_PLAYING_MAX: usize = 96;

const TRAY_POPOVER_W: u32 = 340;
/// Default height until JS measures `#shell` (`tray_popover_resize`); generous so first paint is not clipped
/// (multi-line title + meta + directory path + progress + volume + speed + transport + padding).
const TRAY_POPOVER_H: u32 = 480;

/// Set `AUDIO_HAXOR_TRAY_DEBUG=1` in the environment to print every successful `tray-popover-state` /
/// `tray-popover-ui-theme` emit to stderr (state includes the ~500 ms host poll). Emit **failures** always log.
fn emit_tray_popover_state(app: &AppHandle<Wry>, emit: &TrayPopoverEmit) {
    let appearance_n = emit
        .appearance
        .as_ref()
        .map(|m| m.len())
        .unwrap_or(0);
    match app.emit_to("tray-popover", "tray-popover-state", emit) {
        Ok(()) => {
            if std::env::var_os("AUDIO_HAXOR_TRAY_DEBUG").is_some() {
                eprintln!(
                    "[tray-popover-host] emit tray-popover-state ok idle={} ui_theme={} appearance_vars={} title_ch={} subtitle_ch={} playing={} elapsed={:.2} total_sec={:?}",
                    emit.idle,
                    emit.ui_theme,
                    appearance_n,
                    emit.title.chars().count(),
                    emit.subtitle.chars().count(),
                    emit.playing,
                    emit.elapsed_sec,
                    emit.total_sec
                );
            }
        }
        Err(e) => {
            eprintln!("[tray-popover-host] emit tray-popover-state FAILED: {e}");
        }
    }
}

/// Light/dark from prefs (`prefs_set` key `theme`). Same debug env / failure logging as [`emit_tray_popover_state`].
pub fn emit_tray_popover_ui_theme(app: &AppHandle<Wry>, ui_theme: &str) {
    let payload = serde_json::json!({ "ui_theme": ui_theme });
    match app.emit_to("tray-popover", "tray-popover-ui-theme", payload) {
        Ok(()) => {
            if std::env::var_os("AUDIO_HAXOR_TRAY_DEBUG").is_some() {
                eprintln!(
                    "[tray-popover-host] emit tray-popover-ui-theme ok ui_theme={ui_theme}"
                );
            }
        }
        Err(e) => {
            eprintln!("[tray-popover-host] emit tray-popover-ui-theme FAILED: {e}");
        }
    }
}

/// Prefer the bundle window icon; otherwise embed `32x32.png` so dev/release always have pixels.
fn tray_menu_bar_icon(app: &App) -> tauri::Result<Image<'static>> {
    if let Some(icon) = app.default_window_icon() {
        return Ok(icon.clone().to_owned());
    }
    const TRAY_PNG: &[u8] = include_bytes!("../icons/32x32.png");
    Image::from_bytes(TRAY_PNG)
}

fn t(strings: &HashMap<String, String>, key: &str, fallback: &str) -> String {
    strings
        .get(key)
        .map(|s| s.as_str())
        .filter(|s| !s.is_empty())
        .unwrap_or(fallback)
        .to_string()
}

/// Prefs key `theme` → popover `data-theme` (`light` vs `dark` HUD).
fn tray_popover_ui_theme_from_prefs() -> String {
    match history::get_preference("theme") {
        Some(serde_json::Value::String(s)) if s == "light" => "light".to_string(),
        _ => "dark".to_string(),
    }
}

fn truncate_tray_menu_line(s: &str) -> String {
    let t = s.trim();
    if t.chars().count() <= TRAY_MENU_NOW_PLAYING_MAX {
        return t.to_string();
    }
    let mut out = String::new();
    for (i, ch) in t.chars().enumerate() {
        if i >= TRAY_MENU_NOW_PLAYING_MAX.saturating_sub(1) {
            break;
        }
        out.push(ch);
    }
    out.push('…');
    out
}

/// Serialized to the `tray-popover` WebView for frosted Now Playing UI.
#[derive(Clone, serde::Serialize)]
pub struct TrayPopoverEmit {
    pub idle: bool,
    pub title: String,
    pub subtitle: String,
    /// Absolute path of the playing file — tray popover reveal / copy / context menu.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reveal_path: Option<String>,
    pub elapsed_sec: f64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub total_sec: Option<f64>,
    pub playing: bool,
    /// Clamped 0.25..=2.0 — mirrors prefs `audioSpeed` / main `#npSpeed`.
    pub playback_speed: f64,
    /// 0..=100 — mirrors prefs `audioVolume` / main `#npVolume`.
    pub volume_pct: u8,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub idle_hint: Option<String>,
    /// `"light"` or `"dark"` — tray-popover.html uses this for `html[data-theme]`.
    pub ui_theme: String,
    /// Main-window scheme snapshot (`--cyan`, `--bg-primary`, …) applied on the popover root.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub appearance: Option<HashMap<String, String>>,
}

/// Per-tray state: icon + cached i18n for rebuilding the popup without hitting SQLite each tick.
pub struct TrayState {
    pub inner: Mutex<TrayStateInner>,
}

pub struct TrayStateInner {
    pub tray: Option<TrayIcon<Wry>>,
    pub menu_strings: HashMap<String, String>,
    pub now_playing_menu_line: Option<String>,
    pub last_popover_emit: Option<TrayPopoverEmit>,
    pub last_tray_appearance: Option<HashMap<String, String>>,
}

impl Default for TrayStateInner {
    fn default() -> Self {
        Self {
            tray: None,
            menu_strings: HashMap::new(),
            now_playing_menu_line: None,
            last_popover_emit: None,
            last_tray_appearance: None,
        }
    }
}

impl Default for TrayState {
    fn default() -> Self {
        Self {
            inner: Mutex::new(TrayStateInner::default()),
        }
    }
}

/// Rebuild tray popup labels from `app_i18n` (after UI locale change). Preserves last now-playing line.
pub fn refresh_tray_popup_menu(
    app: &AppHandle<Wry>,
    state: &TrayState,
    strings: &HashMap<String, String>,
) -> Result<(), String> {
    let mut guard = state
        .inner
        .lock()
        .map_err(|_| "tray state mutex poisoned".to_string())?;
    let Some(tray) = guard.tray.clone() else {
        return Ok(());
    };
    guard.menu_strings.clone_from(strings);
    let menu = build_tray_popup_menu(
        app,
        &guard.menu_strings,
        guard.now_playing_menu_line.as_deref(),
    )?;
    drop(guard);
    tray.set_menu(Some(menu)).map_err(|e| e.to_string())
}

fn build_tray_popup_menu(
    app: &AppHandle<Wry>,
    strings: &HashMap<String, String>,
    now_playing_line: Option<&str>,
) -> Result<tauri::menu::Menu<Wry>, String> {
    let mut b = MenuBuilder::new(app);
    if let Some(raw) = now_playing_line {
        let line = truncate_tray_menu_line(raw);
        if !line.is_empty() {
            b = b.text("tray_now_playing", line);
            b = b.separator();
        }
    }
    b.text("tray_show", t(strings, "tray.show", "Show AUDIO_HAXOR"))
        .separator()
        .text("tray_scan_all", t(strings, "tray.scan_all", "Scan All"))
        .text("tray_stop_all", t(strings, "tray.stop_all", "Stop All"))
        .separator()
        .text("tray_prev", t(strings, "tray.previous_track", "Previous Track"))
        .text("tray_play_pause", t(strings, "tray.play_pause", "Play / Pause"))
        .text("tray_next", t(strings, "tray.next_track", "Next Track"))
        .separator()
        .text("tray_quit", t(strings, "tray.quit", "Quit"))
        .build()
        .map_err(|e| e.to_string())
}

/// `scale_factor` maps logical popover width to **physical** pixels when `rect` uses physical coordinates
/// (common on macOS tray events).
fn popover_xy_below_tray(rect: &Rect, scale_factor: f64) -> (i32, i32) {
    let physical_coords = matches!(rect.position, Position::Physical(..));
    let pop_w_half = if physical_coords {
        f64::from(TRAY_POPOVER_W) * scale_factor / 2.0
    } else {
        f64::from(TRAY_POPOVER_W) / 2.0
    };
    let gap = if physical_coords {
        4.0_f64 * scale_factor
    } else {
        4.0_f64
    };
    let (px, py) = match rect.position {
        Position::Physical(p) => (p.x as f64, p.y as f64),
        Position::Logical(p) => (p.x, p.y),
    };
    let (w, h) = match rect.size {
        Size::Physical(s) => (s.width as f64, s.height as f64),
        Size::Logical(s) => (s.width, s.height),
    };
    let x = px + w / 2.0 - pop_w_half;
    let y = py + h + gap;
    (x.floor() as i32, y.floor() as i32)
}

fn toggle_tray_popover(app: &AppHandle<Wry>, rect: &Rect) -> Result<(), String> {
    let tray_state = app.state::<TrayState>();
    let last = tray_state
        .inner
        .lock()
        .map_err(|_| "tray state mutex poisoned".to_string())?
        .last_popover_emit
        .clone();
    let Some(win) = app.get_webview_window("tray-popover") else {
        return Ok(());
    };
    if win.is_visible().unwrap_or(false) {
        let _ = win.hide();
        return Ok(());
    }
    let mut emit = last.unwrap_or(TrayPopoverEmit {
        idle: true,
        title: String::new(),
        subtitle: String::new(),
        reveal_path: None,
        elapsed_sec: 0.0,
        total_sec: None,
        playing: false,
        playback_speed: 1.0,
        volume_pct: 100,
        idle_hint: None,
        ui_theme: tray_popover_ui_theme_from_prefs(),
        appearance: None,
    });
    emit.ui_theme = tray_popover_ui_theme_from_prefs();
    emit_tray_popover_state(app, &emit);
    let scale = win.scale_factor().unwrap_or(1.0);
    let (mut x, y) = popover_xy_below_tray(rect, scale);
    x = x.max(8);
    let _ = win.set_size(tauri::Size::Logical(LogicalSize::new(
        f64::from(TRAY_POPOVER_W),
        f64::from(TRAY_POPOVER_H),
    )));
    let _ = win.set_position(tauri::Position::Physical(PhysicalPosition::new(x, y)));
    let _ = win.show();
    /* Re-apply after `show`: some platforms drop window level across `hide`/`show` cycles. */
    let _ = win.set_always_on_top(true);
    /* Force the popover to become the key window so keyboard events (Escape) reach its JS
     * `keydown` listener AND so `WindowEvent::Focused(false)` fires when the user clicks
     * outside. NSPanel with `visibleOnAllWorkspaces` defaults to non-activating — clicks only
     * transfer "active" status, not key status — so without this call the popover never gets
     * keyboard focus and never fires a blur event either. The historical comment said
     * `set_focus` causes Mission Control to jump Spaces, but that was about focusing the
     * main window; the popover itself is `visibleOnAllWorkspaces: true` so focusing it stays
     * on the current Space. If this turns out to Space-jump in practice we can hop to an
     * Objective-C `makeKeyWindow` via FFI that skips the `NSApp.activate` step. */
    let _ = win.set_focus();
    Ok(())
}

pub fn create_tray(app: &App, strings: &HashMap<String, String>) -> Result<TrayIcon<Wry>, String> {
    let handle = app.handle().clone();
    let tray_menu = build_tray_popup_menu(&handle, strings, None)?;
    let icon = tray_menu_bar_icon(app).map_err(|e| e.to_string())?;
    let mut builder = TrayIconBuilder::new()
        .menu(&tray_menu)
        .icon(icon)
        .tooltip(t(strings, "tray.tooltip", "AUDIO_HAXOR"))
        .show_menu_on_left_click(cfg!(target_os = "linux"));
    #[cfg(target_os = "macos")]
    {
        // Menu bar PNGs from the app bundle are full-color; `template=true` often draws them invisible.
        builder = builder.icon_as_template(false);
    }
    let tray = builder.build(app).map_err(|e| e.to_string())?;
    #[cfg(not(target_os = "linux"))]
    {
        tray.on_tray_icon_event(move |tray, event| {
            if let TrayIconEvent::Click {
                button: MouseButton::Left,
                button_state: MouseButtonState::Up,
                rect,
                ..
            } = event
            {
                let app = tray.app_handle().clone();
                let _ = toggle_tray_popover(&app, &rect);
            }
        });
    }
    Ok(tray)
}

#[derive(serde::Deserialize)]
pub struct TrayNowPlayingPayload {
    #[serde(default)]
    pub title_bar: Option<String>,
    pub tooltip: String,
    #[serde(default)]
    pub idle: bool,
    #[serde(default)]
    pub popover_title: Option<String>,
    #[serde(default)]
    pub popover_subtitle: Option<String>,
    #[serde(default)]
    pub elapsed_sec: Option<f64>,
    #[serde(default)]
    pub total_sec: Option<f64>,
    #[serde(default)]
    pub popover_playing: Option<bool>,
    #[serde(default)]
    pub popover_idle_label: Option<String>,
    /// Optional: main prefs `audioSpeed` (0.25..=2). When omitted, last popover value is kept.
    #[serde(default)]
    pub playback_speed: Option<f64>,
    /// Optional: main prefs `audioVolume` (0..=100). When omitted, last popover value is kept.
    #[serde(default)]
    pub volume_pct: Option<f64>,
    /// Optional: main window `data-theme` (`"light"` / `"dark"`). When omitted, Rust reads prefs.
    #[serde(default)]
    pub ui_theme: Option<String>,
    /// Optional: `getComputedStyle(document.documentElement)` snapshot for scheme vars (`--cyan`, …).
    #[serde(default)]
    pub appearance: Option<HashMap<String, String>>,
    /// Optional: filesystem path for the playing item — popover reveal / copy.
    #[serde(default)]
    pub popover_reveal_path: Option<String>,
}

fn normalized_popover_reveal_path(payload: &TrayNowPlayingPayload) -> Option<String> {
    payload
        .popover_reveal_path
        .as_ref()
        .map(|s| s.trim().to_string())
        .filter(|s| !s.is_empty())
}

fn tray_emit_ui_theme(payload: &TrayNowPlayingPayload) -> String {
    match payload.ui_theme.as_deref() {
        Some("light") => "light".to_string(),
        Some(_) => "dark".to_string(),
        None => tray_popover_ui_theme_from_prefs(),
    }
}

fn tray_playback_speed_merge(payload: &TrayNowPlayingPayload, last: Option<&TrayPopoverEmit>) -> f64 {
    let fallback = || last.map(|e| e.playback_speed).unwrap_or(1.0);
    match payload.playback_speed {
        Some(s) if s.is_finite() => s.clamp(0.25, 2.0),
        _ => fallback(),
    }
}

fn tray_volume_pct_merge(payload: &TrayNowPlayingPayload, last: Option<&TrayPopoverEmit>) -> u8 {
    let fallback = || last.map(|e| e.volume_pct).unwrap_or(100);
    match payload.volume_pct {
        Some(v) if v.is_finite() => v.clamp(0.0, 100.0).round() as u8,
        _ => fallback(),
    }
}

#[tauri::command]
pub fn tray_popover_action(app: AppHandle<Wry>, action: String) -> Result<(), String> {
    /* For `volume:<N>` and `speed:<N>` actions, update `TrayState.last_popover_emit` synchronously
     * with the incoming value. The main window's JS debounces `syncTrayNowPlayingFromPlayback` by
     * 150 ms, but the `start_tray_host_poll` thread re-emits `tray-popover-state` every 500 ms
     * using the cached `volume_pct` / `playback_speed`. Without this pre-update, a host poll tick
     * that fires between the last drag input and the debounced JS sync would broadcast the stale
     * cached value — once the popover's `_trayVolUserActive` 400 ms guard expires, the slider
     * snaps back to the old value. Updating the cache here makes the host poll always emit the
     * latest user intent. */
    if let Some(rest) = action.strip_prefix("volume:") {
        if let Ok(n) = rest.parse::<f64>() {
            if let Some(tray_state) = app.try_state::<TrayState>() {
                if let Ok(mut guard) = tray_state.inner.lock() {
                    if let Some(emit) = guard.last_popover_emit.as_mut() {
                        emit.volume_pct = n.clamp(0.0, 100.0).round() as u8;
                    }
                }
            }
        }
    } else if let Some(rest) = action.strip_prefix("speed:") {
        if let Ok(s) = rest.parse::<f64>() {
            if s.is_finite() {
                if let Some(tray_state) = app.try_state::<TrayState>() {
                    if let Ok(mut guard) = tray_state.inner.lock() {
                        if let Some(emit) = guard.last_popover_emit.as_mut() {
                            emit.playback_speed = s.clamp(0.25, 2.0);
                        }
                    }
                }
            }
        }
    } else if let Some(rest) = action.strip_prefix("seek:") {
        /* Seek directly to the audio-engine from Rust rather than round-tripping through the
         * main window's `listen('menu-action')` → `seekPlaybackToPercent` path. The main webview
         * can be suspended by WebKit when it's in another Space, minimized, or occluded, which
         * means the JS listener doesn't run until the user clicks the main app to bring it
         * forward — the user observed: "moving the playback slider in tray popover doesn't move
         * the playhead until you click on main app". Firing `playback_seek` here is
         * webview-state-independent. We still emit `menu-action` below so the main window's
         * waveform / now-playing UI picks up the new position on the next poll tick OR as soon
         * as it resumes. */
        if let Ok(frac) = rest.parse::<f64>() {
            if frac.is_finite() {
                let frac = frac.clamp(0.0, 1.0);
                let total_sec = app
                    .try_state::<TrayState>()
                    .and_then(|s| s.inner.lock().ok().and_then(|g| {
                        g.last_popover_emit.as_ref().and_then(|e| e.total_sec)
                    }));
                if let Some(dur) = total_sec {
                    if dur > 0.0 {
                        let position_sec = frac * dur;
                        std::thread::spawn(move || {
                            let _ = crate::audio_engine::spawn_audio_engine_request(
                                &serde_json::json!({
                                    "cmd": "playback_seek",
                                    "position_sec": position_sec,
                                }),
                            );
                        });
                    }
                }
            }
        }
    }
    // Same delivery path as `on_menu_event` in lib.rs: only the **main** webview runs `ipc.js`
    // playback handlers — broadcast `emit` does not reliably hit the main window listener.
    let _ = app.emit_to("main", "menu-action", action);
    Ok(())
}

/// Fit the `tray-popover` WebView to content (title lines, meta, fonts). Called from `tray-popover.js`.
/// Width/height are **CSS / logical** pixels (same units as `getBoundingClientRect`); `PhysicalSize` would
/// undersize on HiDPI and clip the HUD.
#[tauri::command]
pub fn tray_popover_resize(app: AppHandle<Wry>, width: f64, height: f64) -> Result<(), String> {
    let Some(win) = app.get_webview_window("tray-popover") else {
        return Ok(());
    };
    let w = width.clamp(240.0, 620.0);
    /* Tall cap: meta + wrapped directory path; `tray-popover.js` measures `#shell` scroll height.
     * Low floor (60 px) so a near-empty idle popover can actually shrink — a higher minimum
     * leaves transparent padding at the bottom that swallows clicks outside the visible shell. */
    let h = height.clamp(60.0, 1200.0);
    let _ = win.set_size(tauri::Size::Logical(LogicalSize::new(w, h)));
    Ok(())
}

/// **Tauri v2 IPC:** call `invoke('update_tray_now_playing', { payload: … })` — the outer key must be
/// `payload` (matches this parameter name); a flat object fails deserialization.
#[tauri::command]
pub fn update_tray_now_playing(
    app: AppHandle<Wry>,
    tray_state: State<'_, TrayState>,
    payload: TrayNowPlayingPayload,
) -> Result<(), String> {
    let mut guard = tray_state
        .inner
        .lock()
        .map_err(|_| "tray state mutex poisoned".to_string())?;
    let Some(tray) = guard.tray.clone() else {
        return Ok(());
    };

    let np_line = if payload.idle {
        None
    } else {
        payload
            .title_bar
            .as_ref()
            .map(|s| s.trim())
            .filter(|s| !s.is_empty())
            .map(|s| s.to_string())
    };
    guard.now_playing_menu_line.clone_from(&np_line);

    if let Some(ref map) = payload.appearance {
        if !map.is_empty() {
            guard.last_tray_appearance = Some(map.clone());
        }
    }

    let theme = tray_emit_ui_theme(&payload);
    let appearance = guard.last_tray_appearance.clone();
    let last_emit = guard.last_popover_emit.as_ref();
    let prev_reveal_path = last_emit.and_then(|e| e.reveal_path.clone());
    let playback_speed = tray_playback_speed_merge(&payload, last_emit);
    let volume_pct = tray_volume_pct_merge(&payload, last_emit);
    let emit = if payload.idle {
        TrayPopoverEmit {
            idle: true,
            title: String::new(),
            subtitle: String::new(),
            reveal_path: None,
            elapsed_sec: 0.0,
            total_sec: None,
            playing: false,
            playback_speed,
            volume_pct,
            idle_hint: payload
                .popover_idle_label
                .clone()
                .filter(|s| !s.trim().is_empty()),
            ui_theme: theme,
            appearance: appearance.clone(),
        }
    } else {
        TrayPopoverEmit {
            idle: false,
            title: payload.popover_title.clone().unwrap_or_default(),
            subtitle: payload.popover_subtitle.clone().unwrap_or_default(),
            reveal_path: normalized_popover_reveal_path(&payload),
            elapsed_sec: payload.elapsed_sec.unwrap_or(0.0),
            total_sec: payload.total_sec,
            playing: payload.popover_playing.unwrap_or(false),
            playback_speed,
            volume_pct,
            idle_hint: None,
            ui_theme: theme,
            appearance: appearance.clone(),
        }
    };
    guard.last_popover_emit = Some(emit.clone());

    let menu = build_tray_popup_menu(
        &app,
        &guard.menu_strings,
        guard.now_playing_menu_line.as_deref(),
    )?;
    drop(guard);
    let _ = tray.set_menu(Some(menu));
    let _ = tray.set_tooltip(Some(payload.tooltip.as_str()));
    /* Menu-bar status item shows icon only — the track name still appears as the first row of the
     * dropdown menu + in the popover HUD + the hover tooltip, but nothing is drawn next to the icon. */
    #[cfg(target_os = "macos")]
    {
        let _ = tray.set_title(None::<&str>);
    }
    emit_tray_popover_state(&app, &emit);

    /* SMB directory metadata pre-warmer: when the now-playing `reveal_path` changes, walk the
     * parent directory on a detached thread so Finder's eventual "Reveal in Finder" click lands
     * on a warm SMB stat cache instead of paying a multi-second network round-trip for the
     * listing. For local SSD libraries this is microseconds and a no-op.
     *
     * We deliberately do NOT pre-read the audio file content here anymore — the audio-engine
     * now slurps the full file into a `MemoryBlock` at playback start (see
     * `Engine.cpp::playbackLoad`), so the file is pinned in process-heap RAM for the lifetime
     * of the track and is immune to `smbfs` UBC eviction under Finder's memory pressure. A Rust
     * parallel read-through would just double the initial SMB bandwidth used at track change
     * with zero benefit. */
    let new_reveal_path = emit.reveal_path.clone();
    if new_reveal_path != prev_reveal_path {
        if let Some(rp) = new_reveal_path {
            std::thread::spawn(move || {
                let p = std::path::Path::new(&rp);
                if let Some(parent) = p.parent() {
                    if !parent.as_os_str().is_empty() {
                        if let Ok(entries) = std::fs::read_dir(parent) {
                            for entry in entries.flatten() {
                                let _ = entry.metadata();
                            }
                        }
                    }
                }
            });
        }
    }
    Ok(())
}

#[tauri::command]
pub fn tray_popover_get_state(tray_state: State<'_, TrayState>) -> Result<Option<TrayPopoverEmit>, String> {
    let guard = tray_state
        .inner
        .lock()
        .map_err(|_| "tray state mutex poisoned".to_string())?;
    Ok(guard.last_popover_emit.clone())
}

#[tauri::command]
pub fn tray_popover_get_ui_theme() -> String {
    tray_popover_ui_theme_from_prefs()
}

/// Bring the main window forward (tray popover context menu — same intent as the native tray “Show” item).
#[tauri::command]
pub fn show_main_window(app: AppHandle<Wry>) -> Result<(), String> {
    let Some(w) = app.get_webview_window("main") else {
        return Ok(());
    };
    w.show().map_err(|e| e.to_string())?;
    w.unminimize().map_err(|e| e.to_string())?;
    w.set_focus().map_err(|e| e.to_string())?;
    Ok(())
}

/// Hide the tray popover. Invoked from the main window (Escape keybind in `ipc.js`) so the user
/// can dismiss the popover from any focused window — `tray-popover.js`'s own `document.keydown`
/// Escape listener only fires when the popover webview itself has keyboard focus, which doesn't
/// happen if the popover was shown with `focus: false` and the user never clicked into it.
#[tauri::command]
pub fn tray_popover_hide(app: AppHandle<Wry>) -> Result<(), String> {
    if let Some(win) = app.get_webview_window("tray-popover") {
        let _ = win.hide();
    }
    Ok(())
}

static TRAY_POLL_ACTIVE: AtomicBool = AtomicBool::new(false);
/// Host-side poll interval — 500 ms matches the popover UI's expected cadence and is cheap since the
/// audio-engine stdin/stdout JSON request is just a few bytes.
const TRAY_POLL_MS: u64 = 500;

fn fmt_tray_time(sec: f64) -> String {
    let s = sec.max(0.0);
    let m = (s / 60.0) as u64;
    let r = (s as u64) % 60;
    format!("{}:{:02}", m, r)
}

fn truncate_tray_title(s: &str) -> String {
    const MAX: usize = 44;
    let t = s.trim();
    if t.chars().count() <= MAX {
        return t.to_string();
    }
    let mut out: String = t.chars().take(MAX.saturating_sub(1)).collect();
    out.push('…');
    out
}

/// Background thread that polls `audio-engine` `playback_status` and pushes fresh elapsed / total /
/// paused state to the **tray icon** and the **tray-popover** WebView, regardless of JS timer
/// throttling. The JS side (`update_tray_now_playing` in `audio.js`) still owns the **title** and
/// **subtitle** — those come from DOM state that Rust cannot see — but this thread keeps the
/// **elapsed / total / playing** fields live when the main window is unfocused (on macOS the rAF
/// loop and `setInterval` both pause behind `isUiIdleHeavyCpu`, leaving the tray frozen).
///
/// The thread is **idempotent** (guarded by `TRAY_POLL_ACTIVE`) and runs for the lifetime of the
/// app. On each tick:
///  1. Poll `playback_status` from audio-engine.
///  2. If `loaded != true`, skip (HTML5 / reverse playback does not reach the engine poll; the JS
///     `timeupdate` + keepalive paths handle those).
///  3. Merge fresh position / duration / paused into the last JS-reported `TrayPopoverEmit`.
///  4. Update `tray.set_title` (macOS) + `tray.set_tooltip` and emit `tray-popover-state`.
pub fn start_tray_host_poll(app: AppHandle<Wry>) {
    if TRAY_POLL_ACTIVE.swap(true, Ordering::SeqCst) {
        return;
    }
    thread::spawn(move || {
        while TRAY_POLL_ACTIVE.load(Ordering::SeqCst) {
            thread::sleep(Duration::from_millis(TRAY_POLL_MS));
            if !TRAY_POLL_ACTIVE.load(Ordering::SeqCst) {
                break;
            }
            /* Short-circuit BEFORE touching the audio-engine — no point spawning the child process
             * or locking its stdin mutex until JS has reported a non-idle track. */
            let Some(tray_state) = app.try_state::<TrayState>() else {
                continue;
            };
            {
                let guard = match tray_state.inner.lock() {
                    Ok(g) => g,
                    Err(_) => continue,
                };
                match guard.last_popover_emit.as_ref() {
                    Some(e) if !e.idle => {}
                    _ => continue,
                }
            }
            let v = match crate::audio_engine::spawn_audio_engine_request(
                &serde_json::json!({ "cmd": "playback_status" }),
            ) {
                Ok(v) => v,
                Err(_) => continue,
            };
            let loaded = v.get("loaded").and_then(|x| x.as_bool()).unwrap_or(false);
            if !loaded {
                continue;
            }
            let pos = v
                .get("position_sec")
                .and_then(|x| x.as_f64())
                .unwrap_or(0.0);
            let dur = v
                .get("duration_sec")
                .and_then(|x| x.as_f64())
                .unwrap_or(0.0);
            let paused = v.get("paused").and_then(|x| x.as_bool()).unwrap_or(false);
            let (tray, new_emit, title_bar, tooltip) = {
                let mut guard = match tray_state.inner.lock() {
                    Ok(g) => g,
                    Err(_) => continue,
                };
                let Some(tray) = guard.tray.clone() else {
                    continue;
                };
                let Some(last) = guard.last_popover_emit.clone() else {
                    continue;
                };
                /* Do not overwrite an explicit idle state — JS has torn down playback; the thread
                 * must not resurrect a fake "still playing" state from a stale position read. */
                if last.idle {
                    continue;
                }
                /* If the engine reports a fresh duration, prefer it; otherwise hold the last value so
                 * the popover does not flash "—" mid-track. */
                let total_sec = if dur > 0.0 { Some(dur) } else { last.total_sec };
                let new_emit = TrayPopoverEmit {
                    idle: false,
                    title: last.title.clone(),
                    subtitle: last.subtitle.clone(),
                    reveal_path: last.reveal_path.clone(),
                    elapsed_sec: pos,
                    total_sec,
                    playing: !paused,
                    playback_speed: last.playback_speed,
                    volume_pct: last.volume_pct,
                    idle_hint: None,
                    ui_theme: last.ui_theme.clone(),
                    appearance: last.appearance.clone(),
                };
                guard.last_popover_emit = Some(new_emit.clone());

                let total_str = match total_sec {
                    Some(t) if t > 0.0 => fmt_tray_time(t),
                    _ => "—".to_string(),
                };
                let elapsed_str = fmt_tray_time(pos);
                /* Menu-bar title is track name only — elapsed/total stay in the popover + tooltip. */
                let title_bar = truncate_tray_title(&new_emit.title);
                let status = if new_emit.playing {
                    "Playing"
                } else {
                    "Paused"
                };
                let tooltip = if new_emit.title.is_empty() {
                    format!("{} / {} • {}", elapsed_str, total_str, status)
                } else {
                    format!(
                        "{} — {} / {} • {}",
                        new_emit.title, elapsed_str, total_str, status
                    )
                };
                (tray, new_emit, title_bar, tooltip)
            };

            /* Status-item icon only — title stays unset (see `update_tray_now_playing`). */
            let _ = title_bar;
            let _ = tray.set_tooltip(Some(tooltip.as_str()));
            emit_tray_popover_state(&app, &new_emit);
        }
        TRAY_POLL_ACTIVE.store(false, Ordering::SeqCst);
    });
}