path: root/naviel.el

;;; naviel.el --- Navidrome music player client for Emacs -*- lexical-binding: t -*-

;; Author: CdatGoose
;; Version: 0.4
;; Package-Requires: ((emacs "29.1") (transient "0.5.0"))
;; Keywords: multimedia, music

;;; Commentary:
;; A Navidrome client for Emacs using the Subsonic API.
;; Plays music via mpv (must be installed on PATH).
;;
;; Layout: Two persistent buffers:
;;   *Naviel Player*  — now-playing info, synced lyrics (prev/current/next)
;;   *Naviel Browser* — artist/album/song tree with TAB expand, cover art
;;
;; Quick setup:
;;   1. ~/.authinfo:  machine your-host login USER password PASS
;;   2. (setq naviel-url "http://host:4533")
;;   3. M-x naviel
;;; Code:

(require 'url)
(require 'url-util)
(require 'xml)
(require 'auth-source)
(require 'cl-lib)
(require 'json)
(require 'seq)
(require 'transient)

;;; Customisation 

(defgroup naviel nil "Naviel music client." :group 'multimedia :prefix "naviel-")

(defcustom naviel-url "http://localhost:4533"
  "Base URL of the Navidrome server (no trailing slash)."
  :type 'string :group 'naviel)
(defcustom naviel-username nil
  "Username. If nil, looked up from ~/.authinfo."
  :type '(choice (const nil) string) :group 'naviel)
(defcustom naviel-password nil
  "Password. If nil, looked up from ~/.authinfo."
  :type '(choice (const nil) string) :group 'naviel)
(defcustom naviel-client-name "naviel.el"
  "Client identifier sent with every API request."
  :type 'string :group 'naviel)
(defcustom naviel-api-version "1.16.1"
  "Subsonic API version declared in requests."
  :type 'string :group 'naviel)
(defcustom naviel-mpv-executable "mpv"
  "Path to the mpv executable."
  :type 'string :group 'naviel)
(defcustom naviel-volume-step 5
  "Volume increment/decrement step (0-100)."
  :type 'integer :group 'naviel)
(defcustom naviel-seek-step 10
  "Seek step in seconds for the [ / ] keys."
  :type 'integer :group 'naviel)
(defcustom naviel-position-poll-interval 0.5
  "Seconds between IPC polls for playback position."
  :type 'float :group 'naviel)
(defcustom naviel-album-list-size 30
  "Default number of albums fetched for recently-added/played views."
  :type 'integer :group 'naviel)
(defcustom naviel-genre-song-limit 200
  "Maximum songs fetched when browsing a genre."
  :type 'integer :group 'naviel)
(defcustom naviel-cover-art-width 300
  "Pixel width requested when fetching cover art."
  :type 'integer :group 'naviel)
(defcustom naviel-cover-art-display t
  "Non-nil to attempt inline cover art display when available."
  :type 'boolean :group 'naviel)
(defcustom naviel-player-cover-size 180
  "Pixel size for cover art in the player buffer."
  :type 'integer :group 'naviel)
(defcustom naviel-player-visualizer t
  "Non-nil to show a CAVA-like visualizer in the player buffer."
  :type 'boolean :group 'naviel)
(defcustom naviel-player-visualizer-bars 32
  "Maximum number of bars shown in the player buffer visualizer."
  :type 'integer :group 'naviel)
(defcustom naviel-player-visualizer-style 'default
  "Style used by the player buffer visualizer."
  :type '(choice (const :tag "Default" default)
                 (const :tag "Compact" compact)
                 (const :tag "Wide" wide)
                 (const :tag "Monochrome" monochrome)
                 (const :tag "High contrast" high-contrast))
  :group 'naviel)
(defcustom naviel-player-visualizer-backend 'auto
  "Visualizer backend.
`auto' uses CAVA when available and falls back to the built-in animation.
`cava' only uses CAVA when it can be started.  `simulated' never starts CAVA."
  :type '(choice (const auto) (const simulated) (const cava))
  :group 'naviel)
(defcustom naviel-cava-executable "cava"
  "Path to the cava executable used by the player visualizer."
  :type 'string :group 'naviel)
(defcustom naviel-player-queue-preview-size 3
  "Number of upcoming songs shown in the player buffer."
  :type 'integer :group 'naviel)
(defcustom naviel-player-dashboard-width 120
  "Maximum content width for the single-window player dashboard."
  :type 'integer :group 'naviel)
(defcustom naviel-player-progress-width 100
  "Maximum width of the player progress bar."
  :type 'integer :group 'naviel)
(defcustom naviel-browser-cover-size 80
  "Pixel size for album cover art in the browser expand view."
  :type 'integer :group 'naviel)

;;; Faces

(defface naviel-header-face
  '((t :inherit bold :height 1.1)) "Main header.")
(defface naviel-separator-face
  '((t :inherit shadow)) "Separator lines.")
(defface naviel-artist-face
  '((t :inherit font-lock-function-name-face :weight semi-bold)) "Artist names.")
(defface naviel-album-face
  '((t :inherit font-lock-string-face)) "Album names.")
(defface naviel-song-title-face
  '((t :inherit default)) "Song titles.")
(defface naviel-song-meta-face
  '((t :inherit shadow)) "Song metadata.")
(defface naviel-track-num-face
  '((t :inherit shadow)) "Track numbers.")
(defface naviel-year-face
  '((t :inherit shadow)) "Album years.")
(defface naviel-now-playing-face
  '((t :inherit success :weight bold)) "Now-playing text.")
(defface naviel-paused-face
  '((t :inherit warning :weight bold)) "Paused indicator.")
(defface naviel-footer-face
  '((t :inherit shadow :height 0.85)) "Footer hints.")
(defface naviel-count-face
  '((t :inherit shadow)) "Item counts.")
(defface naviel-breadcrumb-face
  '((t :inherit font-lock-comment-face)) "Breadcrumb trail.")
(defface naviel-repeat-face
  '((t :inherit font-lock-keyword-face)) "Repeat mode.")
(defface naviel-error-face
  '((t :inherit error)) "In-buffer errors.")
(defface naviel-position-face
  '((t :inherit shadow)) "Playback position.")
(defface naviel-progress-fill-face
  '((t :inherit success)) "Progress bar fill.")
(defface naviel-progress-empty-face
  '((t :inherit shadow)) "Progress bar empty.")
(defface naviel-visualizer-low-face
  '((t :inherit shadow)) "Low bars in the player visualizer.")
(defface naviel-visualizer-mid-face
  '((t :inherit font-lock-string-face)) "Mid bars in the player visualizer.")
(defface naviel-visualizer-high-face
  '((t :inherit success :weight bold)) "High bars in the player visualizer.")
(defface naviel-starred-face
  '((t :inherit font-lock-warning-face)) "Starred indicator.")
(defface naviel-radio-face
  '((t :inherit font-lock-constant-face)) "Internet radio stations.")
(defface naviel-lyrics-current-face
  '((t :inherit default :weight bold :height 1.05)) "Current synced lyric line.")
(defface naviel-lyrics-context-face
  '((t :inherit shadow :height 0.9)) "Adjacent lyric lines (prev/next).")
(defface naviel-lyrics-nosync-face
  '((t :inherit shadow :slant italic)) "Unsynced / static lyrics.")
(defface naviel-expand-indicator-face
  '((t :inherit font-lock-builtin-face)) "Album expand triangle.")
(defface naviel-inline-song-face
  '((t :inherit naviel-song-title-face)) "Songs in expanded album view.")

;;; Repeat mode

(defvar naviel-repeat-mode 'off
  "Playback repeat mode: `off', `one', or `album'.")

(defun naviel-toggle-repeat ()
  "Cycle repeat mode: off → one → album → off."
  (interactive)
  (setq naviel-repeat-mode
        (pcase naviel-repeat-mode ('off 'one) ('one 'album) (_ 'off)))
  (naviel--player-render)
  (message "Repeat: %s" (naviel--repeat-label)))

(defun naviel--repeat-label ()
  (pcase naviel-repeat-mode ('one "one") ('album "all") (_ "off")))

(defun naviel-toggle-visualizer ()
  "Toggle the player buffer visualizer."
  (interactive)
  (setq naviel-player-visualizer (not naviel-player-visualizer))
  (if naviel-player-visualizer
      (naviel--maybe-start-cava)
    (naviel--stop-cava))
  (naviel--player-render)
  (message "Visualizer: %s" (if naviel-player-visualizer "on" "off")))

(defun naviel-cycle-visualizer-style ()
  "Cycle player visualizer styles."
  (interactive)
  (setq naviel-player-visualizer-style
        (pcase naviel-player-visualizer-style
          ('default 'compact)
          ('compact 'wide)
          ('wide 'monochrome)
          ('monochrome 'high-contrast)
          (_ 'default)))
  (naviel--player-render)
  (message "Visualizer style: %s" naviel-player-visualizer-style))

;;; Internal state

(defvar naviel--process        nil)
(defvar naviel--ipc-process    nil)
(defvar naviel--ipc-buffer     "")
(defvar naviel--ipc-request-id 0)
(defvar naviel--ipc-callbacks  nil)
(defvar naviel--position-timer nil)
(defvar naviel--elapsed        nil)
(defvar naviel--duration       nil)
(defvar naviel--queue         '())
(defvar naviel--queue-index    0)
(defvar naviel--volume         80)
(defvar naviel--paused         nil)
(defvar naviel--current-song   nil)
(defvar naviel--browser-stack '())
(defvar naviel--current-view   nil)
(defvar naviel--mode-line-timer nil)
(defvar naviel--cover-cache (make-hash-table :test 'equal))
(defvar naviel--cava-process nil)
(defvar naviel--cava-buffer "")
(defvar naviel--cava-config-file nil)
(defvar naviel--cava-levels nil)
(defvar naviel--cava-bars nil)

;; Star cache
(defvar naviel--starred-ids (make-hash-table :test 'equal))

;; Synced lyrics state
(defvar naviel--lrc-lines      nil  "List of (seconds . text) cons cells, sorted by time.")
(defvar naviel--lrc-raw        nil  "Raw unsynchronised lyrics string, or nil.")
(defvar naviel--lrc-current-idx -1  "Index of last active lyric line.")

;; Browser inline-expand state: hash of album-id -> (songs . open-p)
(defvar naviel--expanded-albums (make-hash-table :test 'equal))

;;; Buffer accessors

(defun naviel--player-buffer  () (get-buffer-create "*Naviel Player*"))
(defun naviel--browser-buffer () (get-buffer-create "*Naviel Browser*"))

;;; Window layout

(defun naviel--ensure-layout ()
  "Show player on the left and browser on the right."
  (delete-other-windows)
  (let ((player-win  (selected-window))
        (browser-win (split-window-right)))
    (set-window-buffer player-win  (naviel--player-buffer))
    (set-window-buffer browser-win (naviel--browser-buffer))
    (select-window browser-win)))

;;; Authentication

(defun naviel--credentials ()
  (let* ((host (url-host (url-generic-parse-url naviel-url)))
         (user (or naviel-username
                   (plist-get (car (auth-source-search :host host :require '(:user))) :user)))
         (pass (or naviel-password
                   (let* ((entry (car (auth-source-search :host host :require '(:secret))))
                          (s (plist-get entry :secret)))
                     (when s (if (functionp s) (funcall s) s))))))
    (unless (and user pass)
      (error "naviel: no credentials for %s – set naviel-username/naviel-password or ~/.authinfo" host))
    (cons user pass)))

(defun naviel--auth-params ()
  (let* ((creds (naviel--credentials))
         (salt  (naviel--random-salt 10))
         (token (md5 (concat (cdr creds) salt))))
    `(("u" . ,(car creds)) ("t" . ,token) ("s" . ,salt)
      ("v" . ,naviel-api-version) ("c" . ,naviel-client-name) ("f" . "xml"))))

(defun naviel--random-salt (len)
  (let ((chars "abcdefghijklmnopqrstuvwxyz0123456789") (r ""))
    (dotimes (_ len r)
      (setq r (concat r (string (aref chars (random (length chars)))))))))

;;; Async HTTP / API

(defun naviel--build-url (endpoint params)
  (let* ((all (append (naviel--auth-params) params))
         (q (mapconcat
             (lambda (p) (concat (url-hexify-string (car p)) "=" (url-hexify-string (cdr p))))
             all "&")))
    (format "%s/rest/%s?%s" naviel-url endpoint q)))

(defun naviel--request-async (endpoint params parse-fn callback)
  (let ((url (naviel--build-url endpoint params)))
    (url-retrieve
     url
     (lambda (status)
       (if (plist-get status :error)
           (progn (ignore-errors (kill-buffer (current-buffer)))
                  (naviel--show-error (format "Could not reach %s – is the server running?" naviel-url))
                  (funcall callback nil))
         (condition-case err
             (progn
               (goto-char (point-min))
               (re-search-forward "\r?\n\r?\n" nil t)
               (set-buffer-multibyte t)
               (decode-coding-region (point) (point-max) 'utf-8)
               (let* ((xml      (xml-parse-region (point) (point-max)))
                      (response (naviel--check-status xml))
                      (result   (funcall parse-fn response)))
                 (kill-buffer (current-buffer))
                 (funcall callback result)))
           (error
            (ignore-errors (kill-buffer (current-buffer)))
            (naviel--show-error (error-message-string err))
            (funcall callback nil)))))
     nil t)))

(defun naviel--check-status (xml)
  (let* ((root     (car xml))
         (response (if (eq (xml-node-name root) 'subsonic-response) root
                     (car (xml-get-children root 'subsonic-response))))
         (status   (xml-get-attribute-or-nil response 'status)))
    (unless response (error "naviel: unexpected XML response structure"))
    (when (string= status "failed")
      (let* ((err  (car (xml-get-children response 'error)))
             (code (xml-get-attribute err 'code))
             (msg  (xml-get-attribute err 'message)))
        (error "naviel API error %s: %s" code msg)))
    response))

(defun naviel--get-child (r tag) (car (xml-get-children r tag)))
(defun naviel--attr (node attr)  (xml-get-attribute node attr))

;;; Error display

(defun naviel--show-error (msg)
  (with-current-buffer (naviel--browser-buffer)
    (naviel-browser-mode)
    (let ((inhibit-read-only t))
      (erase-buffer)
      (insert (propertize "\n  ✗  naviel error\n\n" 'face 'naviel-error-face))
      (insert (propertize (format "  %s\n\n" msg) 'face 'naviel-error-face))
      (insert (propertize "  g  retry    q  quit\n" 'face 'naviel-footer-face))
      (goto-char (point-min))))
  (pop-to-buffer (naviel--browser-buffer)))

;;; Stream / cover-art URLs

(defun naviel--stream-url (song-id)
  (naviel--build-url "stream" `(("id" . ,song-id))))

(defun naviel--cover-art-url (cover-id &optional size)
  (naviel--build-url "getCoverArt"
                     `(("id" . ,cover-id)
                       ("size" . ,(number-to-string (or size naviel-cover-art-width))))))

;;; Cover art insertion

(defun naviel--fetch-and-insert-cover (cover-id buffer marker-regex size)
  "Fetch COVER-ID and insert it after MARKER-REGEX in BUFFER."
  (when (and naviel-cover-art-display cover-id (not (string= cover-id "")))
    (let ((url (naviel--cover-art-url cover-id size))
          (tmp (make-temp-file "naviel-art" nil ".jpg")))
      (url-retrieve
       url
       (lambda (status)
         (unless (plist-get status :error)
           (goto-char (point-min))
           (re-search-forward "\r?\n\r?\n" nil t)
           (let ((data (buffer-substring-no-properties (point) (point-max))))
             (ignore-errors (kill-buffer (current-buffer)))
             (with-temp-file tmp (set-buffer-multibyte nil) (insert data))
             (naviel--do-insert-image tmp buffer marker-regex size)))
         (ignore-errors (kill-buffer (current-buffer))))
       nil t))))

(defun naviel--cover-cache-key (cover-id size)
  (format "%s:%s" cover-id size))

(defun naviel--fetch-cover-to-cache (cover-id size callback)
  "Fetch COVER-ID at SIZE, cache it, then call CALLBACK with the image path."
  (when (and naviel-cover-art-display cover-id (not (string= cover-id "")))
    (let* ((key (naviel--cover-cache-key cover-id size))
           (cached (gethash key naviel--cover-cache)))
      (if (and cached (file-readable-p cached))
          (funcall callback cached)
        (let ((url (naviel--cover-art-url cover-id size))
              (tmp (make-temp-file "naviel-art" nil ".jpg")))
          (url-retrieve
           url
           (lambda (status)
             (unwind-protect
                 (unless (plist-get status :error)
                   (goto-char (point-min))
                   (re-search-forward "\r?\n\r?\n" nil t)
                   (let ((data (buffer-substring-no-properties (point) (point-max))))
                     (with-temp-file tmp
                       (set-buffer-multibyte nil)
                       (insert data))
                     (puthash key tmp naviel--cover-cache)
                     (funcall callback tmp)))
               (ignore-errors (kill-buffer (current-buffer)))))
           nil t))))))

(defun naviel--do-insert-image (path buffer marker-regex size)
  "Insert image at PATH into BUFFER after first match of MARKER-REGEX."
  (when (and (display-graphic-p)
             (image-type-available-p 'jpeg)
             (get-buffer buffer))
    (with-current-buffer buffer
      (let ((inhibit-read-only t))
        (save-excursion
          (goto-char (point-min))
          (when (re-search-forward marker-regex nil t)
            (forward-line 1)
            (let ((img (create-image path 'jpeg nil :width size)))
              (insert "  ")
              (insert-image img)
              (insert "\n"))))))))

(defun naviel--player-insert-cover (cover-id)
  "Insert cached player cover art for COVER-ID, fetching asynchronously if needed."
  (when (and naviel-cover-art-display cover-id (not (string= cover-id ""))
             (display-graphic-p) (image-type-available-p 'jpeg))
    (let* ((size (naviel--player-cover-display-size))
           (key (naviel--cover-cache-key cover-id size))
           (cached (gethash key naviel--cover-cache)))
      (cond
       ((and cached (file-readable-p cached))
        (insert "  ")
        (insert-image (create-image cached 'jpeg nil :width size))
        (insert "\n\n"))
       (t
        (insert (propertize "  [cover loading...]\n\n" 'face 'naviel-separator-face))
        (naviel--fetch-cover-to-cache
         cover-id size
         (lambda (_path) (naviel--player-render))))))))

(defun naviel--player-cover-path (cover-id)
  "Return cached player cover path for COVER-ID, fetching it if missing."
  (when (and naviel-cover-art-display cover-id (not (string= cover-id ""))
             (display-graphic-p) (image-type-available-p 'jpeg))
    (let* ((size (naviel--player-cover-display-size))
           (key (naviel--cover-cache-key cover-id size))
           (cached (gethash key naviel--cover-cache)))
      (if (and cached (file-readable-p cached))
          cached
        (naviel--fetch-cover-to-cache
         cover-id size
         (lambda (_path) (naviel--player-render)))
        nil))))

;;; mpv IPC

(defun naviel--ipc-socket-path ()
  (expand-file-name "naviel-mpv.sock" temporary-file-directory))

(defun naviel--ipc-connect ()
  (let ((sock  (naviel--ipc-socket-path))
        (limit (+ (float-time) 1.5)))
    (while (and (not (file-exists-p sock)) (< (float-time) limit))
      (sleep-for 0.05))
    (when (file-exists-p sock)
      (condition-case err
          (setq naviel--ipc-process
                (make-network-process
                 :name "naviel-ipc" :family 'local :service sock
                 :filter #'naviel--ipc-filter :sentinel #'naviel--ipc-sentinel
                 :coding 'utf-8-unix)
                naviel--ipc-buffer "")
        (error (message "naviel: IPC connect failed – %s" (error-message-string err)))))))

(defun naviel--ipc-filter (_proc string)
  (setq naviel--ipc-buffer (concat naviel--ipc-buffer string))
  (let ((start 0))
    (while (string-match "\n" naviel--ipc-buffer start)
      (let* ((end  (match-end 0))
             (line (substring naviel--ipc-buffer start (1- end))))
        (setq start end)
        (naviel--ipc-dispatch line)))
    (setq naviel--ipc-buffer (substring naviel--ipc-buffer start))))

(defun naviel--ipc-sentinel (proc event)
  (when (and (string-match-p "deleted\\|closed\\|failed" event)
             (eq proc naviel--ipc-process))
    (setq naviel--ipc-process nil)))

(defun naviel--ipc-dispatch (json-line)
  (condition-case nil
      (let* ((obj    (json-read-from-string json-line))
             (event  (cdr (assq 'event      obj)))
             (req-id (cdr (assq 'request_id obj)))
             (data   (cdr (assq 'data       obj)))
             (err    (cdr (assq 'error      obj))))
        (when req-id
          (let ((cb (cdr (assq req-id naviel--ipc-callbacks))))
            (when cb
              (setq naviel--ipc-callbacks (assq-delete-all req-id naviel--ipc-callbacks))
              (when (or (null err) (string= err "success"))
                (funcall cb data)))))
        (when event (naviel--ipc-handle-event event)))
    (error nil)))

(defun naviel--ipc-handle-event (event)
  (cond
   ((string= event "end-file") (naviel--next-in-queue))
   ((string= event "pause")
    (setq naviel--paused t)
    (naviel--stop-cava)
    (naviel--player-render))
   ((string= event "unpause")
    (setq naviel--paused nil)
    (naviel--maybe-start-cava)
    (naviel--player-render))))

(defun naviel--ipc-send (command &optional callback)
  (when (and naviel--ipc-process (process-live-p naviel--ipc-process))
    (cl-incf naviel--ipc-request-id)
    (let* ((id   naviel--ipc-request-id)
           (msg  (append `(("command" . ,(vconcat command)))
                         (when callback `(("request_id" . ,id)))))
           (json (concat (json-encode msg) "\n")))
      (when callback (push (cons id callback) naviel--ipc-callbacks))
      (condition-case err
          (process-send-string naviel--ipc-process json)
        (error (message "naviel IPC send: %s" (error-message-string err)))))))

;;; CAVA visualizer backend

(defun naviel--cava-available-p ()
  (and (memq naviel-player-visualizer-backend '(auto cava))
       (executable-find naviel-cava-executable)))

(defun naviel--cava-desired-bars ()
  (let* ((width (naviel--player-window-width))
         (glyph-width (if (eq naviel-player-visualizer-style 'wide) 2 1)))
    (max 8 (min 160 (/ (max 20 (- width 4)) glyph-width)))))

(defun naviel--cava-config (bars)
  (let ((bars (max 8 bars)))
    (mapconcat
     #'identity
     `("[general]"
       ,(format "bars = %d" bars)
       "framerate = 20"
       ""
       "[input]"
       "method = pulse"
       "source = auto"
       ""
       "[output]"
       "method = raw"
       "raw_target = /dev/stdout"
       "data_format = ascii"
       "ascii_max_range = 7"
       "channels = mono")
     "\n")))

(defun naviel--maybe-start-cava ()
  "Start CAVA for the visualizer when configured and available."
  (when (and naviel-player-visualizer
             (not naviel--paused)
             (naviel--cava-available-p)
             (let ((desired-bars (naviel--cava-desired-bars)))
               (if (and naviel--cava-process
                        (process-live-p naviel--cava-process))
                   (not (equal desired-bars naviel--cava-bars))
                 t)))
    (condition-case err
        (let* ((bars (naviel--cava-desired-bars))
               (config (make-temp-file "naviel-cava" nil ".conf")))
          (naviel--stop-cava)
          (with-temp-file config (insert (naviel--cava-config bars)))
          (setq naviel--cava-config-file config
                naviel--cava-bars bars
                naviel--cava-buffer ""
                naviel--cava-levels nil
                naviel--cava-process
                (start-process "naviel-cava" nil naviel-cava-executable "-p" config))
          (set-process-filter naviel--cava-process #'naviel--cava-filter)
          (set-process-sentinel naviel--cava-process #'naviel--cava-sentinel))
      (error
       (setq naviel--cava-process nil
             naviel--cava-levels nil)
       (when (eq naviel-player-visualizer-backend 'cava)
         (message "naviel: could not start cava: %s" (error-message-string err)))))))

(defun naviel--stop-cava ()
  "Stop the optional CAVA visualizer process."
  (when (and naviel--cava-process (process-live-p naviel--cava-process))
    (delete-process naviel--cava-process))
  (setq naviel--cava-process nil
        naviel--cava-buffer ""
        naviel--cava-levels nil
        naviel--cava-bars nil)
  (when (and naviel--cava-config-file (file-exists-p naviel--cava-config-file))
    (ignore-errors (delete-file naviel--cava-config-file)))
  (setq naviel--cava-config-file nil))

(defun naviel--cava-filter (_proc string)
  (setq naviel--cava-buffer (concat naviel--cava-buffer string))
  (let ((start 0))
    (while (string-match "\n" naviel--cava-buffer start)
      (let* ((end (match-beginning 0))
             (line (substring naviel--cava-buffer start end)))
        (setq start (1+ end))
        (naviel--cava-handle-line line)))
    (setq naviel--cava-buffer (substring naviel--cava-buffer start))))

(defun naviel--cava-handle-line (line)
  (let (levels)
    (dolist (chunk (split-string line "[;[:space:]]+" t))
      (let ((n (string-to-number chunk)))
        (push (max 0 (min 7 n)) levels)))
    (when levels
      (setq naviel--cava-levels (nreverse levels))
      (naviel--player-render))))

(defun naviel--cava-sentinel (proc _event)
  (when (eq proc naviel--cava-process)
    (setq naviel--cava-process nil
          naviel--cava-buffer ""
          naviel--cava-levels nil
          naviel--cava-bars nil)
    (when (and naviel--cava-config-file (file-exists-p naviel--cava-config-file))
      (ignore-errors (delete-file naviel--cava-config-file)))
    (setq naviel--cava-config-file nil)))

;;; Playback position polling

(defun naviel--start-position-timer ()
  (naviel--stop-position-timer)
  (setq naviel--position-timer
        (run-with-timer naviel-position-poll-interval
                        naviel-position-poll-interval
                        #'naviel--poll-position)))

(defun naviel--stop-position-timer ()
  (when naviel--position-timer
    (cancel-timer naviel--position-timer)
    (setq naviel--position-timer nil)))

(defun naviel--poll-position ()
  (when (and naviel--ipc-process (process-live-p naviel--ipc-process))
    (naviel--ipc-send '("get_property" "time-pos")
                      (lambda (v)
                        (setq naviel--elapsed (and (numberp v) v))
                        (naviel--player-render)))
    (naviel--ipc-send '("get_property" "duration")
                      (lambda (v)
                        (setq naviel--duration (and (numberp v) v))))))

;;; mpv process management

(defun naviel--stop ()
  (naviel--stop-position-timer)
  (naviel--stop-cava)
  (when (and naviel--ipc-process (process-live-p naviel--ipc-process))
    (delete-process naviel--ipc-process))
  (setq naviel--ipc-process nil naviel--ipc-buffer "")
  (when (and naviel--process (process-live-p naviel--process))
    (delete-process naviel--process))
  (let ((sock (naviel--ipc-socket-path)))
    (when (file-exists-p sock) (ignore-errors (delete-file sock))))
  (setq naviel--process nil naviel--paused nil naviel--current-song nil
        naviel--elapsed nil naviel--duration nil
        naviel--lrc-lines nil naviel--lrc-raw nil naviel--lrc-current-idx -1)
  (naviel--player-render)
  (naviel--browser-rerender-current-view))

(defun naviel--play-url (url song-info)
  (naviel--stop)
  (setq naviel--current-song song-info naviel--paused nil
        naviel--elapsed nil naviel--duration nil
        naviel--lrc-lines nil naviel--lrc-raw nil naviel--lrc-current-idx -1)
  (let* ((sock (naviel--ipc-socket-path))
         (proc (start-process "naviel-mpv" nil naviel-mpv-executable
                              "--no-video" "--quiet"
                              (format "--volume=%d" naviel--volume)
                              (format "--input-ipc-server=%s" sock)
                              url)))
    (setq naviel--process proc))
  (run-with-timer 0.3 nil #'naviel--ipc-connect)
  (run-with-timer 0.6 nil #'naviel--start-position-timer)
  (run-with-timer 0.8 nil #'naviel--maybe-start-cava)
  ;; Fetch synced lyrics from lrclib
  (naviel--lrclib-fetch song-info)
  (naviel--player-render)
  (message "▶  %s  –  %s"
           (plist-get song-info :title)
           (plist-get song-info :artist)))

(defun naviel--toggle-pause ()
  (interactive)
  (if (and naviel--process (process-live-p naviel--process))
      (naviel--ipc-send '("cycle" "pause"))
    (message "naviel: nothing is playing")))

(defun naviel--seek (seconds)
  (if (and naviel--process (process-live-p naviel--process))
      (naviel--ipc-send `("seek" ,seconds "relative"))
    (message "naviel: nothing is playing")))

(defun naviel-seek-forward  () (interactive) (naviel--seek    naviel-seek-step))
(defun naviel-seek-backward () (interactive) (naviel--seek (- naviel-seek-step)))

;;; Queue

(defun naviel--play-queue-index (idx)
  (setq naviel--queue-index idx)
  (let* ((song (nth idx naviel--queue))
         (url  (naviel--stream-url (plist-get song :id))))
    (naviel--play-url url song)
    (naviel--browser-rerender-current-view)))

(defun naviel--next-in-queue ()
  (interactive)
  (pcase naviel-repeat-mode
    ('one   (naviel--play-queue-index naviel--queue-index))
    ('album (naviel--play-queue-index
             (mod (1+ naviel--queue-index) (max 1 (length naviel--queue)))))
    (_ (let ((next (1+ naviel--queue-index)))
         (if (< next (length naviel--queue))
             (naviel--play-queue-index next)
           (naviel--stop)
           (message "naviel: end of queue"))))))

(defun naviel--prev-in-queue ()
  (interactive)
  (let ((prev (1- naviel--queue-index)))
    (if (>= prev 0) (naviel--play-queue-index prev)
      (message "naviel: at start of queue"))))

(defun naviel--volume-up ()
  (interactive)
  (setq naviel--volume (min 100 (+ naviel--volume naviel-volume-step)))
  (naviel--ipc-send `("set_property" "volume" ,naviel--volume))
  (naviel--player-render)
  (message "Volume: %d%%" naviel--volume))

(defun naviel--volume-down ()
  (interactive)
  (setq naviel--volume (max 0 (- naviel--volume naviel-volume-step)))
  (naviel--ipc-send `("set_property" "volume" ,naviel--volume))
  (naviel--player-render)
  (message "Volume: %d%%" naviel--volume))

(defun naviel--append-songs-to-queue (songs label)
  (let ((was-empty (null naviel--queue)))
    (setq naviel--queue (append naviel--queue songs))
    (when was-empty (setq naviel--queue-index 0))
    (naviel--browser-rerender-current-view)
    (message "naviel: +%d from \"%s\"  (queue: %d)"
             (length songs) label (length naviel--queue))))

(defun naviel-queue-shuffle ()
  (interactive)
  (when (null naviel--queue) (user-error "Queue is empty"))
  (let* ((vec (vconcat naviel--queue)) (len (length vec)))
    (dotimes (i (1- len))
      (let* ((j (+ i (random (- len i)))) (tmp (aref vec i)))
        (aset vec i (aref vec j)) (aset vec j tmp)))
    (setq naviel--queue (append vec nil)))
  (when naviel--current-song
    (let* ((cur-id (plist-get naviel--current-song :id))
           (pos (cl-position-if (lambda (s) (equal (plist-get s :id) cur-id))
                                naviel--queue)))
      (when pos
        (let ((cur (nth pos naviel--queue)))
          (setq naviel--queue
                (cons cur (append (seq-take naviel--queue pos)
                                  (seq-drop naviel--queue (1+ pos)))))
          (setq naviel--queue-index 0)))))
  (naviel--browser-rerender-current-view)
  (message "naviel: shuffled (%d tracks)" (length naviel--queue)))

;;; lrclib.net synced lyrics

(defun naviel--lrclib-fetch (song)
  "Fetch synced (or plain) lyrics from lrclib.net for SONG plist."
  (let* ((title    (or (plist-get song :title)  ""))
         (artist   (or (plist-get song :artist) ""))
         (album    (or (plist-get song :album)  ""))
         (dur-str  (plist-get song :duration))
         (duration (if (and dur-str (not (string= dur-str "")))
                       (string-to-number dur-str) 0))
         ;; Use the GET endpoint with query params
         (url (concat "https://lrclib.net/api/get?"
                      "track_name="   (url-hexify-string title)
                      "&artist_name=" (url-hexify-string artist)
                      "&album_name="  (url-hexify-string album)
                      (when (> duration 0)
                        (format "&duration=%d" (round duration))))))
    (url-retrieve
     url
     (lambda (status)
       (if (plist-get status :error)
           (ignore-errors (kill-buffer (current-buffer)))
         (condition-case nil
             (progn
               (goto-char (point-min))
               (re-search-forward "\r?\n\r?\n" nil t)
               (set-buffer-multibyte t)
               (decode-coding-region (point) (point-max) 'utf-8)
               (let* ((json-object-type 'alist)
                      (json-array-type  'list)
                      (data (json-read)))
                 (kill-buffer (current-buffer))
                 (naviel--lrclib-handle data)))
           (error (ignore-errors (kill-buffer (current-buffer)))))))
     nil t)))

(defun naviel--lrclib-handle (data)
  "Process lrclib JSON response DATA."
  (let ((synced (cdr (assq 'syncedLyrics data)))
        (plain  (cdr (assq 'plainLyrics  data))))
    (cond
     ((and synced (not (eq synced :null)) (not (string= synced "")))
      (setq naviel--lrc-lines (naviel--parse-lrc synced)
            naviel--lrc-raw   nil
            naviel--lrc-current-idx -1))
     ((and plain (not (eq plain :null)) (not (string= plain "")))
      (setq naviel--lrc-lines nil
            naviel--lrc-raw   plain))
     (t
      (setq naviel--lrc-lines nil naviel--lrc-raw nil)))
    (naviel--player-render)))

(defun naviel--parse-lrc (lrc-string)
  "Parse LRC format string into sorted list of (seconds . text) conses."
  (let (lines)
    (dolist (line (split-string lrc-string "\n"))
      (when (string-match "^\\[\\([0-9]+\\):\\([0-9]+\\(?:\\.[0-9]+\\)?\\)\\]\\(.*\\)$" line)
        (let* ((min  (string-to-number (match-string 1 line)))
               (sec  (string-to-number (match-string 2 line)))
               (text (string-trim (match-string 3 line)))
               (ts   (+ (* min 60) sec)))
          (push (cons ts text) lines))))
    (sort (nreverse lines) (lambda (a b) (< (car a) (car b))))))

(defun naviel--lrc-active-index (elapsed)
  "Return the index of the active lyric line for ELAPSED seconds."
  (when (and naviel--lrc-lines elapsed)
    (let ((idx -1))
      (cl-loop for i from 0 for entry in naviel--lrc-lines
               when (<= (car entry) elapsed)
               do (setq idx i))
      idx)))

;;; Player buffer rendering

(defun naviel--player-buffer-p ()
  (get-buffer "*Naviel Player*"))

(defun naviel--player-window ()
  (get-buffer-window (naviel--player-buffer) t))

(defun naviel--player-window-width ()
  (let ((win (naviel--player-window)))
    (max 40 (- (if win (window-width win) (frame-width)) 2))))

(defun naviel--player-window-height ()
  (let ((win (naviel--player-window)))
    (max 12 (if win (window-height win) (frame-height)))))

(defun naviel--player-single-window-p ()
  "Return non-nil when the player buffer is the only ordinary window."
  (let ((win (naviel--player-window)))
    (and win
         (= 1 (length (window-list (window-frame win) 'no-minibuf))))))

(defun naviel--player-visualizer-height (window-height)
  "Return visualizer row count for WINDOW-HEIGHT."
  (cond
   ((>= window-height 38) 8)
   ((>= window-height 30) 6)
   ((>= window-height 24) 4)
   ((>= window-height 18) 2)
   (t 1)))

(defun naviel--player-cover-display-size ()
  "Return responsive player cover-art size in pixels."
  (let* ((w (naviel--player-window-width))
         (h (naviel--player-window-height))
         (scale (cond
                 ((or (< w 55) (< h 22)) 0.55)
                 ((or (< w 75) (< h 30)) 0.75)
                 ((and (> w 110) (> h 38)) 1.25)
                 (t 1.0))))
    (max 72 (round (* naviel-player-cover-size scale)))))

(defun naviel--pad-right (s width)
  "Return S truncated or padded to WIDTH display columns."
  (let* ((truncated (naviel--trunc s width))
         (pad (max 0 (- width (string-width truncated)))))
    (concat truncated (make-string pad ? ))))

(defun naviel--centered-indent (outer-width inner-width)
  "Return indentation needed to center INNER-WIDTH in OUTER-WIDTH."
  (make-string (max 2 (/ (max 0 (- outer-width inner-width)) 2)) ? ))

(defun naviel--indent-lines (s indent)
  "Prefix every non-final line in S with INDENT."
  (mapconcat (lambda (line) (concat indent line))
             (split-string (string-remove-suffix "\n" s) "\n")
             "\n"))

(defun naviel--player-footer-line (width)
  "Return a footer hint line fitting WIDTH columns."
  (propertize
   (concat "  " (naviel--trunc "SPC pause  n/p skip  [ ] seek  +/- vol  R repeat  V viz  C style  ? menu"
                                width))
   'face 'naviel-footer-face))

(defun naviel--player-song-info-lines (song width)
  "Return responsive song info lines for SONG within WIDTH columns."
  (let* ((title  (or (plist-get song :title)  "?"))
         (artist (or (plist-get song :artist) ""))
         (album  (or (plist-get song :album)  ""))
         (state  (if naviel--paused
                     (propertize "paused" 'face 'naviel-paused-face)
                   (propertize "playing" 'face 'naviel-now-playing-face))))
    (list
     (propertize "Song Info" 'face 'naviel-breadcrumb-face)
     (format "%s %s"
             (propertize "Title:" 'face 'naviel-radio-face)
             (propertize (naviel--trunc title (max 8 (- width 7)))
                         'face 'naviel-now-playing-face))
     (format "%s %s"
             (propertize "By:" 'face 'naviel-radio-face)
             (propertize (naviel--trunc artist (max 8 (- width 4)))
                         'face 'naviel-artist-face))
     (format "%s %s"
             (propertize "In:" 'face 'naviel-radio-face)
             (propertize (naviel--trunc album (max 8 (- width 4)))
                         'face 'naviel-album-face))
     (format "State: %s   vol %d%%   repeat: %s"
             state naviel--volume
             (propertize (naviel--repeat-label) 'face 'naviel-repeat-face)))))

(defun naviel--player-queue-preview-lines (width)
  "Return upcoming queue entries as lines fitting WIDTH columns."
  (let (lines)
    (push (propertize "Up Next" 'face 'naviel-breadcrumb-face) lines)
    (if (and naviel--queue
             (> naviel-player-queue-preview-size 0)
             (< (1+ naviel--queue-index) (length naviel--queue)))
        (let* ((start (1+ naviel--queue-index))
               (end (min (length naviel--queue)
                         (+ start naviel-player-queue-preview-size)))
               (idx start))
          (while (< idx end)
            (let* ((song (nth idx naviel--queue))
                   (artist-width (min 18 (max 0 (/ width 3))))
                   (title-width (max 8 (- width artist-width 7)))
                   (title (naviel--trunc (or (plist-get song :title) "?") title-width))
                   (artist (naviel--trunc (or (plist-get song :artist) "") artist-width)))
              (push (format "%s. %s%s"
                            (propertize (number-to-string (1+ idx)) 'face 'naviel-track-num-face)
                            (propertize title 'face 'naviel-song-title-face)
                            (if (string= artist "")
                                ""
                              (concat "  "
                                      (propertize artist 'face 'naviel-song-meta-face))))
                    lines))
            (setq idx (1+ idx))))
      (push (propertize "End of queue" 'face 'shadow) lines))
    (nreverse lines)))

(defun naviel--player-lyrics-lines (width)
  "Return lyrics preview lines fitting WIDTH columns."
  (cond
   (naviel--lrc-lines
    (let* ((elapsed naviel--elapsed)
           (idx (or (naviel--lrc-active-index elapsed) -1))
           (lines naviel--lrc-lines)
           (total (length lines))
           (start (max 0 (- idx 3)))
           (end (min total (+ idx 5)))
           result)
      (setq naviel--lrc-current-idx idx)
      (push (propertize "Lyrics" 'face 'naviel-breadcrumb-face) result)
      (if (< idx 0)
          (push (propertize "· · ·" 'face 'naviel-lyrics-context-face) result)
        (cl-loop for i from start below end
                 for entry = (nth i lines)
                 do (push
                     (if (= i idx)
                         (format "▸ %s"
                                 (propertize (naviel--trunc (cdr entry) (max 1 (- width 2)))
                                             'face 'naviel-lyrics-current-face))
                       (propertize (naviel--trunc (cdr entry) width)
                                   'face 'naviel-lyrics-context-face))
                     result)))
      (push (propertize "(synced via lrclib.net)" 'face 'naviel-footer-face) result)
      (nreverse result)))
   (naviel--lrc-raw
    (append
     (list (propertize "Lyrics" 'face 'naviel-breadcrumb-face)
           (propertize "(unsynced)" 'face 'naviel-footer-face))
     (mapcar (lambda (ln)
               (propertize (naviel--trunc ln width)
                           'face 'naviel-lyrics-nosync-face))
             (seq-take (split-string naviel--lrc-raw "\n") 12))))
   (t
    (list
     (propertize "Lyrics" 'face 'naviel-breadcrumb-face)
     (propertize "No lyrics found." 'face 'shadow)
     (propertize "l  search lyrics manually" 'face 'naviel-footer-face)))))

(defun naviel--player-render ()
  "Redraw the *Naviel Player* buffer."
  (when (naviel--player-buffer-p)
    (with-current-buffer (naviel--player-buffer)
      (naviel-player-mode)
      (let ((inhibit-read-only t)
            (saved-pos (point)))
        (erase-buffer)
        (naviel--player-insert-content)
        (goto-char (min saved-pos (point-max)))))))

(defun naviel--player-insert-content ()
  "Insert all player buffer content."
  (let* ((song    naviel--current-song)
         (w       (naviel--player-window-width))
         (h       (naviel--player-window-height))
         (content-width (max 20 (- w 4)))
         (sep     (propertize (make-string w ?─) 'face 'naviel-separator-face)))
    ;; ── Header ──
    (insert (propertize "  Naviel\n" 'face 'naviel-header-face))
    (insert sep) (insert "\n")

    (if (not song)
        ;; Nothing playing
      (progn
        (insert (propertize "  ·  Nothing playing\n\n" 'face 'shadow))
        (insert sep) (insert "\n"))

      (let ((single-layout (and (naviel--player-single-window-p) (>= w 72))))
        (if single-layout
            (naviel--player-insert-single-window-content song w h content-width sep)

      ;; ── Song info ──
      (let* (( title  (or (plist-get song :title)  "?"))
             (artist (or (plist-get song :artist) ""))
             (album  (or (plist-get song :album)  ""))
             (cover  (plist-get song :coverArt))
             (state  (if naviel--paused
                         (propertize "⏸ paused" 'face 'naviel-paused-face)
                       (propertize "▶ playing" 'face 'naviel-now-playing-face))))
        ;; ── Cover art ──
        (naviel--player-insert-cover cover)

        (if naviel--paused
            (insert (format "  %s\n\n" state))
            (progn (insert (format "  %s %s\n"
                                  (propertize "Title:" 'face 'naviel-radio-face)
                                  (propertize (naviel--trunc title (max 12 (- content-width 7)))
                                              'face 'naviel-now-playing-face)))
                  (insert (format "  %s %s\n"
                                  (propertize "By:" 'face 'naviel-radio-face)
                                  (propertize (naviel--trunc artist (max 12 (- content-width 4))) 'face 'naviel-artist-face)))
                  (insert (format "  %s %s\n\n"
                                  (propertize "In:" 'face 'naviel-radio-face)
                                  (propertize (naviel--trunc album (max 12 (- content-width 4))) 'face 'naviel-album-face)))
                  ))
        

        ;; ── Progress bar ──
        (let* ((elap  naviel--elapsed)
               (dur   (or naviel--duration
                          (let ((d (plist-get song :duration)))
                            (when (and d (not (string= d ""))) (string-to-number d)))))
               (e-str (naviel--format-secs elap))
               (d-str (naviel--format-secs dur))
               (pbar  (naviel--progress-bar elap dur (max 12 (- content-width 12))))
               (qidx  (format "[%d/%d]" (1+ naviel--queue-index) (length naviel--queue))))
          (insert (format "  %s\n" pbar))
          (insert (format "  %s / %s  %s\n\n"
                          (propertize e-str 'face 'naviel-position-face)
                          (propertize d-str 'face 'naviel-position-face)
                          (propertize qidx  'face 'naviel-count-face))))

        ;; ── CAVA-like visualizer ──
        (when naviel-player-visualizer
          (insert (naviel--visualizer-bars song naviel--elapsed
                                           content-width
                                           (naviel--player-visualizer-height h)))
          (insert "\n"))

        ;; ── Volume + repeat ──
        (insert (format "  vol %s   repeat: %s\n"
                        (naviel--volume-bar naviel--volume)
                        (propertize (naviel--repeat-label) 'face 'naviel-repeat-face)))
        (naviel--player-insert-queue-preview content-width)
        (insert "\n") (insert sep) (insert "\n")

        ;; ── Lyrics ──
        (naviel--player-insert-lyrics)))

        (unless single-layout
          ;; ── Footer ──
          (insert "\n")
          (insert (naviel--player-footer-line content-width))
          (insert "\n"))))))

(defun naviel--player-insert-single-window-content (song _w h content-width sep)
  "Insert dashboard-style player content for one-window use."
  (let* ((dashboard-width (max 68 (min content-width naviel-player-dashboard-width)))
         (indent (naviel--centered-indent content-width dashboard-width))
         (gap (propertize " │ " 'face 'naviel-separator-face))
         (left-width (max 24 (floor (* (- dashboard-width 3) 0.43))))
         (right-width (max 24 (- dashboard-width left-width 3)))
         (top-rule (concat indent
                           (propertize (make-string (1+ left-width) ?─) 'face 'naviel-separator-face)
                           (propertize "┬" 'face 'naviel-separator-face)
                           (propertize (make-string (1+ right-width) ?─) 'face 'naviel-separator-face)
                           "\n"))
         (bottom-rule (concat indent
                              (propertize (make-string (1+ left-width) ?─) 'face 'naviel-separator-face)
                              (propertize "┴" 'face 'naviel-separator-face)
                              (propertize (make-string (1+ right-width) ?─) 'face 'naviel-separator-face)
                              "\n"))
         (left-lines (append (naviel--player-song-info-lines song left-width)
                             (list "")
                             (naviel--player-queue-preview-lines left-width)))
         (right-lines (naviel--player-lyrics-lines right-width))
         (rows (max (length left-lines) (length right-lines)))
         (elap naviel--elapsed)
         (dur (or naviel--duration
                  (let ((d (plist-get song :duration)))
                    (when (and d (not (string= d ""))) (string-to-number d)))))
         (e-str (naviel--format-secs elap))
         (d-str (naviel--format-secs dur))
         (qidx (format "[%d/%d]" (1+ naviel--queue-index) (length naviel--queue)))
         (progress-width (max 24 (min naviel-player-progress-width (- dashboard-width 12))))
         (progress-indent (naviel--centered-indent content-width progress-width))
         (visualizer-height (max 4 (naviel--player-visualizer-height h)))
         (cover-path (naviel--player-cover-path (plist-get song :coverArt))))
    (when cover-path
      (insert indent)
      (insert-image (create-image cover-path 'jpeg nil :width (max 96 (min 140 (naviel--player-cover-display-size)))))
      (insert "\n\n"))
    (insert top-rule)
    (dotimes (i rows)
      (let ((left (or (nth i left-lines) ""))
            (right (or (nth i right-lines) "")))
        (insert indent)
        (insert (naviel--pad-right left left-width))
        (insert gap)
        (insert (naviel--trunc right right-width))
        (insert "\n")))
    (insert bottom-rule)
    (let* ((footer-lines 2)
           (bottom-lines (+ 2 1
                            (if naviel-player-visualizer (+ visualizer-height 1) 0)
                            1 footer-lines))
           (target-line (- h bottom-lines))
           (max-spacer 3)
           (spacer-lines (min max-spacer
                              (max 1 (- target-line (line-number-at-pos))))))
      (dotimes (_ spacer-lines)
        (insert "\n")))
    (insert (format "%s%s\n"
                    progress-indent
                    (naviel--progress-bar elap dur progress-width)))
    (insert (format "%s%s / %s  %s\n\n"
                    progress-indent
                    (propertize e-str 'face 'naviel-position-face)
                    (propertize d-str 'face 'naviel-position-face)
                    (propertize qidx 'face 'naviel-count-face)))
    (when naviel-player-visualizer
      (insert (naviel--indent-lines
               (naviel--visualizer-bars song elap dashboard-width visualizer-height)
               indent))
      (insert "\n"))
    (insert sep) (insert "\n\n")
    (insert (naviel--player-footer-line content-width))
    (insert "\n")))

(defun naviel--player-insert-lyrics ()
  "Insert the lyrics section into the player buffer."
  (cond
   ;; Synced lyrics
   (naviel--lrc-lines
    (progn
      (insert (propertize "\n  Lyrics\n" 'face 'naviel-breadcrumb-face))
      (let* ((elapsed naviel--elapsed)
             (idx     (or (naviel--lrc-active-index elapsed) -1))
             (lines   naviel--lrc-lines)
             (total   (length lines))
             (prev-entry (when (> idx 0) (nth (1- idx) lines)))
             (cur-entry  (when (>= idx 0) (nth idx lines)))
             (next-entry (when (< (1+ idx) total) (nth (1+ idx) lines))))
        (setq naviel--lrc-current-idx idx)
        ;; Previous line (dimmed)
        (if prev-entry
            (insert (format "  %s\n"
                            (propertize (naviel--trunc (cdr prev-entry) 82)
                                        'face 'naviel-lyrics-context-face)))
          (insert "\n"))
        ;; Current line (highlighted)
        (if cur-entry
            (insert (format "  ▸ %s\n"
                            (propertize (naviel--trunc (cdr cur-entry) 80)
                                        'face 'naviel-lyrics-current-face)))
          (insert (propertize "  · · ·\n" 'face 'naviel-lyrics-context-face)))
      ;; Next line (dimmed)
        (if next-entry
            (insert (format "  %s\n"
                          (propertize (naviel--trunc (cdr next-entry) 82)
                                      'face 'naviel-lyrics-context-face)))
          (insert "\n"))
        (insert "\n")
      (insert (propertize "  (synced via lrclib.net)\n" 'face 'naviel-footer-face)))))
   ;; Plain / unsynced lyrics
   (naviel--lrc-raw

    (progn
      (insert (propertize "  Lyrics\n" 'face 'naviel-breadcrumb-face))
      (insert (propertize "  (unsynced)\n\n" 'face 'naviel-footer-face))
      ;; Show first 12 lines
      (let ((lns (seq-take (split-string naviel--lrc-raw "\n") 12)))
        (dolist (ln lns)
          (insert (format "  %s\n"
                          (propertize (naviel--trunc ln 52)
                                      'face 'naviel-lyrics-nosync-face))))
        (when (> (length (split-string naviel--lrc-raw "\n")) 12)
          (insert (propertize "  … (l for full lyrics)\n" 'face 'naviel-footer-face))))))
    ;; No lyrics
   (t
    (insert (propertize "  No lyrics found.\n" 'face 'shadow))
    (insert (propertize "  l  search lyrics manually\n" 'face 'naviel-footer-face)))))

(defun naviel--player-insert-queue-preview (width)
  "Insert upcoming queue entries into the player buffer."
  (when (and naviel--queue
             (> naviel-player-queue-preview-size 0)
             (< (1+ naviel--queue-index) (length naviel--queue)))
    (insert "\n")
    (insert (propertize "  Up next\n" 'face 'naviel-breadcrumb-face))
    (let* ((start (1+ naviel--queue-index))
           (end (min (length naviel--queue)
                     (+ start naviel-player-queue-preview-size)))
           (idx start))
      (while (< idx end)
        (let* ((song (nth idx naviel--queue))
               (artist-width (min 24 (max 0 (/ width 3))))
               (title-width (max 12 (- width artist-width 8)))
               (title (naviel--trunc (or (plist-get song :title) "?") title-width))
               (artist (naviel--trunc (or (plist-get song :artist) "") artist-width)))
          (insert (format "  %s. %s%s\n"
                          (propertize (number-to-string (1+ idx)) 'face 'naviel-track-num-face)
                          (propertize title 'face 'naviel-song-title-face)
                          (if (string= artist "")
                              ""
                            (concat "  "
                                    (propertize artist 'face 'naviel-song-meta-face))))))
        (setq idx (1+ idx))))))

;;; Player mode

(defvar naviel-player-mode-map
  (let ((m (make-sparse-keymap)))
    (define-key m (kbd "SPC") #'naviel--toggle-pause)
    (define-key m (kbd "n")   #'naviel--next-in-queue)
    (define-key m (kbd "p")   #'naviel--prev-in-queue)
    (define-key m (kbd "+")   #'naviel--volume-up)
    (define-key m (kbd "=")   #'naviel--volume-up)
    (define-key m (kbd "-")   #'naviel--volume-down)
    (define-key m (kbd "[")   #'naviel-seek-backward)
    (define-key m (kbd "]")   #'naviel-seek-forward)
    (define-key m (kbd "R")   #'naviel-toggle-repeat)
    (define-key m (kbd "V")   #'naviel-toggle-visualizer)
    (define-key m (kbd "C")   #'naviel-cycle-visualizer-style)
    (define-key m (kbd "l")   #'naviel-lyrics-show)
    (define-key m (kbd "*")   #'naviel-toggle-star-current)
    (define-key m (kbd "?")   #'naviel-dispatch)
    (define-key m (kbd "q")   #'quit-window)
    m))

(define-derived-mode naviel-player-mode special-mode "Naviel:Player"
  "Major mode for the Naviel player buffer."
  (setq buffer-read-only t)
  (setq-local truncate-lines t))

;;; API parse helpers

(defun naviel--parse-artists (response)
  (let (result)
    (dolist (index (xml-get-children (naviel--get-child response 'artists) 'index) result)
      (dolist (a (xml-get-children index 'artist))
        (push `(:id      ,(naviel--attr a 'id)
                :name    ,(naviel--attr a 'name)
                :albums  ,(naviel--attr a 'albumCount)
                :starred ,(naviel--attr a 'starred))
              result)))
    (nreverse result)))

(defun naviel--parse-artist-albums (response)
  (let (result)
    (dolist (al (xml-get-children (naviel--get-child response 'artist) 'album) result)
      (push `(:id       ,(naviel--attr al 'id)
              :name     ,(naviel--attr al 'name)
              :year     ,(naviel--attr al 'year)
              :coverArt ,(naviel--attr al 'coverArt)
              :starred  ,(naviel--attr al 'starred))
            result))
    (nreverse result)))

(defun naviel--parse-album-songs (response)
  (let* ((album-node (naviel--get-child response 'album))
         result)
    (dolist (s (xml-get-children album-node 'song) result)
      (push `(:id       ,(naviel--attr s 'id)
              :title    ,(naviel--attr s 'title)
              :artist   ,(naviel--attr s 'artist)
              :album    ,(naviel--attr s 'album)
              :track    ,(naviel--attr s 'track)
              :duration ,(naviel--attr s 'duration)
              :coverArt ,(naviel--attr s 'coverArt)
              :starred  ,(naviel--attr s 'starred))
            result))
    (nreverse result)))

(defun naviel--parse-search (response)
  (let* ((r3 (naviel--get-child response 'searchResult3))
         artists albums songs)
    (dolist (a  (xml-get-children r3 'artist))
      (push `(:id ,(naviel--attr a 'id) :name ,(naviel--attr a 'name)
              :starred ,(naviel--attr a 'starred)) artists))
    (dolist (al (xml-get-children r3 'album))
      (push `(:id ,(naviel--attr al 'id) :name ,(naviel--attr al 'name)
              :artist ,(naviel--attr al 'artist) :starred ,(naviel--attr al 'starred)) albums))
    (dolist (s  (xml-get-children r3 'song))
      (push `(:id ,(naviel--attr s 'id) :title ,(naviel--attr s 'title)
              :artist ,(naviel--attr s 'artist) :album ,(naviel--attr s 'album)
              :duration ,(naviel--attr s 'duration) :starred ,(naviel--attr s 'starred)) songs))
    `(:artists ,(nreverse artists) :albums ,(nreverse albums) :songs ,(nreverse songs))))

(defun naviel--parse-random-songs (response)
  (let (result)
    (dolist (s (xml-get-children (naviel--get-child response 'randomSongs) 'song) result)
      (push `(:id ,(naviel--attr s 'id) :title ,(naviel--attr s 'title)
              :artist ,(naviel--attr s 'artist) :album ,(naviel--attr s 'album)
              :duration ,(naviel--attr s 'duration) :coverArt ,(naviel--attr s 'coverArt)
              :starred ,(naviel--attr s 'starred))
            result))
    (nreverse result)))

(defun naviel--parse-playlists (response)
  (let (result)
    (dolist (pl (xml-get-children (naviel--get-child response 'playlists) 'playlist) result)
      (push `(:id ,(naviel--attr pl 'id) :name ,(naviel--attr pl 'name)
              :count ,(naviel--attr pl 'songCount) :owner ,(naviel--attr pl 'owner))
            result))
    (nreverse result)))

(defun naviel--parse-playlist-songs (response)
  (let (result)
    (dolist (s (xml-get-children (naviel--get-child response 'playlist) 'entry) result)
      (push `(:id ,(naviel--attr s 'id) :title ,(naviel--attr s 'title)
              :artist ,(naviel--attr s 'artist) :album ,(naviel--attr s 'album)
              :track ,(naviel--attr s 'track) :duration ,(naviel--attr s 'duration)
              :coverArt ,(naviel--attr s 'coverArt) :starred ,(naviel--attr s 'starred))
            result))
    (nreverse result)))

(defun naviel--parse-album-list2 (response)
  (let (result)
    (dolist (al (xml-get-children (naviel--get-child response 'albumList2) 'album) result)
      (push `(:id ,(naviel--attr al 'id) :name ,(naviel--attr al 'name)
              :artist ,(naviel--attr al 'artist) :year ,(naviel--attr al 'year)
              :coverArt ,(naviel--attr al 'coverArt) :starred ,(naviel--attr al 'starred))
            result))
    (nreverse result)))

(defun naviel--parse-genres (response)
  (let (result)
    (dolist (g (xml-get-children (naviel--get-child response 'genres) 'genre) result)
      (let* ((children  (xml-node-children g))
             (text-node (seq-find #'stringp children))
             (name      (when text-node (string-trim text-node)))
             (songs     (naviel--attr g 'songCount))
             (albums    (naviel--attr g 'albumCount)))
        (when (and name (not (string= name "")))
          (push `(:name ,name :songs ,songs :albums ,albums) result))))
    (nreverse result)))

(defun naviel--parse-songs-by-genre (response)
  (let (result)
    (dolist (s (xml-get-children (naviel--get-child response 'songsByGenre) 'song) result)
      (push `(:id ,(naviel--attr s 'id) :title ,(naviel--attr s 'title)
              :artist ,(naviel--attr s 'artist) :album ,(naviel--attr s 'album)
              :duration ,(naviel--attr s 'duration) :coverArt ,(naviel--attr s 'coverArt)
              :starred ,(naviel--attr s 'starred))
            result))
    (nreverse result)))

(defun naviel--parse-lyrics (response)
  (let* ((node (naviel--get-child response 'lyrics))
         (text (when node (seq-find #'stringp (xml-node-children node)))))
    (if (and text (not (string= (string-trim text) "")))
        (string-trim text)
      nil)))

(defun naviel--parse-starred2 (response)
  (let* ((starred (naviel--get-child response 'starred2))
         artists albums songs)
    (dolist (a  (xml-get-children starred 'artist))
      (push `(:id ,(naviel--attr a 'id) :name ,(naviel--attr a 'name) :starred t) artists))
    (dolist (al (xml-get-children starred 'album))
      (push `(:id ,(naviel--attr al 'id) :name ,(naviel--attr al 'name)
              :artist ,(naviel--attr al 'artist) :year ,(naviel--attr al 'year)
              :coverArt ,(naviel--attr al 'coverArt) :starred t) albums))
    (dolist (s  (xml-get-children starred 'song))
      (push `(:id ,(naviel--attr s 'id) :title ,(naviel--attr s 'title)
              :artist ,(naviel--attr s 'artist) :album ,(naviel--attr s 'album)
              :duration ,(naviel--attr s 'duration) :coverArt ,(naviel--attr s 'coverArt)
              :starred t) songs))
    `(:artists ,(nreverse artists) :albums ,(nreverse albums) :songs ,(nreverse songs))))

(defun naviel--parse-radio-stations (response)
  (let (result)
    (dolist (s (xml-get-children (naviel--get-child response 'internetRadioStations)
                                 'internetRadioStation)
               result)
      (push `(:id         ,(naviel--attr s 'id)
              :name       ,(naviel--attr s 'name)
              :stream-url ,(naviel--attr s 'streamUrl)
              :home-url   ,(naviel--attr s 'homePageUrl))
            result))
    (nreverse result)))

(defun naviel--parse-void (_response) t)

;;; Async API entry points

(defun naviel--get-artists (cb)
  (naviel--request-async "getArtists" '() #'naviel--parse-artists cb))
(defun naviel--get-artist (id cb)
  (naviel--request-async "getArtist" `(("id" . ,id)) #'naviel--parse-artist-albums cb))
(defun naviel--get-album (id cb)
  (naviel--request-async "getAlbum" `(("id" . ,id)) #'naviel--parse-album-songs cb))
(defun naviel--get-playlists (cb)
  (naviel--request-async "getPlaylists" '() #'naviel--parse-playlists cb))
(defun naviel--get-playlist (id cb)
  (naviel--request-async "getPlaylist" `(("id" . ,id)) #'naviel--parse-playlist-songs cb))
(defun naviel--get-album-list2 (type size cb)
  (naviel--request-async "getAlbumList2"
                         `(("type" . ,type) ("size" . ,(number-to-string size)))
                         #'naviel--parse-album-list2 cb))
(defun naviel--get-genres (cb)
  (naviel--request-async "getGenres" '() #'naviel--parse-genres cb))
(defun naviel--get-songs-by-genre (genre count offset cb)
  (naviel--request-async "getSongsByGenre"
                         `(("genre"  . ,genre)
                           ("count"  . ,(number-to-string count))
                           ("offset" . ,(number-to-string offset)))
                         #'naviel--parse-songs-by-genre cb))
(defun naviel--search-async (q cb)
  (naviel--request-async "search3"
                         `(("query" . ,q) ("artistCount" . "10")
                           ("albumCount" . "10") ("songCount" . "20"))
                         #'naviel--parse-search cb))
(defun naviel--get-random-songs (n cb)
  (naviel--request-async "getRandomSongs" `(("size" . ,(number-to-string n)))
                         #'naviel--parse-random-songs cb))
(defun naviel--get-lyrics (artist title cb)
  (naviel--request-async "getLyrics"
                         `(("artist" . ,artist) ("title" . ,title))
                         #'naviel--parse-lyrics cb))
(defun naviel--get-starred2 (cb)
  (naviel--request-async "getStarred2" '() #'naviel--parse-starred2 cb))
(defun naviel--get-radio-stations (cb)
  (naviel--request-async "getInternetRadioStations" '()
                         #'naviel--parse-radio-stations cb))

(defun naviel--api-star (id type cb)
  (let ((param (pcase type ('song "id") ('album "albumId") ('artist "artistId") (_ "id"))))
    (naviel--request-async "star" `((,param . ,id)) #'naviel--parse-void cb)))

(defun naviel--api-unstar (id type cb)
  (let ((param (pcase type ('song "id") ('album "albumId") ('artist "artistId") (_ "id"))))
    (naviel--request-async "unstar" `((,param . ,id)) #'naviel--parse-void cb)))

;;; Star cache

(defun naviel--starred-p (id) (gethash id naviel--starred-ids))

(defun naviel--star-cache-set (id val)
  (if val (puthash id t naviel--starred-ids) (remhash id naviel--starred-ids)))

(defun naviel--prime-star-cache (items id-key starred-key)
  (dolist (item items)
    (let ((id      (plist-get item id-key))
          (starred (plist-get item starred-key)))
      (when (and id starred (not (string= starred "")))
        (puthash id t naviel--starred-ids)))))

;;; Duration / string helpers

(defun naviel--format-secs (secs)
  (if (and secs (numberp secs) (> secs 0))
      (let* ((s (round secs)) (m (/ s 60)) (ss (% s 60)))
        (format "%d:%02d" m ss))
    "--:--"))

(defun naviel--trunc (s max)
  "Truncate S to at most MAX display columns, appending … if cut.
Uses `string-width'/`truncate-string-to-width' so accented letters,
CJK characters and emoji are measured by display width, not byte count."
  (if (null s) ""
    (if (> (string-width s) max)
        (concat (truncate-string-to-width s (max 0 (- max 1)) nil nil nil) "…")
      s)))

(defun naviel--star-glyph (id)
  (if (naviel--starred-p id)
      (propertize "★" 'face 'naviel-starred-face)
    (propertize "☆" 'face 'naviel-separator-face)))

;;; Progress / volume bars

(defun naviel--progress-bar (elapsed duration width)
  (if (and elapsed duration (> duration 0))
      (let* ((pct  (min 1.0 (/ elapsed duration)))
             (fill (round (* width pct)))
             (empty (- width fill)))
        (concat
         (propertize (make-string fill ?━) 'face 'naviel-progress-fill-face)
         (propertize (make-string empty ?─) 'face 'naviel-progress-empty-face)))
    (propertize (make-string width ?─) 'face 'naviel-separator-face)))

(defun naviel--visualizer-glyphs ()
  (pcase naviel-player-visualizer-style
    ('compact [" " " " "▁" "▂" "▃" "▄" "▅" "▆"])
    ('wide ["▁ " "▂ " "▃ " "▄ " "▅ " "▆ " "▇ " "█ "])
    (_ ["▁" "▂" "▃" "▄" "▅" "▆" "▇" "█"])))

(defun naviel--visualizer-face (level)
  (pcase naviel-player-visualizer-style
    ('monochrome 'naviel-now-playing-face)
    ('high-contrast (if (>= level 4) 'naviel-error-face 'naviel-separator-face))
    (_ (cond ((>= level 6) 'naviel-visualizer-high-face)
             ((>= level 3) 'naviel-visualizer-mid-face)
             (t 'naviel-visualizer-low-face)))))

(defun naviel--visualizer-format-levels (levels width height)
  "Format visualizer LEVELS to fit WIDTH columns and HEIGHT rows."
  (let* ((glyphs (naviel--visualizer-glyphs))
         (glyph-width (max 1 (string-width (aref glyphs 7))))
         (levels (or levels '(0)))
         (len (length levels))
         (bars (max 1 (min (max 1 (/ width glyph-width)) len)))
         parts)
    (if (<= height 1)
        (progn
          (dotimes (i bars)
            (let* ((src (floor (* i (/ (float len) bars))))
                   (level (max 0 (min 7 (nth src levels)))))
              (push (propertize (aref glyphs level)
                                'face (naviel--visualizer-face level))
                    parts)))
          (concat "  " (truncate-string-to-width (apply #'concat (nreverse parts)) width) "\n"))
      (let (rows)
        (dotimes (row height)
          (setq parts nil)
          (let ((threshold (ceiling (* 8.0 (/ (- height row) (float height))))))
            (dotimes (i bars)
              (let* ((src (floor (* i (/ (float len) bars))))
                     (level (max 0 (min 7 (nth src levels))))
                     (active (>= (1+ level) threshold))
                     (cell (if active
                               (if (eq naviel-player-visualizer-style 'wide) "█ " "█")
                             (if (eq naviel-player-visualizer-style 'wide) "  " " "))))
                (push (propertize cell
                                  'face (if active
                                            (naviel--visualizer-face level)
                                          'naviel-separator-face))
                      parts))))
          (push (concat "  "
                        (truncate-string-to-width (apply #'concat (nreverse parts)) width)
                        "\n")
                rows))
        (apply #'concat (nreverse rows))))))

(defun naviel--visualizer-simulated-levels (song elapsed width)
  "Return simulated visualizer levels for SONG at ELAPSED seconds."
  (let* ((bars (max 1 width))
         (time (if naviel--paused
                   (or elapsed 0.0)
                 (or elapsed (float-time))))
         (seed (sxhash (format "%s:%s"
                               (or (plist-get song :id) "")
                               (or (plist-get song :title) ""))))
         levels)
    (dotimes (i bars)
      (let* ((phase (+ (* time 5.0) (* i 0.47) (% seed 31)))
             (bass (+ 0.5 (* 0.5 (sin (+ phase (* i 0.13))))))
             (mid  (+ 0.5 (* 0.5 (sin (+ (* phase 0.67) (/ seed 97.0))))))
             (spark (+ 0.5 (* 0.5 (sin (+ (* phase 1.73) (* i i 0.021))))))
             (edge-falloff (- 1.0 (* 0.38 (/ (abs (- i (/ (1- bars) 2.0)))
                                             (max 1.0 (/ bars 2.0))))))
             (level (truncate (* 7.0 edge-falloff
                                (+ (* 0.52 bass) (* 0.34 mid) (* 0.14 spark))))))
        (push (max 0 (min 7 level)) levels)))
    (nreverse levels)))

(defun naviel--visualizer-bars (song elapsed width height)
  "Return a CAVA-like visualizer line for SONG at ELAPSED seconds."
  (naviel--maybe-start-cava)
  (naviel--visualizer-format-levels
   (or naviel--cava-levels
       (naviel--visualizer-simulated-levels song elapsed width))
   width height))

(defun naviel--volume-bar (vol)
  (let* ((w 8) (f (round (* w (/ vol 100.0)))))
    (concat
     (propertize (make-string f ?▪) 'face 'naviel-now-playing-face)
     (propertize (make-string (- w f) ?▪) 'face 'naviel-separator-face)
     (propertize (format " %3d%%" vol) 'face 'naviel-song-meta-face))))

;;; Browser buffer

(defun naviel--expanded-p (album-id)
  (gethash album-id naviel--expanded-albums))

(defun naviel--expand-set (album-id val)
  (puthash album-id val naviel--expanded-albums))

(defun naviel-browser-toggle-expand ()
  "TAB: toggle inline expand of album at point, fetching songs if needed."
  (interactive)
  (let ((entry (naviel--item-at-point)))
    (unless entry (user-error "No item at point"))
    (let* ((type (car entry))
           (item (cdr entry)))
      (pcase type
        ('album
         (let* ((id    (plist-get item :id))
                (state (naviel--expanded-p id)))
           (if state
               ;; Collapse
               (progn
                 (naviel--expand-set id nil)
                 (naviel--browser-rerender-current-view))
             ;; Expand – fetch if not cached
             (let ((cached (plist-get state :songs)))
               (if cached
                   (progn
                     (naviel--expand-set id `(:open t :songs ,cached))
                     (naviel--browser-rerender-current-view))
                 (message "naviel: loading tracks…")
                 (naviel--get-album
                  id (lambda (songs)
                       (when songs
                         (naviel--expand-set id `(:open t :songs ,songs))
                         (naviel--browser-rerender-current-view)))))))))
        ('artist
         ;; For artists, RET already drills in; TAB does the same
         (naviel--browser-enter))
        (_ (message "naviel: TAB expand not available for this item type"))))))

;;; Browser format callbacks

(defun naviel--format-artist (artist _p)
  (let* ((id   (plist-get artist :id))
         (name (naviel--trunc (or (plist-get artist :name) "?") 44))
         (n    (plist-get artist :albums)))
    (format "  %s %-44s %s"
            (naviel--star-glyph id)
            (propertize name 'face 'naviel-artist-face)
            (if (and n (not (string= n "")))
                (propertize (format "(%s albums)" n) 'face 'naviel-count-face)
              ""))))

(defun naviel--format-album (album _p)
  (let* ((id   (plist-get album :id))
         (name (naviel--trunc (or (plist-get album :name) "?") 44))
         (y    (plist-get album :year))
         (exp  (naviel--expanded-p id))
         (tri  (if exp
                   (propertize "▾ " 'face 'naviel-expand-indicator-face)
                 (propertize "▸ " 'face 'naviel-expand-indicator-face))))
    (format "  %s%s %-44s %s"
            (naviel--star-glyph id)
            tri
            (propertize name 'face 'naviel-album-face)
            (if (and y (not (string= y "")))
                (propertize y 'face 'naviel-year-face)
              ""))))

(defun naviel--format-album-with-artist (album _p)
  (let* ((id     (plist-get album :id))
         (name   (naviel--trunc (or (plist-get album :name)   "?") 36))
         (artist (naviel--trunc (or (plist-get album :artist) "") 26))
         (y      (plist-get album :year))
         (exp    (naviel--expanded-p id))
         (tri    (if exp
                     (propertize "▾ " 'face 'naviel-expand-indicator-face)
                   (propertize "▸ " 'face 'naviel-expand-indicator-face))))
    (format "  %s%s %-36s  %-26s  %s"
            (naviel--star-glyph id)
            tri
            (propertize name   'face 'naviel-album-face)
            (propertize artist 'face 'naviel-artist-face)
            (if (and y (not (string= y "")))
                (propertize y 'face 'naviel-year-face)
              ""))))

(defun naviel--format-song (song playing)
  (let* ((id     (plist-get song :id))
         (track  (naviel--trunc (or (plist-get song :track)  "") 3))
         (title  (naviel--trunc (or (plist-get song :title)  "?") 36))
         (artist (naviel--trunc (or (plist-get song :artist) "") 24))
         (dur    (naviel--format-secs
                  (let ((d (plist-get song :duration)))
                    (when (and d (not (string= d ""))) (string-to-number d))))))
    (format "  %s %s  %s  %-36s  %-24s  %s"
            (if playing (propertize "▶" 'face 'naviel-now-playing-face)
              (propertize " " 'face 'naviel-separator-face))
            (naviel--star-glyph id)
            (propertize (format "%3s" track) 'face 'naviel-track-num-face)
            (propertize title  'face (if playing 'naviel-now-playing-face 'naviel-song-title-face))
            (propertize artist 'face 'naviel-song-meta-face)
            (propertize dur    'face 'naviel-song-meta-face))))

(defun naviel--format-inline-song (song playing _idx)
  "Format a song for inline display under an expanded album."
  (let* ((id     (plist-get song :id))
         (track  (naviel--trunc (or (plist-get song :track) "") 3))
         (title  (naviel--trunc (or (plist-get song :title) "?") 38))
         (dur    (naviel--format-secs
                  (let ((d (plist-get song :duration)))
                    (when (and d (not (string= d ""))) (string-to-number d))))))
    (format "      %s %s  %s  %-38s  %s"
            (if playing (propertize "▶" 'face 'naviel-now-playing-face)
              (propertize " " 'face 'naviel-separator-face))
            (naviel--star-glyph id)
            (propertize (format "%3s" track) 'face 'naviel-track-num-face)
            (propertize title 'face (if playing 'naviel-now-playing-face 'naviel-inline-song-face))
            (propertize dur   'face 'naviel-song-meta-face))))

(defun naviel--format-playlist (pl _p)
  (let* ((name  (naviel--trunc (or (plist-get pl :name) "?") 40))
         (count (plist-get pl :count))
         (owner (plist-get pl :owner)))
    (format "  %-41s  %-16s  %s"
            (propertize name 'face 'naviel-album-face)
            (if (and count (not (string= count "")))
                (propertize (format "%s tracks" count) 'face 'naviel-count-face)
              "")
            (if (and owner (not (string= owner "")))
                (propertize owner 'face 'naviel-song-meta-face)
              ""))))

(defun naviel--format-genre (genre _p)
  (let* ((name   (naviel--trunc (or (plist-get genre :name) "?") 32))
         (songs  (or (plist-get genre :songs)  ""))
         (albums (or (plist-get genre :albums) "")))
    (format "  %-32s  %s"
            (propertize name 'face 'naviel-artist-face)
            (if (not (string= songs ""))
                (propertize (format "%s songs · %s albums" songs albums) 'face 'naviel-count-face)
              ""))))

(defun naviel--format-radio (station _p)
  (let* ((name (naviel--trunc (or (plist-get station :name) "?") 44))
         (url  (naviel--trunc (or (plist-get station :stream-url) "") 40)))
    (format "  %-44s  %s"
            (propertize name 'face 'naviel-radio-face)
            (propertize url 'face 'naviel-song-meta-face))))

;;; Browser core render 

(defun naviel--browser-render (heading items format-fn type &optional section-label)
  (setq naviel--current-view
        `(:type ,type :items ,items :heading ,heading
          :format-fn ,format-fn :section-label ,section-label))
  (naviel--browser-do-render heading items format-fn type section-label))

(defun naviel--browser-do-render (heading items format-fn type section-label)
  (with-current-buffer (naviel--browser-buffer)
    (naviel-browser-mode)
    (let ((inhibit-read-only t)
          (saved-line (line-number-at-pos)))
      (erase-buffer)
      (insert (naviel--make-breadcrumbs))
      (insert (propertize (format "  %s\n" heading) 'face 'naviel-header-face))
      (insert (propertize (make-string (min 80 (window-width)) ?─)
                          'face 'naviel-separator-face))
      (insert "\n")
      (when section-label
        (insert (propertize (format "\n  %s\n\n" section-label) 'face 'naviel-breadcrumb-face)))
      (if (null items)
          (insert (propertize "  (no results)\n" 'face 'shadow))
        (let ((idx 0))
          (dolist (item items)
            (let* ((is-playing (and naviel--current-song
                                    (eq type 'song)
                                    (= idx naviel--queue-index)
                                    (equal (plist-get item :id)
                                           (plist-get naviel--current-song :id))))
                   (line (funcall format-fn item is-playing)))
              (insert (propertize line
                                  'naviel-item item 'naviel-type type 'naviel-idx idx
                                  'face (when is-playing 'naviel-now-playing-face)))
              (insert "\n")
              ;; Inline expand for albums
              (when (and (eq type 'album)
                         (naviel--expanded-p (plist-get item :id)))
                (naviel--browser-insert-expanded-album item idx)))
            (cl-incf idx))))
      (insert (propertize (make-string (min 80 (window-width)) ?─) 'face 'naviel-separator-face))
      (insert "\n")
      (insert (propertize
               "  RET play  TAB expand  a append  SPC pause  n/p skip  * star  l lyrics  ? menu"
               'face 'naviel-footer-face))
      (insert "\n")
      (goto-char (point-min))
      (forward-line (max 0 (- saved-line 1))))))

(defun naviel--browser-insert-expanded-album (album _parent-idx)
  "Insert inline song list and optional cover art for ALBUM below its line."
  (let* ((album-id  (plist-get album :id))
         (cover-id  (plist-get album :coverArt))
         (state     (naviel--expanded-p album-id))
         (songs     (plist-get state :songs)))
    ;; Cover art (GUI only)
    (when (and naviel-cover-art-display cover-id (not (string= cover-id ""))
               (display-graphic-p) (image-type-available-p 'jpeg))
      ;; Insert a placeholder line; async fill will replace it
      (insert (propertize (format "      [cover loading…]\n")
                          'face 'naviel-separator-face
                          'naviel-cover-placeholder album-id))
      ;; Kick off async fetch
      (naviel--fetch-and-insert-cover
       cover-id "*Naviel Browser*" "cover loading" naviel-browser-cover-size))
    ;; Songs
    (when songs
      (setq naviel--queue songs naviel--queue-index 0)
      (let ((sidx 0))
        (dolist (song songs)
          (let* ((is-playing (and naviel--current-song
                                  (equal (plist-get song :id)
                                         (plist-get naviel--current-song :id))))
                 (line (naviel--format-inline-song song is-playing sidx)))
            (insert (propertize line
                                'naviel-item song
                                'naviel-type 'song
                                'naviel-idx  sidx
                                'naviel-inline-song t
                                'face (when is-playing 'naviel-now-playing-face)))
            (insert "\n"))
          (cl-incf sidx))))
    (insert (propertize "      ──\n" 'face 'naviel-separator-face))))

;;; Breadcrumbs

(defun naviel--make-breadcrumbs ()
  (if (null naviel--browser-stack) ""
    (propertize
     (concat "  " (mapconcat (lambda (v) (plist-get v :label))
                             (reverse naviel--browser-stack) "  ❯  ")
             "\n")
     'face 'naviel-breadcrumb-face)))

;;; Render entry points

(defun naviel--render-artists (artists)
  (naviel--prime-star-cache artists :id :starred)
  (naviel--browser-render (format "Artists  (%d)" (length artists))
                          artists #'naviel--format-artist 'artist))

(defun naviel--render-albums (albums name)
  (naviel--prime-star-cache albums :id :starred)
  (naviel--browser-render name albums #'naviel--format-album 'album
                          (format "%d album%s" (length albums)
                                  (if (= 1 (length albums)) "" "s"))))

(defun naviel--render-songs (songs context &optional section)
  (naviel--prime-star-cache songs :id :starred)
  (naviel--browser-render context songs #'naviel--format-song 'song
                          (or section (format "%d track%s" (length songs)
                                              (if (= 1 (length songs)) "" "s")))))

;;; Browser rerender

(defun naviel--browser-rerender-current-view ()
  (when (and naviel--current-view (get-buffer "*Naviel Browser*"))
    (naviel--browser-do-render
     (plist-get naviel--current-view :heading)
     (plist-get naviel--current-view :items)
     (plist-get naviel--current-view :format-fn)
     (plist-get naviel--current-view :type)
     (plist-get naviel--current-view :section-label))))

;;; Star / unstar

(defun naviel-toggle-star-current ()
  "Toggle star on the currently playing song."
  (interactive)
  (unless naviel--current-song (user-error "naviel: nothing playing"))
  (let* ((song naviel--current-song)
         (id   (plist-get song :id)))
    (if (naviel--starred-p id)
        (naviel--api-unstar id 'song
                            (lambda (ok)
                              (when ok
                                (naviel--star-cache-set id nil)
                                (naviel--player-render)
                                (message "naviel: unstarred"))))
      (naviel--api-star id 'song
                        (lambda (ok)
                          (when ok
                            (naviel--star-cache-set id t)
                            (naviel--player-render)
                            (message "naviel: starred ★")))))))

(defun naviel-toggle-star ()
  "Toggle star on the item at point."
  (interactive)
  (let* ((entry (naviel--item-at-point))
         (type  (car entry))
         (item  (cdr entry))
         (id    (or (plist-get item :id) (plist-get item :name))))
    (unless (and id type (memq type '(song album artist)))
      (user-error "naviel: no starrable item at point"))
    (if (naviel--starred-p id)
        (naviel--api-unstar id type
                            (lambda (ok)
                              (when ok
                                (naviel--star-cache-set id nil)
                                (naviel--browser-rerender-current-view)
                                (message "naviel: unstarred"))))
      (naviel--api-star id type
                        (lambda (ok)
                          (when ok
                            (naviel--star-cache-set id t)
                            (naviel--browser-rerender-current-view)
                            (message "naviel: starred ★")))))))

;;; Browser mode

(defvar naviel-browser-mode-map
  (let ((m (make-sparse-keymap)))
    (define-key m (kbd "RET") #'naviel--browser-enter)
    (define-key m (kbd "TAB") #'naviel-browser-toggle-expand)
    (define-key m (kbd "a")   #'naviel--browser-append)
    (define-key m (kbd "*")   #'naviel-toggle-star)
    (define-key m (kbd "SPC") #'naviel--toggle-pause)
    (define-key m (kbd "n")   #'naviel--next-in-queue)
    (define-key m (kbd "p")   #'naviel--prev-in-queue)
    (define-key m (kbd "+")   #'naviel--volume-up)
    (define-key m (kbd "=")   #'naviel--volume-up)
    (define-key m (kbd "-")   #'naviel--volume-down)
    (define-key m (kbd "[")   #'naviel-seek-backward)
    (define-key m (kbd "]")   #'naviel-seek-forward)
    (define-key m (kbd "s")   #'naviel-search)
    (define-key m (kbd "r")   #'naviel-play-random)
    (define-key m (kbd "b")   #'naviel--browser-back)
    (define-key m (kbd "g")   #'naviel--browser-refresh)
    (define-key m (kbd "l")   #'naviel-lyrics-show)
    (define-key m (kbd "q")   #'naviel--browser-quit)
    (define-key m (kbd "?")   #'naviel-dispatch)
    (define-key m (kbd "R")   #'naviel-toggle-repeat)
    (define-key m (kbd "P")   #'naviel-playlists)
    (define-key m (kbd "N")   #'naviel-recently-added)
    (define-key m (kbd "H")   #'naviel-recently-played)
    (define-key m (kbd "G")   #'naviel-genres)
    (define-key m (kbd "F")   #'naviel-starred-view)
    (define-key m (kbd "I")   #'naviel-radio)
    m))

(define-derived-mode naviel-browser-mode special-mode "Naviel:Browser"
  "Major mode for the Naviel music browser."
  (setq buffer-read-only t)
  (setq-local revert-buffer-function #'naviel--browser-refresh)
  (hl-line-mode 1))

(defun naviel--item-at-point ()
  (let ((type (get-text-property (point) 'naviel-type))
        (item (get-text-property (point) 'naviel-item)))
    (when type (cons type item))))

(defun naviel--browser-enter ()
  (interactive)
  (let ((entry (naviel--item-at-point)))
    (unless entry (user-error "No item at point"))
    (let ((type (car entry)) (item (cdr entry)))
      (pcase type
        ('artist
         (let ((id (plist-get item :id)) (name (plist-get item :name)))
           (push `(:type artist :data ,id :label ,name) naviel--browser-stack)
           (message "naviel: loading albums…")
           (naviel--get-artist
            id (lambda (albums)
                 (if albums (naviel--render-albums albums name)
                   (pop naviel--browser-stack))))))
        ('album
         ;; RET on an album: load and play
         (let ((id (plist-get item :id)) (name (plist-get item :name)))
           (push `(:type album :data ,id :label ,name) naviel--browser-stack)
           (message "naviel: loading tracks…")
           (naviel--get-album
            id (lambda (songs)
                 (if songs
                     (progn (setq naviel--queue songs naviel--queue-index 0)
                            (naviel--render-songs songs name)
                            (naviel--play-queue-index 0))
                   (pop naviel--browser-stack))))))
        ('playlist
         (let ((id (plist-get item :id)) (name (plist-get item :name)))
           (push `(:type playlist :data ,id :label ,name) naviel--browser-stack)
           (message "naviel: loading playlist…")
           (naviel--get-playlist
            id (lambda (songs)
                 (if songs
                     (progn (setq naviel--queue songs naviel--queue-index 0)
                            (naviel--render-songs songs name)
                            (naviel--play-queue-index 0))
                   (pop naviel--browser-stack))))))
        ('genre
         (let* ((name  (plist-get item :name))
                (count (min naviel-genre-song-limit
                            (string-to-number (or (plist-get item :songs) "50")))))
           (push `(:type genre :data ,name :label ,name) naviel--browser-stack)
           (message "naviel: loading genre \"%s\"..." name)
           (naviel--get-songs-by-genre
            name count 0
            (lambda (songs)
              (if songs
                  (progn (setq naviel--queue songs naviel--queue-index 0)
                         (naviel--render-songs songs (format "Genre: %s" name)
                                               (format "%d tracks" (length songs))))
                (pop naviel--browser-stack)
                (message "naviel: no songs for \"%s\"" name))))))
        ('radio
         (let* ((name (plist-get item :name))
                (url  (plist-get item :stream-url))
                (pseudo-song `(:id ,url :title ,name :artist "Internet Radio"
                               :album "" :duration "" :coverArt "")))
           (naviel--play-url url pseudo-song)))
        ('song
         (naviel--play-queue-index (get-text-property (point) 'naviel-idx)))
        (_ (message "naviel: unknown type: %s" type))))))

(defun naviel--browser-append ()
  (interactive)
  (let ((entry (naviel--item-at-point)))
    (unless entry (user-error "No item at point"))
    (let ((type (car entry)) (item (cdr entry)))
      (pcase type
        ('album
         (naviel--get-album
          (plist-get item :id)
          (lambda (songs) (when songs (naviel--append-songs-to-queue songs (plist-get item :name))))))
        ('playlist
         (naviel--get-playlist
          (plist-get item :id)
          (lambda (songs) (when songs (naviel--append-songs-to-queue songs (plist-get item :name))))))
        ('song
         (naviel--append-songs-to-queue (list item) (or (plist-get item :title) "?")))
        (_ (message "naviel: cannot append type: %s" type))))))

(defun naviel--browser-back ()
  (interactive)
  (cond
   ((null naviel--browser-stack)
    (message "naviel: already at top level"))
   ((= 1 (length naviel--browser-stack))
    (setq naviel--browser-stack '())
    (naviel--show-artists))
   (t
    (pop naviel--browser-stack)
    (let* ((frame (car naviel--browser-stack))
           (type  (plist-get frame :type))
           (id    (plist-get frame :data))
           (name  (plist-get frame :label)))
      (pcase type
        ('artist   (naviel--get-artist   id (lambda (a) (when a (naviel--render-albums a name)))))
        ('album    (naviel--get-album    id (lambda (s) (when s (naviel--render-songs  s name)))))
        ('playlist (naviel--get-playlist id (lambda (s) (when s (naviel--render-songs  s name)))))
        ('genre    (naviel--get-songs-by-genre
                    id naviel-genre-song-limit 0
                    (lambda (s) (when s (naviel--render-songs s (format "Genre: %s" id))))))
        (_         (naviel--show-artists)))))))

(defun naviel--browser-refresh (&rest _)
  (interactive)
  (if (null naviel--browser-stack)
      (naviel--show-artists)
    (let* ((frame (car naviel--browser-stack))
           (type  (plist-get frame :type))
           (id    (plist-get frame :data))
           (name  (plist-get frame :label)))
      (pcase type
        ('artist        (naviel--get-artist   id (lambda (a) (when a (naviel--render-albums a name)))))
        ('album         (naviel--get-album    id (lambda (s) (when s (naviel--render-songs  s name)))))
        ('playlist-list (naviel-playlists))
        ('playlist      (naviel--get-playlist id (lambda (s) (when s (naviel--render-songs  s name)))))
        ('genre-list    (naviel-genres))
        ('genre         (naviel--get-songs-by-genre
                         id naviel-genre-song-limit 0
                         (lambda (s) (when s (naviel--render-songs s (format "Genre: %s" id))))))
        ('album-list2   (naviel--get-album-list2
                         id naviel-album-list-size
                         (lambda (als) (when als (naviel--browser-render
                                                  name als
                                                  #'naviel--format-album-with-artist 'album)))))
        ('starred       (naviel-starred-view))
        ('radio         (naviel-radio))
        (_              (naviel--show-artists))))))

(defun naviel--browser-quit () (interactive) (quit-window))

(defun naviel--show-artists ()
  (message "naviel: loading library…")
  (naviel--get-artists
   (lambda (artists)
     (when artists
       (setq naviel--browser-stack '())
       (naviel--render-artists artists)))))

;;; Mode line

(defun naviel--mode-line-string ()
  (if naviel--current-song
      (format " %s %s%s"
              (if naviel--paused "⏸" "▶")
              (naviel--trunc (plist-get naviel--current-song :title) 28)
              (if (and naviel--elapsed naviel--duration)
                  (format "  %s/%s"
                          (naviel--format-secs naviel--elapsed)
                          (naviel--format-secs naviel--duration))
                ""))
    ""))

(defun naviel--update-mode-line () (force-mode-line-update t))

;;; Transient menu

(transient-define-prefix naviel-dispatch ()
  "Naviel command menu."
  [:class transient-columns
   ["Playback"
    ("SPC" "Pause / resume"  naviel--toggle-pause)
    ("n"   "Next track"      naviel--next-in-queue)
    ("p"   "Previous track"  naviel--prev-in-queue)
    ("["   "Seek back"       naviel-seek-backward)
    ("]"   "Seek forward"    naviel-seek-forward)
    ("+"   "Volume up"       naviel--volume-up)
    ("-"   "Volume down"     naviel--volume-down)
    ("R"   "Cycle repeat"    naviel-toggle-repeat)
    ("V"   "Visualizer"      naviel-toggle-visualizer)
    ("C"   "Viz style"       naviel-cycle-visualizer-style)]
   ["Library"
    ("s"   "Search"          naviel-search)
    ("r"   "Random"          naviel-play-random)
    ("P"   "Playlists"       naviel-playlists)
    ("N"   "Recently added"  naviel-recently-added)
    ("H"   "Recently played" naviel-recently-played)
    ("G"   "Genres"          naviel-genres)
    ("F"   "Starred"         naviel-starred-view)
    ("I"   "Internet radio"  naviel-radio)]
   ["Item / Queue"
    ("RET" "Play / expand"   naviel--browser-enter)
    ("TAB" "Inline expand"   naviel-browser-toggle-expand)
    ("a"   "Append to queue" naviel--browser-append)
    ("*"   "Toggle star"     naviel-toggle-star)
    ("l"   "Show lyrics"     naviel-lyrics-show)
    ("S"   "Shuffle queue"   naviel-queue-shuffle)
    ("b"   "Back"            naviel--browser-back)
    ("g"   "Refresh"         naviel--browser-refresh)]])

;;; Public commands

;;;###autoload
(defun naviel ()
  "Open the Naviel music browser and player."
  (interactive)
  (unless (executable-find naviel-mpv-executable)
    (error "naviel: mpv not found on PATH"))
  (naviel--ensure-layout)
  (naviel--player-render)
  (naviel--show-artists))

;;;###autoload
(defun naviel-lyrics-show ()
  "Fetch and display full lyrics for the song at point or currently playing."
  (interactive)
  (let* ((entry (naviel--item-at-point))
         (type  (car entry))
         (item  (cdr entry))
         (song  (if (eq type 'song) item naviel--current-song)))
    (unless song (user-error "naviel: no song at point or currently playing"))
    (let ((artist (or (plist-get song :artist) ""))
          (title  (or (plist-get song :title)  "")))
      (message "naviel: fetching lyrics for \"%s\"…" title)
      ;; Try lrclib first, fall back to Subsonic getLyrics
      (naviel--lrclib-fetch-full song
       (lambda (synced plain)
         (naviel--show-lyrics-buffer title artist synced plain))))))

(defun naviel--lrclib-fetch-full (song callback)
  "Fetch full lyrics from lrclib for SONG. CALLBACK receives (synced plain)."
  (let* ((title    (or (plist-get song :title)  ""))
         (artist   (or (plist-get song :artist) ""))
         (album    (or (plist-get song :album)  ""))
         (dur-str  (plist-get song :duration))
         (duration (if (and dur-str (not (string= dur-str "")))
                       (string-to-number dur-str) 0))
         (url (concat "https://lrclib.net/api/get?"
                      "track_name="   (url-hexify-string title)
                      "&artist_name=" (url-hexify-string artist)
                      "&album_name="  (url-hexify-string album)
                      (when (> duration 0)
                        (format "&duration=%d" (round duration))))))
    (url-retrieve
     url
     (lambda (status)
       (if (plist-get status :error)
           (funcall callback nil nil)
         (condition-case nil
             (progn
               (goto-char (point-min))
               (re-search-forward "\r?\n\r?\n" nil t)
               (set-buffer-multibyte t)
               (decode-coding-region (point) (point-max) 'utf-8)
               (let* ((json-object-type 'alist)
                      (json-array-type  'list)
                      (data    (json-read))
                      (synced  (cdr (assq 'syncedLyrics data)))
                      (plain   (cdr (assq 'plainLyrics  data))))
                 (kill-buffer (current-buffer))
                 (funcall callback
                          (when (and synced (not (eq synced :null))
                                     (not (string= synced ""))) synced)
                          (when (and plain  (not (eq plain  :null))
                                     (not (string= plain  ""))) plain))))
           (error (ignore-errors (kill-buffer (current-buffer)))
                  (funcall callback nil nil)))))
     nil t)))

(defun naviel--show-lyrics-buffer (title artist synced plain)
  (with-current-buffer (get-buffer-create "*Naviel Lyrics*")
    (let ((inhibit-read-only t))
      (erase-buffer)
      (special-mode)
      (local-set-key (kbd "q") #'quit-window)
      (insert (propertize (format "  %s\n" title) 'face 'naviel-header-face))
      (insert (propertize (format "  %s\n" artist) 'face 'naviel-artist-face))
      (insert (propertize (make-string (min 80 (window-width)) ?─) 'face 'naviel-separator-face))
      (insert "\n\n")
      (cond
       (synced
        (insert (propertize "  (synced · lrclib.net)\n\n" 'face 'naviel-footer-face))
        (dolist (entry (naviel--parse-lrc synced))
          (insert (format "  %s\n"
                          (propertize (cdr entry) 'face 'naviel-lyrics-nosync-face)))))
       (plain
        (insert (propertize "  (plain · lrclib.net)\n\n" 'face 'naviel-footer-face))
        (dolist (ln (split-string plain "\n"))
          (insert (format "  %s\n" (propertize ln 'face 'naviel-lyrics-nosync-face)))))
       (t
        (insert (propertize "  No lyrics found on lrclib.net.\n" 'face 'shadow))))
      (insert "\n")
      (insert (propertize "  q  close" 'face 'naviel-footer-face))
      (insert "\n")
      (goto-char (point-min))))
  (pop-to-buffer "*Naviel Lyrics*"))

;;;###autoload
(defun naviel-starred-view ()
  "Show all starred artists, albums, and songs."
  (interactive)
  (message "naviel: loading starred items…")
  (naviel--get-starred2
   (lambda (results)
     (if (null results)
         (message "naviel: nothing starred yet")
       (let ((artists (plist-get results :artists))
             (albums  (plist-get results :albums))
             (songs   (plist-get results :songs)))
         (dolist (a artists) (naviel--star-cache-set (plist-get a :id) t))
         (dolist (al albums)  (naviel--star-cache-set (plist-get al :id) t))
         (dolist (s  songs)   (naviel--star-cache-set (plist-get s :id)  t))
         (push `(:type starred :data nil :label "Starred") naviel--browser-stack)
         (pop-to-buffer (naviel--browser-buffer))
         (naviel-browser-mode)
         (let ((inhibit-read-only t))
           (erase-buffer)
           (insert (naviel--make-breadcrumbs))
           (insert (propertize "  ★  Starred\n" 'face 'naviel-header-face))
           (insert (propertize (make-string (min 80 (window-width)) ?─)
                               'face 'naviel-separator-face))
           (insert "\n")
           (cl-flet ((section (label items type fmt-fn)
                       (when items
                         (insert (propertize (format "\n  %s\n" label)
                                             'face 'naviel-breadcrumb-face))
                         (let ((idx 0))
                           (dolist (item items)
                             (insert (propertize (funcall fmt-fn item nil)
                                                 'naviel-item item
                                                 'naviel-type type
                                                 'naviel-idx  idx))
                             (insert "\n")
                             (cl-incf idx))))))
             (section "Artists" artists 'artist #'naviel--format-artist)
             (section "Albums"  albums  'album  #'naviel--format-album-with-artist)
             (when songs
               (insert (propertize "\n  Songs\n" 'face 'naviel-breadcrumb-face))
               (setq naviel--queue songs naviel--queue-index 0)
               (let ((idx 0))
                 (dolist (s songs)
                   (insert (propertize (naviel--format-song s nil)
                                       'naviel-item s 'naviel-type 'song 'naviel-idx idx))
                   (insert "\n")
                   (cl-incf idx))))
             (when (and (null artists) (null albums) (null songs))
               (insert (propertize "  Nothing starred yet.\n" 'face 'shadow))))
           (insert (propertize (make-string (min 80 (window-width)) ?─) 'face 'naviel-separator-face))
           (insert "\n")
           (insert (propertize "  RET play  TAB expand  a append  * star  ? menu" 'face 'naviel-footer-face))
           (insert "\n")
           (goto-char (point-min))
           (forward-line 3)))))))

;;;###autoload
(defun naviel-radio ()
  "Browse and play internet radio stations."
  (interactive)
  (message "naviel: loading radio stations…")
  (naviel--get-radio-stations
   (lambda (stations)
     (if (null stations)
         (message "naviel: no internet radio stations configured on this server")
       (push `(:type radio :data nil :label "Internet Radio") naviel--browser-stack)
       (naviel--browser-render
        (format "Internet Radio  (%d stations)" (length stations))
        stations #'naviel--format-radio 'radio)))))

;;;###autoload
(defun naviel-search (query)
  (interactive "sSearch Naviel: ")
  (when (string= query "") (user-error "Search query cannot be empty"))
  (message "naviel: searching…")
  (naviel--search-async
   query
   (lambda (results)
     (when results
       (let ((artists (plist-get results :artists))
             (albums  (plist-get results :albums))
             (songs   (plist-get results :songs)))
         (naviel--prime-star-cache artists :id :starred)
         (naviel--prime-star-cache albums  :id :starred)
         (naviel--prime-star-cache songs   :id :starred)
         (pop-to-buffer (naviel--browser-buffer))
         (naviel-browser-mode)
         (let ((inhibit-read-only t))
           (erase-buffer)
           (insert (propertize (format "  Search: %s\n" query) 'face 'naviel-header-face))
           (insert (propertize (make-string (min 80 (window-width)) ?─)
                               'face 'naviel-separator-face))
           (insert "\n")
           (cl-flet ((section (label items type fmt-fn)
                       (when items
                         (insert (propertize (format "\n  %s\n" label)
                                             'face 'naviel-breadcrumb-face))
                         (let ((idx 0))
                           (dolist (item items)
                             (insert (propertize (funcall fmt-fn item nil)
                                                 'naviel-item item 'naviel-type type
                                                 'naviel-idx idx))
                             (insert "\n") (cl-incf idx))))))
             (section "Artists" artists 'artist #'naviel--format-artist)
             (section "Albums"  albums  'album  #'naviel--format-album-with-artist)
             (when songs
               (insert (propertize "\n  Songs\n" 'face 'naviel-breadcrumb-face))
               (setq naviel--queue songs naviel--queue-index 0)
               (let ((idx 0))
                 (dolist (s songs)
                   (insert (propertize (naviel--format-song s nil)
                                       'naviel-item s 'naviel-type 'song 'naviel-idx idx))
                   (insert "\n") (cl-incf idx))))
             (when (and (null artists) (null albums) (null songs))
               (insert (propertize "  No results found.\n" 'face 'shadow))))
           (insert (propertize (make-string (min 80 (window-width)) ?─) 'face 'naviel-separator-face))
           (insert "\n")
           (insert (propertize "  RET play  TAB expand  a append  * star  ? menu" 'face 'naviel-footer-face))
           (insert "\n")
           (goto-char (point-min))
           (forward-line 3)))))))

;;;###autoload
(defun naviel-play-random (&optional count)
  (interactive "P")
  (let ((n (if count (prefix-numeric-value count) 20)))
    (message "naviel: fetching %d random tracks…" n)
    (naviel--get-random-songs
     n (lambda (songs)
         (when songs
           (setq naviel--queue songs naviel--queue-index 0)
           (pop-to-buffer (naviel--browser-buffer))
           (naviel--render-songs songs (format "Random  –  %d tracks" n))
           (naviel--play-queue-index 0))))))

;;;###autoload
(defun naviel-stop ()
  (interactive)
  (naviel--stop)
  (message "naviel: stopped"))

;;;###autoload
(defun naviel-playlists ()
  (interactive)
  (message "naviel: loading playlists…")
  (naviel--get-playlists
   (lambda (pls)
     (if (null pls) (message "naviel: no playlists found")
       (push `(:type playlist-list :data nil :label "Playlists") naviel--browser-stack)
       (naviel--browser-render (format "Playlists  (%d)" (length pls))
                               pls #'naviel--format-playlist 'playlist)))))

;;;###autoload
(defun naviel-recently-added (&optional size)
  (interactive "P")
  (let ((n (if size (prefix-numeric-value size) naviel-album-list-size)))
    (message "naviel: fetching recently added…")
    (naviel--get-album-list2
     "newest" n
     (lambda (albums)
       (if (null albums) (message "naviel: no results")
         (push `(:type album-list2 :data "newest" :label "Recently Added") naviel--browser-stack)
         (naviel--browser-render (format "Recently Added  (%d)" (length albums))
                                 albums #'naviel--format-album-with-artist 'album))))))

;;;###autoload
(defun naviel-recently-played (&optional size)
  (interactive "P")
  (let ((n (if size (prefix-numeric-value size) naviel-album-list-size)))
    (message "naviel: fetching recently played…")
    (naviel--get-album-list2
     "recent" n
     (lambda (albums)
       (if (null albums) (message "naviel: no results")
         (push `(:type album-list2 :data "recent" :label "Recently Played") naviel--browser-stack)
         (naviel--browser-render (format "Recently Played  (%d)" (length albums))
                                 albums #'naviel--format-album-with-artist 'album))))))

;;;###autoload
(defun naviel-genres ()
  (interactive)
  (message "naviel: loading genres…")
  (naviel--get-genres
   (lambda (genres)
     (if (null genres) (message "naviel: no genres found")
       (setq genres
             (sort genres (lambda (a b)
                            (> (string-to-number (or (plist-get a :songs) "0"))
                               (string-to-number (or (plist-get b :songs) "0"))))))
       (push `(:type genre-list :data nil :label "Genres") naviel--browser-stack)
       (naviel--browser-render (format "Genres  (%d)" (length genres))
                               genres #'naviel--format-genre 'genre)))))

;;; Mode line integration

(defvar naviel-mode-line-format '(:eval (naviel--mode-line-string)))

;;;###autoload
(define-minor-mode naviel-mode-line-mode
  "Show Naviel playback status in the mode line."
  :global t :lighter nil
  (if naviel-mode-line-mode
      (progn
        (add-to-list 'global-mode-string naviel-mode-line-format)
        (setq naviel--mode-line-timer (run-with-timer 1 1 #'naviel--update-mode-line)))
    (setq global-mode-string (remove naviel-mode-line-format global-mode-string))
    (when naviel--mode-line-timer
      (cancel-timer naviel--mode-line-timer)
      (setq naviel--mode-line-timer nil))))

(provide 'naviel)
;;; naviel.el ends here