;;;; player.lisp - ParenScript version of player.js
;;;; Web Player functionality including audio playback, playlists, queue management, and live streaming

(in-package #:asteroid)

(defparameter *player-js*
  (ps:ps*
   '(progn
    
    ;; Global variables
    (defvar *tracks* (array))
    (defvar *current-track* nil)
    (defvar *current-track-index* -1)
    (defvar *play-queue* (array))
    (defvar *is-shuffled* nil)
    (defvar *is-repeating* nil)
    (defvar *audio-player* nil)
    
    ;; Pagination variables for track library
    (defvar *library-current-page* 1)
    (defvar *library-tracks-per-page* 20)
    (defvar *filtered-library-tracks* (array))
    
    ;; Initialize player on page load
    (ps:chain document
              (add-event-listener
               "DOMContentLoaded"
               (lambda ()
                 (setf *audio-player* (ps:chain document (get-element-by-id "audio-player")))
                 (redirect-when-frame)
                 (load-tracks)
                 (load-playlists)
                 (setup-event-listeners)
                 (update-player-display)
                 (update-volume)
                 
                 ;; Setup live stream with reduced buffering and reconnect logic
                 (let ((live-audio (ps:chain document (get-element-by-id "live-stream-audio"))))
                   (when live-audio
                     ;; Reduce buffer to minimize delay
                     (setf (ps:@ live-audio preload) "none")
                     
                     ;; Add reconnect logic for long pauses
                     (let ((pause-timestamp nil)
                           (is-reconnecting false)
                           (needs-reconnect false)
                           (pause-reconnect-threshold 10000))
                       
                       (ps:chain live-audio
                                 (add-event-listener "pause"
                                   (lambda ()
                                     (setf pause-timestamp (ps:chain |Date| (now)))
                                     (ps:chain console (log "Live stream paused at:" pause-timestamp)))))
                       
                       (ps:chain live-audio
                                 (add-event-listener "play"
                                   (lambda ()
                                     (when (and (not is-reconnecting)
                                                pause-timestamp
                                                (> (- (ps:chain |Date| (now)) pause-timestamp) pause-reconnect-threshold))
                                       (setf needs-reconnect true)
                                       (ps:chain console (log "Long pause detected, will reconnect when playing starts...")))
                                     (setf pause-timestamp nil))))
                       
                       (ps:chain live-audio
                                 (add-event-listener "playing"
                                   (lambda ()
                                     (when (and needs-reconnect (not is-reconnecting))
                                       (setf is-reconnecting true)
                                       (setf needs-reconnect false)
                                       (ps:chain console (log "Reconnecting live stream after long pause to clear stale buffers..."))
                                       
                                       (ps:chain live-audio (pause))
                                       
                                       (when (ps:@ window |resetSpectrumAnalyzer|)
                                         (ps:chain window (reset-spectrum-analyzer)))
                                       
                                       (ps:chain live-audio (load))
                                       
                                       (set-timeout
                                         (lambda ()
                                           (ps:chain live-audio (play)
                                                     (catch (lambda (err)
                                                              (ps:chain console (log "Reconnect play failed:" err)))))
                                           
                                           (when (ps:@ window |initSpectrumAnalyzer|)
                                             (ps:chain window (init-spectrum-analyzer))
                                             (ps:chain console (log "Spectrum analyzer reinitialized after reconnect")))
                                           
                                           (setf is-reconnecting false))
                                         200)))))
                       )))
                 
                 ;; Restore user quality preference
                 (let ((selector (ps:chain document (get-element-by-id "live-stream-quality")))
                       (stream-quality (or (ps:chain local-storage (get-item "stream-quality")) "aac")))
                   (when (and selector (not (= (ps:@ selector value) stream-quality)))
                     (setf (ps:@ selector value) stream-quality)
                     (ps:chain selector (dispatch-event (ps:new (-Event "change")))))))))
    
    ;; Frame redirection logic
    (defun redirect-when-frame ()
      (let* ((path (ps:@ window location pathname))
            (is-frameset-page (not (= (ps:@ window parent) (ps:@ window self))))
            (is-content-frame (ps:chain path (includes "player-content"))))
        
        (when (and is-frameset-page (not is-content-frame))
          (setf (ps:@ window location href) "/asteroid/player-content"))
        
        (when (and (not is-frameset-page) is-content-frame)
          (setf (ps:@ window location href) "/asteroid/player"))))
    
    ;; Setup all event listeners
    (defun setup-event-listeners ()
      ;; Search
      (ps:chain (ps:chain document (get-element-by-id "search-tracks"))
                (add-event-listener "input" filter-tracks))
      
      ;; Player controls
      (ps:chain (ps:chain document (get-element-by-id "play-pause-btn"))
                (add-event-listener "click" toggle-play-pause))
      (ps:chain (ps:chain document (get-element-by-id "prev-btn"))
                (add-event-listener "click" play-previous))
      (ps:chain (ps:chain document (get-element-by-id "next-btn"))
                (add-event-listener "click" play-next))
      (ps:chain (ps:chain document (get-element-by-id "shuffle-btn"))
                (add-event-listener "click" toggle-shuffle))
      (ps:chain (ps:chain document (get-element-by-id "repeat-btn"))
                (add-event-listener "click" toggle-repeat))
      
      ;; Volume control
      (ps:chain (ps:chain document (get-element-by-id "volume-slider"))
                (add-event-listener "input" update-volume))
      
      ;; Audio player events
      (when (and *audio-player* (ps:chain *audio-player* add-event-listener))
        (ps:chain *audio-player* (add-event-listener "loadedmetadata" update-time-display))
        (ps:chain *audio-player* (add-event-listener "timeupdate" update-time-display))
        (ps:chain *audio-player* (add-event-listener "ended" handle-track-end))
        (ps:chain *audio-player* (add-event-listener "play" (lambda () (update-play-button "⏸️ Pause"))))
        (ps:chain *audio-player* (add-event-listener "pause" (lambda () (update-play-button "▶️ Play")))))
      
      ;; Playlist controls
      (ps:chain (ps:chain document (get-element-by-id "create-playlist"))
                (add-event-listener "click" create-playlist))
      (ps:chain (ps:chain document (get-element-by-id "clear-queue"))
                (add-event-listener "click" clear-queue))
      (ps:chain (ps:chain document (get-element-by-id "save-queue"))
                (add-event-listener "click" save-queue-as-playlist)))
    
    ;; Load tracks from API
    (defun load-tracks ()
      (ps:chain
       (ps:chain (fetch "/api/asteroid/tracks"))
       (then (lambda (response)
               (if (ps:@ response ok)
                   (ps:chain response (json))
                   (progn
                     (ps:chain console (error (+ "HTTP " (ps:@ response status))))
                     (ps:create :status "error" :tracks (array))))))
       (then (lambda (result)
               ;; Handle RADIANCE API wrapper format
               (let ((data (or (ps:@ result data) result)))
                 (if (= (ps:@ data status) "success")
                     (progn
                       (setf *tracks* (or (ps:@ data tracks) (array)))
                       (display-tracks *tracks*))
                     (progn
                       (ps:chain console (error "Error loading tracks:" (ps:@ data error)))
                       (setf (ps:chain (ps:chain document (get-element-by-id "track-list")) inner-h-t-m-l)
                             "<div class=\"error\">Error loading tracks</div>"))))))
       (catch (lambda (error)
                (ps:chain console (error "Error loading tracks:" error))
                (setf (ps:chain (ps:chain document (get-element-by-id "track-list")) inner-h-t-m-l)
                      "<div class=\"error\">Error loading tracks</div>")))))
    
    ;; Display tracks in library
    (defun display-tracks (track-list)
      (setf *filtered-library-tracks* track-list)
      (setf *library-current-page* 1)
      (render-library-page))
    
    ;; Render current library page
    (defun render-library-page ()
      (let ((container (ps:chain document (get-element-by-id "track-list")))
            (pagination-controls (ps:chain document (get-element-by-id "library-pagination-controls"))))
        
        (if (= (ps:@ *filtered-library-tracks* length) 0)
            (progn
              (setf (ps:@ container inner-h-t-m-l) "<div class=\"no-tracks\">No tracks found</div>")
              (setf (ps:@ pagination-controls style display) "none")
              (return)))
        
        ;; Calculate pagination
        (let* ((total-pages (ceiling (/ (ps:@ *filtered-library-tracks* length) *library-tracks-per-page*)))
              (start-index (* (- *library-current-page* 1) *library-tracks-per-page*))
              (end-index (+ start-index *library-tracks-per-page*))
              (tracks-to-show (ps:chain *filtered-library-tracks* (slice start-index end-index))))
          
          ;; Render tracks for current page
          (let ((tracks-html (ps:chain tracks-to-show
                                      (map (lambda (track page-index)
                                             ;; Find the actual index in the full tracks array
                                             (let ((actual-index (ps:chain *tracks* 
                                                                       (find-index (lambda (trk) (= (ps:@ trk id) (ps:@ track id)))))))
                                               (+ "<div class=\"track-item\" data-track-id=\"" (ps:@ track id) "\" data-index=\"" actual-index "\">"
                                                  "<div class=\"track-info\">"
                                                  "<div class=\"track-title\">" (or (ps:@ track title) "Unknown Title") "</div>"
                                                  "<div class=\"track-meta\">" (or (ps:@ track artist) "Unknown Artist") " • " (or (ps:@ track album) "Unknown Album") "</div>"
                                                  "</div>"
                                                  "<div class=\"track-actions\">"
                                                  "<button onclick=\"playTrack(" actual-index ")\" class=\"btn btn-sm btn-success\" title=\"Play\">▶️</button>"
                                                  "<button onclick=\"addToQueue(" actual-index ")\" class=\"btn btn-sm btn-info\" title=\"Add to queue\">➕</button>"
                                                  "<button onclick=\"showAddToPlaylistMenu(" (ps:@ track id) ", event)\" class=\"btn btn-sm btn-secondary\" title=\"Add to playlist\">📋</button>"
                                                  "</div>"
                                                  "</div>"))))
                                      (join ""))))
            
            (setf (ps:@ container inner-h-t-m-l) tracks-html)
            
            ;; Update pagination controls
            (setf (ps:chain (ps:chain document (get-element-by-id "library-page-info")) text-content)
                  (+ "Page " *library-current-page* " of " total-pages " (" (ps:@ *filtered-library-tracks* length) " tracks)"))
            (setf (ps:@ pagination-controls style display) 
                  (if (> total-pages 1) "block" "none"))))))
    
    ;; Library pagination functions
    (defun library-go-to-page (page)
      (let ((total-pages (ceiling (/ (ps:@ *filtered-library-tracks* length) *library-tracks-per-page*))))
        (when (and (>= page 1) (<= page total-pages))
          (setf *library-current-page* page)
          (render-library-page))))
    
    (defun library-previous-page ()
      (when (> *library-current-page* 1)
        (setf *library-current-page* (- *library-current-page* 1))
        (render-library-page)))
    
    (defun library-next-page ()
      (let ((total-pages (ceiling (/ (ps:@ *filtered-library-tracks* length) *library-tracks-per-page*))))
        (when (< *library-current-page* total-pages)
          (setf *library-current-page* (+ *library-current-page* 1))
          (render-library-page))))
    
    (defun library-go-to-last-page ()
      (let ((total-pages (ceiling (/ (ps:@ *filtered-library-tracks* length) *library-tracks-per-page*))))
        (setf *library-current-page* total-pages)
        (render-library-page)))
    
    (defun change-library-tracks-per-page ()
      (setf *library-tracks-per-page* 
            (parse-int (ps:chain (ps:chain document (get-element-by-id "library-tracks-per-page")) value)))
      (setf *library-current-page* 1)
      (render-library-page))
    
    ;; Filter tracks based on search query
    (defun filter-tracks ()
      (let ((query (ps:chain (ps:chain document (get-element-by-id "search-tracks")) value (to-lower-case))))
        (let ((filtered (ps:chain *tracks* 
                                   (filter (lambda (track)
                                             (or (ps:chain (or (ps:@ track title) "") (to-lower-case) (includes query))
                                                 (ps:chain (or (ps:@ track artist) "") (to-lower-case) (includes query))
                                                 (ps:chain (or (ps:@ track album) "") (to-lower-case) (includes query))))))))
          (display-tracks filtered))))
    
    ;; Play a specific track by index
    (defun play-track (index)
      (when (and (>= index 0) (< index (ps:@ *tracks* length)))
        (setf *current-track* (aref *tracks* index))
        (setf *current-track-index* index)
        
        ;; Load track into audio player
        (setf (ps:@ *audio-player* src) (+ "/asteroid/tracks/" (ps:@ *current-track* id) "/stream"))
        (ps:chain *audio-player* (load))
        (ps:chain *audio-player* 
                  (play)
                  (catch (lambda (error)
                           (ps:chain console (error "Playback error:" error))
                           (alert "Error playing track. The track may not be available."))))
        
        (update-player-display)
        
        ;; Update server-side player state
        (ps:chain (fetch (+ "/api/asteroid/player/play?track-id=" (ps:@ *current-track* id))
                         (ps:create :method "POST"))
                  (catch (lambda (error)
                           (ps:chain console (error "API update error:" error)))))))
    
    ;; Toggle play/pause
    (defun toggle-play-pause ()
      (if *current-track*
          (if (ps:@ *audio-player* paused)
              (ps:chain *audio-player* (play))
              (ps:chain *audio-player* (pause)))
          (alert "Please select a track to play")))
    
    ;; Play previous track
    (defun play-previous ()
      (if (> (ps:@ *play-queue* length) 0)
          ;; Play from queue
          (let ((prev-index (max 0 (- *current-track-index* 1))))
            (play-track prev-index))
          ;; Play previous track in library
          (let ((prev-index (if (> *current-track-index* 0) 
                                (- *current-track-index* 1) 
                                (- (ps:@ *tracks* length) 1))))
            (play-track prev-index))))
    
    ;; Play next track
    (defun play-next ()
      (if (> (ps:@ *play-queue* length) 0)
          ;; Play from queue
          (let ((next-track (ps:chain *play-queue* (shift))))
            (play-track (ps:chain *tracks* 
                                  (find-index (lambda (trk) (= (ps:@ trk id) (ps:@ next-track id))))))
            (update-queue-display))
          ;; Play next track in library
          (let ((next-index (if *is-shuffled*
                                (floor (* (random) (ps:@ *tracks* length)))
                                (mod (+ *current-track-index* 1) (ps:@ *tracks* length)))))
            (play-track next-index))))
    
    ;; Handle track end
    (defun handle-track-end ()
      (if *is-repeating*
          (progn
            (setf (ps:@ *audio-player* current-time) 0)
            (ps:chain *audio-player* (play)))
          (play-next)))
    
    ;; Toggle shuffle mode
    (defun toggle-shuffle ()
      (setf *is-shuffled* (not *is-shuffled*))
      (let ((btn (ps:chain document (get-element-by-id "shuffle-btn"))))
        (setf (ps:@ btn text-content) (if *is-shuffled* "🔀 Shuffle ON" "🔀 Shuffle"))
        (ps:chain btn (class-list toggle "active" *is-shuffled*))))
    
    ;; Toggle repeat mode
    (defun toggle-repeat ()
      (setf *is-repeating* (not *is-repeating*))
      (let ((btn (ps:chain document (get-element-by-id "repeat-btn"))))
        (setf (ps:@ btn text-content) (if *is-repeating* "🔁 Repeat ON" "🔁 Repeat"))
        (ps:chain btn (class-list toggle "active" *is-repeating*))))
    
    ;; Update volume
    (defun update-volume ()
      (let ((volume (/ (parse-int (ps:chain (ps:chain document (get-element-by-id "volume-slider")) value)) 100)))
        (when *audio-player*
          (setf (ps:@ *audio-player* volume) volume))))
    
    ;; Update time display
    (defun update-time-display ()
      (let ((current (format-time (ps:@ *audio-player* current-time)))
            (total (format-time (ps:@ *audio-player* duration))))
        (setf (ps:chain (ps:chain document (get-element-by-id "current-time")) text-content) current)
        (setf (ps:chain (ps:chain document (get-element-by-id "total-time")) text-content) total)))
    
    ;; Format time helper
    (defun format-time (seconds)
      (if (isNaN seconds)
          "0:00"
          (let ((mins (floor (/ seconds 60)))
                (secs (floor (mod seconds 60))))
            (+ mins ":" (ps:chain secs (to-string)  (pad-start 2 "0"))))))
    
    ;; Update play button text
    (defun update-play-button (text)
      (setf (ps:chain (ps:chain document (get-element-by-id "play-pause-btn")) text-content) text))
    
    ;; Update player display with current track info
    (defun update-player-display ()
      (when *current-track*
        (setf (ps:chain (ps:chain document (get-element-by-id "current-title")) text-content)
              (or (ps:@ *current-track* title) "Unknown Title"))
        (setf (ps:chain (ps:chain document (get-element-by-id "current-artist")) text-content)
              (or (ps:@ *current-track* artist) "Unknown Artist"))
        (setf (ps:chain (ps:chain document (get-element-by-id "current-album")) text-content)
              (or (ps:@ *current-track* album) "Unknown Album"))))
    
    ;; Add track to queue
    (defun add-to-queue (index)
      (when (and (>= index 0) (< index (ps:@ *tracks* length)))
        (setf (aref *play-queue* (ps:@ *play-queue* length)) (aref *tracks* index))
        (update-queue-display)))
    
    ;; Update queue display
    (defun update-queue-display ()
      (let ((container (ps:chain document (get-element-by-id "play-queue"))))
        (if (= (ps:@ *play-queue* length) 0)
            (setf (ps:@ container inner-h-t-m-l) "<div class=\"empty-queue\">Queue is empty</div>")
            (let ((queue-html (ps:chain *play-queue*
                                         (map (lambda (track index)
                                                (+ "<div class=\"queue-item\">"
                                                   "<div class=\"track-info\">"
                                                   "<div class=\"track-title\">" (or (ps:@ track title) "Unknown Title") "</div>"
                                                   "<div class=\"track-meta\">" (or (ps:@ track artist) "Unknown Artist") "</div>"
                                                   "</div>"
                                                   "<button onclick=\"removeFromQueue(" index ")\" class=\"btn btn-sm btn-danger\">✖️</button>"
                                                   "</div>")))
                                         (join ""))))
              (setf (ps:@ container inner-h-t-m-l) queue-html)))))
    
    ;; Remove track from queue
    (defun remove-from-queue (index)
      (ps:chain *play-queue* (splice index 1))
      (update-queue-display))
    
    ;; Clear queue
    (defun clear-queue ()
      (setf *play-queue* (array))
      (update-queue-display))
    
    ;; Store playlists for the add-to-playlist menu
    (defvar *user-playlists* (array))
    
    ;; Show add to playlist dropdown menu
    (defun show-add-to-playlist-menu (track-id event)
      (ps:chain event (stop-propagation))
      ;; Remove any existing menu
      (let ((existing-menu (ps:chain document (get-element-by-id "playlist-dropdown-menu"))))
        (when existing-menu
          (ps:chain existing-menu (remove))))
      
      ;; Fetch playlists and show menu
      (ps:chain (fetch "/api/asteroid/playlists")
                (then (lambda (response) (ps:chain response (json))))
                (then (lambda (result)
                        (let* ((data (or (ps:@ result data) result))
                               (playlists (or (ps:@ data playlists) (array)))
                               (menu (ps:chain document (create-element "div"))))
                          (setf *user-playlists* playlists)
                          (setf (ps:@ menu id) "playlist-dropdown-menu")
                          (setf (ps:@ menu class-name) "playlist-dropdown-menu")
                          (setf (ps:@ menu style position) "fixed")
                          (setf (ps:@ menu style left) (+ (ps:@ event client-x) "px"))
                          (setf (ps:@ menu style top) (+ (ps:@ event client-y) "px"))
                          (setf (ps:@ menu style z-index) "1000")
                          (setf (ps:@ menu style background) "#1a1a2e")
                          (setf (ps:@ menu style border) "1px solid #00ff00")
                          (setf (ps:@ menu style border-radius) "4px")
                          (setf (ps:@ menu style padding) "5px 0")
                          (setf (ps:@ menu style min-width) "150px")
                          
                          (if (= (ps:@ playlists length) 0)
                              (setf (ps:@ menu inner-h-t-m-l) 
                                    "<div style=\"padding: 8px 12px; color: #888;\">No playlists yet</div>")
                              (setf (ps:@ menu inner-h-t-m-l)
                                    (ps:chain playlists
                                              (map (lambda (playlist)
                                                     (+ "<div class=\"playlist-menu-item\" onclick=\"addTrackToPlaylist(" 
                                                        (ps:@ playlist id) ", " track-id 
                                                        ")\" style=\"padding: 8px 12px; cursor: pointer; color: #00ff00;\" "
                                                        "onmouseover=\"this.style.background='#2a2a4e'\" "
                                                        "onmouseout=\"this.style.background='transparent'\">"
                                                        (ps:@ playlist name) " (" (ps:@ playlist "track-count") ")"
                                                        "</div>")))
                                              (join ""))))
                          
                          (ps:chain document body (append-child menu))
                          
                          ;; Close menu when clicking elsewhere
                          (let ((close-handler (lambda (e)
                                                 (when (not (ps:chain menu (contains (ps:@ e target))))
                                                   (ps:chain menu (remove))
                                                   (ps:chain document (remove-event-listener "click" close-handler))))))
                            (set-timeout (lambda ()
                                           (ps:chain document (add-event-listener "click" close-handler)))
                                         100)))))
                (catch (lambda (error)
                         (ps:chain console (error "Error loading playlists for menu:" error))))))
    
    ;; Add track to a specific playlist
    (defun add-track-to-playlist (playlist-id track-id)
      ;; Close the menu
      (let ((menu (ps:chain document (get-element-by-id "playlist-dropdown-menu"))))
        (when menu (ps:chain menu (remove))))
      
      (let ((form-data (ps:new (-Form-data))))
        (ps:chain form-data (append "playlist-id" playlist-id))
        (ps:chain form-data (append "track-id" track-id))
        (ps:chain (fetch "/api/asteroid/playlists/add-track"
                         (ps:create :method "POST" :body form-data))
                  (then (lambda (response) (ps:chain response (json))))
                  (then (lambda (result)
                          (let ((data (or (ps:@ result data) result)))
                            (if (= (ps:@ data status) "success")
                                (progn
                                  ;; Find playlist name for feedback
                                  (let ((playlist (ps:chain *user-playlists* 
                                                            (find (lambda (p) (= (ps:@ p id) playlist-id))))))
                                    (alert (+ "Track added to \"" (if playlist (ps:@ playlist name) "playlist") "\"")))
                                  (load-playlists))
                                (alert (+ "Error: " (ps:@ data message)))))))
                  (catch (lambda (error)
                           (ps:chain console (error "Error adding track to playlist:" error))
                           (alert "Error adding track to playlist"))))))
    
    ;; Create playlist
    (defun create-playlist ()
      (let ((name (ps:chain (ps:chain document (get-element-by-id "new-playlist-name")) value (trim))))
        (when (not (= name ""))
          (let ((form-data (ps:new (-Form-data))))
            (ps:chain form-data (append "name" name))
            (ps:chain form-data (append "description" ""))
            
            (ps:chain (fetch "/api/asteroid/playlists/create"
                             (ps:create :method "POST" :body form-data))
                      (then (lambda (response)
                              (ps:chain response (json))))
                      (then (lambda (result)
                              ;; Handle RADIANCE API wrapper format
                              (let ((data (or (ps:@ result data) result)))
                                (if (= (ps:@ data status) "success")
                                    (progn
                                      (alert (+ "Playlist \"" name "\" created successfully!"))
                                      (setf (ps:chain (ps:chain document (get-element-by-id "new-playlist-name")) value) "")
                                      
                                      ;; Wait a moment then reload playlists
                                      (set-timeout load-playlists 500))
                                    (alert (+ "Error creating playlist: " (ps:@ data message)))))))
                      (catch (lambda (error)
                               (ps:chain console (error "Error creating playlist:" error))
                               (alert (+ "Error creating playlist: " (ps:@ error message))))))))))
    
    ;; Save queue as playlist
    (defun save-queue-as-playlist ()
      (if (> (ps:@ *play-queue* length) 0)
          (let ((name (prompt "Enter playlist name:")))
            (when name
              ;; Create the playlist
              (let ((form-data (ps:new (-Form-data))))
                (ps:chain form-data (append "name" name))
                (ps:chain form-data (append "description" (+ "Created from queue with " (ps:@ *play-queue* length) " tracks")))
                
                (ps:chain (fetch "/api/asteroid/playlists/create"
                                 (ps:create :method "POST" :body form-data))
                          (then (lambda (response) (ps:chain response (json))))
                          (then (lambda (create-result)
                                  ;; Handle RADIANCE API wrapper format
                                  (let ((create-data (or (ps:@ create-result data) create-result)))
                                    (if (= (ps:@ create-data status) "success")
                                        (progn
                                          ;; Wait a moment for database to update, then fetch playlists
                                          (set-timeout 
                                           (lambda ()
                                             ;; Get the new playlist ID by fetching playlists
                                             (ps:chain (fetch "/api/asteroid/playlists")
                                                       (then (lambda (response) (ps:chain response (json))))
                                                       (then (lambda (playlists-result)
                                                               ;; Handle RADIANCE API wrapper format
                                                               (let ((playlist-result-data (or (ps:@ playlists-result data) playlists-result)))
                                                                 (if (and (= (ps:@ playlist-result-data status) "success")
                                                                          (> (ps:@ playlist-result-data playlists length) 0))
                                                                     (progn
                                                                       ;; Find the playlist with matching name (most recent)
                                                                       (let ((new-playlist (or (ps:chain (ps:@ playlist-result-data playlists)
                                                                                                         (find (lambda (p) (= (ps:@ p name) name))))
                                                                                               (aref (ps:@ playlist-result-data playlists)
                                                                                                     (- (ps:@ playlist-result-data playlists length) 1)))))
                                                                         
                                                                         ;; Add all tracks from queue to playlist
                                                                         (let ((added-count 0))
                                                                           (ps:chain *play-queue*
                                                                                     (for-each (lambda (track)
                                                                                                 (let ((track-id (ps:@ track id)))
                                                                                                   (when track-id
                                                                                                     (let ((add-form-data (ps:new (-Form-data))))
                                                                                                       (ps:chain add-form-data (append "playlist-id" (ps:@ new-playlist id)))
                                                                                                       (ps:chain add-form-data (append "track-id" track-id))
                                                                                                       
                                                                                                       (ps:chain (fetch "/api/asteroid/playlists/add-track"
                                                                                                                        (ps:create :method "POST" :body add-form-data))
                                                                                                                 (then (lambda (response) (ps:chain response (json))))
                                                                                                                 (then (lambda (add-result)
                                                                                                                         (when (= (ps:@ add-result data status) "success")
                                                                                                                           (setf added-count (+ added-count 1)))))
                                                                                                                 (catch (lambda (err)
                                                                                                                          (ps:chain console (log "Error adding track:" err)))))))))))
                                                                           
                                                                           (alert (+ "Playlist \"" name "\" created with " added-count " tracks!"))
                                                                           (load-playlists))))
                                                                     (progn
                                                                       (alert (+ "Playlist created but could not add tracks. Error: "
                                                                                 (or (ps:@ playlist-result-data message) "Unknown")))
                                                                       (load-playlists))))))
                                                       (catch (lambda (error)
                                                                (ps:chain console (error "Error fetching playlists:" error))
                                                                (alert "Playlist created but could not add tracks")))))
                                           500))
                                        (alert (+ "Error creating playlist: " (ps:@ create-data message)))))))
                          (catch (lambda (error)
                                   (ps:chain console (error "Error saving queue as playlist:" error))
                                   (alert (+ "Error saving queue as playlist: " (ps:@ error message)))))))))
          (alert "Queue is empty")))
    
    ;; Load playlists from API
    (defun load-playlists ()
      (ps:chain
       (fetch "/api/asteroid/playlists")
       (then (lambda (response) (ps:chain response (json))))
       (then (lambda (result)
               (ps:chain console (log "Playlists API result:" result))
               (let ((playlists (cond
                                  ((and (ps:@ result data) (= (ps:@ result data status) "success"))
                                   (ps:chain console (log "Found playlists in result.data.playlists"))
                                   (or (ps:@ result data playlists) (array)))
                                  ((= (ps:@ result status) "success")
                                   (ps:chain console (log "Found playlists in result.playlists"))
                                   (or (ps:@ result playlists) (array)))
                                  (t
                                   (ps:chain console (log "No playlists found in response"))
                                   (array)))))
                 (ps:chain console (log "Playlists to display:" playlists))
                 (display-playlists playlists))))
       (catch (lambda (error)
                (ps:chain console (error "Error loading playlists:" error))
                (display-playlists (array))))))
    
    ;; Display playlists
    (defun display-playlists (playlists)
      (let ((container (ps:chain document (get-element-by-id "playlists-container"))))
        
        (if (or (not playlists) (= (ps:@ playlists length) 0))
            (setf (ps:@ container inner-h-t-m-l) "<div class=\"no-playlists\">No playlists created yet.</div>")
            (let ((playlists-html (ps:chain playlists
                                        (map (lambda (playlist)
                                               (+ "<div class=\"playlist-item\" data-playlist-id=\"" (ps:@ playlist id) "\">"
                                                  "<div class=\"playlist-info\">"
                                                  "<div class=\"playlist-name\">" (ps:@ playlist name) "</div>"
                                                  "<div class=\"playlist-meta\">" (ps:@ playlist "track-count") " tracks</div>"
                                                  "</div>"
                                                  "<div class=\"playlist-actions\">"
                                                  "<button onclick=\"viewPlaylist(" (ps:@ playlist id) ")\" class=\"btn btn-sm btn-secondary\" title=\"View tracks\">👁️</button>"
                                                  "<button onclick=\"loadPlaylist(" (ps:@ playlist id) ")\" class=\"btn btn-sm btn-info\" title=\"Load to queue\">📂</button>"
                                                  "<button onclick=\"deletePlaylist(" (ps:@ playlist id) ", '" (ps:chain (ps:@ playlist name) (replace (ps:regex "/'/g") "\\\\'")) "')\" class=\"btn btn-sm btn-danger\" title=\"Delete playlist\">🗑️</button>"
                                                  "</div>"
                                                  "</div>")))
                                        (join ""))))
          
              (setf (ps:@ container inner-h-t-m-l) playlists-html)))))
    
    ;; Delete playlist
    (defun delete-playlist (playlist-id playlist-name)
      (when (confirm (+ "Are you sure you want to delete playlist \"" playlist-name "\"?"))
        (let ((form-data (ps:new (-Form-data))))
          (ps:chain form-data (append "playlist-id" playlist-id))
          (ps:chain (fetch "/api/asteroid/playlists/delete"
                           (ps:create :method "POST" :body form-data))
                    (then (lambda (response) (ps:chain response (json))))
                    (then (lambda (result)
                            (let ((data (or (ps:@ result data) result)))
                              (if (= (ps:@ data status) "success")
                                  (progn
                                    (alert (+ "Playlist \"" playlist-name "\" deleted"))
                                    (load-playlists))
                                  (alert (+ "Error deleting playlist: " (ps:@ data message)))))))
                    (catch (lambda (error)
                             (ps:chain console (error "Error deleting playlist:" error))
                             (alert "Error deleting playlist")))))))
    
    ;; View playlist contents
    (defun view-playlist (playlist-id)
      (ps:chain
       (fetch (+ "/api/asteroid/playlists/get?playlist-id=" playlist-id))
       (then (lambda (response) (ps:chain response (json))))
       (then (lambda (result)
               (let ((data (or (ps:@ result data) result)))
                 (if (and (= (ps:@ data status) "success") (ps:@ data playlist))
                     (let* ((playlist (ps:@ data playlist))
                            (tracks (or (ps:@ playlist tracks) (array)))
                            (track-list (if (> (ps:@ tracks length) 0)
                                            (ps:chain tracks
                                                      (map (lambda (track index)
                                                             (+ (+ index 1) ". " 
                                                                (or (ps:@ track artist) "Unknown") " - " 
                                                                (or (ps:@ track title) "Unknown"))))
                                                      (join "\\n"))
                                            "No tracks in playlist")))
                       (alert (+ "Playlist: " (ps:@ playlist name) "\\n"
                                 "Tracks: " (ps:@ playlist "track-count") "\\n\\n"
                                 track-list)))
                     (alert "Could not load playlist")))))
       (catch (lambda (error)
                (ps:chain console (error "Error viewing playlist:" error))
                (alert "Error viewing playlist")))))
    
    ;; Load playlist into queue
    (defun load-playlist (playlist-id)
      (ps:chain
       (ps:chain (fetch (+ "/api/asteroid/playlists/get?playlist-id=" playlist-id)))
       (then (lambda (response) (ps:chain response (json))))
       (then (lambda (result)
               ;; Handle RADIANCE API wrapper format
               (let ((data (or (ps:@ result data) result)))
                 (if (and (= (ps:@ data status) "success") (ps:@ data playlist))
                     (let ((playlist (ps:@ data playlist)))
                       
                       ;; Clear current queue
                       (setf *play-queue* (array))
                       
                       ;; Add all playlist tracks to queue
                       (if (and (ps:@ playlist tracks) (> (ps:@ playlist tracks length) 0))
                           (progn
                             (ps:chain (ps:@ playlist tracks)
                                       (for-each (lambda (track)
                                                   ;; Find the full track object from our tracks array
                                                   (let ((full-track (ps:chain *tracks* 
                                                                             (find (lambda (trk) (= (ps:@ trk id) (ps:@ track id)))))))
                                                     (when full-track
                                                       (setf (aref *play-queue* (ps:@ *play-queue* length)) full-track))))))
                             
                             (update-queue-display)
                             (let ((loaded-count (ps:@ *play-queue* length)))
                               (alert (+ "Loaded " loaded-count " tracks from \"" (ps:@ playlist name) "\" into queue!"))
                               
                               ;; Optionally start playing the first track
                               (when (> loaded-count 0)
                                 (let* ((first-track (aref *play-queue* 0))
                                        (track-index (ps:chain *tracks* 
                                                               (find-index (lambda (trk) (= (ps:@ trk id) (ps:@ first-track id)))))))
                                   ;; Remove first track from queue since we're playing it
                                   (ps:chain *play-queue* (shift))
                                   (update-queue-display)
                                   (when (>= track-index 0)
                                     (play-track track-index))))))
                           (alert (+ "Playlist \"" (ps:@ playlist name) "\" is empty"))))
                     (alert (+ "Error loading playlist: " (or (ps:@ data message) "Unknown error")))))))
       (catch (lambda (error)
                (ps:chain console (error "Error loading playlist:" error))
                (alert (+ "Error loading playlist: " (ps:@ error message)))))))
    
    ;; Stream quality configuration
    (defun get-live-stream-config (stream-base-url quality)
      (let ((config (ps:create 
                      :aac (ps:create 
                             :url (+ stream-base-url "/asteroid.aac")
                             :type "audio/aac"
                             :mount "asteroid.aac")
                      :mp3 (ps:create 
                             :url (+ stream-base-url "/asteroid.mp3")
                             :type "audio/mpeg"
                             :mount "asteroid.mp3")
                      :low (ps:create 
                             :url (+ stream-base-url "/asteroid-low.mp3")
                             :type "audio/mpeg"
                             :mount "asteroid-low.mp3"))))
        (aref config quality)))
    
    ;; Change live stream quality
    (defun change-live-stream-quality ()
      (let ((stream-base-url (ps:chain (ps:chain document (get-element-by-id "stream-base-url")) value))
            (selector (ps:chain document (get-element-by-id "live-stream-quality")))
            (config (get-live-stream-config 
                     (ps:chain (ps:chain document (get-element-by-id "stream-base-url")) value)
                     (ps:chain (ps:chain document (get-element-by-id "live-stream-quality")) value))))
        
        ;; Update audio player
        (let ((audio-element (ps:chain document (get-element-by-id "live-stream-audio")))
              (source-element (ps:chain document (get-element-by-id "live-stream-source")))
              (was-playing (not (ps:chain (ps:chain document (get-element-by-id "live-stream-audio")) paused))))
          
          (setf (ps:@ source-element src) (ps:@ config url))
          (setf (ps:@ source-element type) (ps:@ config type))
          (ps:chain audio-element (load))
          
          ;; Resume playback if it was playing
          (when was-playing
            (ps:chain audio-element 
                      (play)
                      (catch (lambda (e) (ps:chain console (log "Autoplay prevented:" e)))))))))
    
    ;; Update now playing information
    (defun update-now-playing ()
      (ps:chain
       (fetch "/api/asteroid/partial/now-playing")
       (then (lambda (response)
               (let ((content-type (ps:chain response headers (get "content-type"))))
                 (if (ps:chain content-type (includes "text/html"))
                     (ps:chain response (text))
                     (progn
                       (ps:chain console (log "Error connecting to stream"))
                       "")))))
       (then (lambda (data)
               (setf (ps:chain document (get-element-by-id "now-playing") inner-h-t-m-l) data)))

       (catch (lambda (error)
                (ps:chain console (log "Could not fetch stream status:" error))))))
    
    ;; Initial update after 1 second
    (set-timeout update-now-playing 1000)
    ;; Update live stream info every 10 seconds
    (set-interval update-now-playing 10000)
    
    ;; Make functions globally accessible for onclick handlers
    (defvar window (ps:@ window))
    (setf (ps:@ window play-track) play-track)
    (setf (ps:@ window add-to-queue) add-to-queue)
    (setf (ps:@ window remove-from-queue) remove-from-queue)
    (setf (ps:@ window library-go-to-page) library-go-to-page)
    (setf (ps:@ window library-previous-page) library-previous-page)
    (setf (ps:@ window library-next-page) library-next-page)
    (setf (ps:@ window library-go-to-last-page) library-go-to-last-page)
    (setf (ps:@ window change-library-tracks-per-page) change-library-tracks-per-page)
    (setf (ps:@ window load-playlist) load-playlist)
    (setf (ps:@ window delete-playlist) delete-playlist)
    (setf (ps:@ window view-playlist) view-playlist)
    (setf (ps:@ window show-add-to-playlist-menu) show-add-to-playlist-menu)
    (setf (ps:@ window add-track-to-playlist) add-track-to-playlist)))
  "Compiled JavaScript for web player - generated at load time")

(defun generate-player-js ()
  "Generate JavaScript code for the web player"
  *player-js*)