#lang racket/base

(require racket-mimetypes/mimetypes
         racket/class
         racket/file
         racket/path
         "library-ref.rkt"
         "base/media-resource.rkt"
         "track-filesystem-providers.rkt"
         "track-tag-data.rkt"
         "base/track.rkt"
         "../misc/utils.rkt")

(provide track-filesystem%)

(define track-filesystem%
  (class track%
    (init-field library relative-path)

    (check/c track-filesystem%
             relative-path
             list?)

    (define file
      (send library resolve-path relative-path))

    (define mime-type
      (mimetype-for-ext
       file
       #:default "application/octet-stream"))

    (define tag-source
      (new tag-source-filesystem%
           [file file]))

    (super-new
     [resource
      (new media-resource-file%
           [file file]
           [mime-type mime-type])]
     [music-library-factory-id
      (let ((cfg (send library get-cfg)))
        (library-ref
         (send cfg get-id)
         (send cfg get-kind)
         (send cfg get-kind-version)))]
     [track-factory-id 'file]
     [track-relive-info relative-path]
     [tag-data-provider
      (new tag-data-provider-filesystem%
           [tag-source tag-source]
           [fallback-data
            (track-tag-data
             (path->string
              (file-name-from-path file))
             ""
             ""
             0
             0)])]
     [image-provider
      (new image-provider-filesystem%
           [file file]
           [tag-source tag-source])]
     [booklet-provider
      (new booklet-provider-filesystem%
           [file file])])))

(module+ test
  (require rackunit)

  (define file
    (make-temporary-file "rktplayer-track-~a.mp3"))

  (define cfg%
    (class object%
      (define/public (get-id) 'test-library)
      (define/public (get-kind) 'filesystem)
      (define/public (get-kind-version) 1)
      (super-new)))

  (define library%
    (class object%
      (define/public (resolve-path relative-path)
        file)
      (define/public (get-cfg)
        (new cfg%))
      (super-new)))

  (dynamic-wind
    void
    (lambda ()
      (let* ((track
              (new track-filesystem%
                   [library (new library%)]
                   [relative-path
                    (list (file-name-from-path file))]))
             (resource (send track get-resource))
             (library-reference
              (send track get-music-library-factory-id)))
        (check-true (is-a? track track%))
        (check-equal?
         (send resource get-file)
         (normal-case-path
          (path->complete-path file)))
        (check-equal? (send track get-track-factory-id) 'file)
        (check-equal? (send track get-track-relive-info)
                      (list (file-name-from-path file)))
        (check-true (is-a? resource media-resource-file%))
        (check-true (send resource is-seekable?))
        (check-equal? (send resource get-mime-type)
                      "audio/mpeg")
        (check-equal? (library-ref-library-id library-reference)
                      'test-library)))
    (lambda ()
      (when (file-exists? file)
        (delete-file file)))))