#lang racket/base

(require "../misc/utils.rkt")

(provide
 (struct-out library-item)
 library-item->store
 store->library-item)

(define library-item-store-version
  1)

(struct library-item
  (id
   name
   kind
   kind-version
   root
   host
   item-limit
   current)
  #:transparent
  #:guard
  (lambda (id name kind kind-version root host item-limit current type-name)
    (check/c* library-item
              (id symbol?)
              (name string?)
              (kind (or/c 'filesystem 'media-server))
              (kind-version exact-positive-integer?)
              (root (or/c path? string?))
              (host (or/c #f string?))
              (item-limit exact-positive-integer?)
              (current boolean?))
    (values id
            name
            kind
            kind-version
            root
            host
            item-limit
            current)))

(define (library-item->store item)
  (check/c library-item->store item library-item?)

  (let ((root (library-item-root item)))
    (hash
     'version library-item-store-version
     'id (library-item-id item)
     'name (library-item-name item)
     'kind (library-item-kind item)
     'kind-version (library-item-kind-version item)
     'root (if (path? root) (path->string root) root)
     'host (library-item-host item)
     'item-limit (library-item-item-limit item)
     'current (library-item-current item))))

(define (store->library-item stored)
  (check/c store->library-item stored hash?)

  (let ((version (hash-ref stored 'version #f)))
    (check/c store->library-item
             version
             (=/c library-item-store-version))

    (library-item
     (hash-ref stored 'id)
     (hash-ref stored 'name)
     (hash-ref stored 'kind)
     (hash-ref stored 'kind-version)
     (hash-ref stored 'root)
     (hash-ref stored 'host)
     (hash-ref stored 'item-limit 100)
     (hash-ref stored 'current))))