#lang racket

(require racket/class
         "music-library.rkt"
         racket-sound
         )

(provide track%
         playlist%
         )

(define the-displayln displayln)

(define track%
  (class object%
    (init-field
     [file #f]
     [title ""]
     [artist ""]
     [album ""]
     [length 0]
     [number 0]
     )

    (define/public (displayln)
      (the-displayln (format "~a - ~a - ~a - ~a"
                             number
                             title
                             album
                             length)))

    (define/public (get-file) file)
    (define/public (get-title) title)
    (define/public (get-artist) artist)
    (define/public (get-album) album)
    (define/public (get-number) number)
    (define/public (get-length) length)

    (super-new)
    (begin
      (unless (eq? file #f)
        (let ((tags (id3-tags (format "~a" file))))
          (set! title (tags-title tags))
          (set! artist (tags-artist tags))
          (set! album (tags-album tags))
          (set! number (tags-track tags))
          (set! length (tags-length tags))
          )
        )
      )
    ))

(define list-len length)

(define playlist%
  (class object%
    (init-field
     [start-map #f]
     [max-tracks 100]
     )
    
    (define tracks '())

    (define (can-add? file)
      (and (<= (list-len tracks) max-tracks)
           (is-music-file? file)))

    (define (add-track file)
      (let  ((track (new track% [file file])))
        (set! tracks (append tracks (list track)))))

    (define (read-tracks-internal dir)
      ;(displayln (format "dir = ~a" dir))
      (if (> (list-len tracks) max-tracks)
          'done
          (if (file-exists? dir)
              (when (can-add? dir)
                (add-track dir))
              (if (directory-exists? dir)
                  (let ((content (directory-list dir)))
                    (for-each (λ (entry)
                                (let ((p (build-path dir entry)))
                                  (if (directory-exists? p)
                                      (read-tracks-internal p)
                                      (when (and (file-exists? p) (can-add? p))
                                        (add-track p)))))
                              content))
                  'no-file-or-dir
                  )
              )
          )
      )

    (define/public (read-tracks)
      (set! tracks '())
      (read-tracks-internal start-map)
      )

    (define/public (length)
      (list-len tracks))

    (define/public (track i)
      (list-ref tracks i))

    (define/public (display-tracks)
      (for-each (λ (track)
                  (send track displayln))
                tracks))

    (super-new)
    (begin
      (when (eq? start-map #f)
        (error "Initialize playlist% with a starting map"))
      )
    )
  )