(module class-resolver mzscheme
  (require (planet "inspector.ss" ("dherman" "inspector.plt" 1)))
  (require (planet "struct.ss" ("dherman" "struct.plt" 1 2)))
  (require (lib "string.ss" "srfi" "13"))
  (require (lib "class.ss"))
  (require (lib "contract.ss"))

  (define class-resolver<%>
    (interface () resolve-package resolve-type))

  (define current-class-resolver
    (make-parameter #f (lambda (new-resolver)
                         (unless (is-a? new-resolver class-resolver<%>)
                           (raise-type-error 'current-class-resolver
                                             "class-resolver<%>"
                                             new-resolver))
                         new-resolver)))

  (with-public-inspector
    (define-struct/opt type-name (package type [dimension 0]))
    ;; TODO: provide with contracts
    (provide (struct type-name (package type dimension))))
;    (provide/contract (struct type-name ([package (listof symbol?)]
;                                         [type symbol?]))))

  ;; build-type-name : (listof symbol) -> type-name
  (define (build-type-name name)
    (let ([rev (reverse name)])
      (make-type-name (reverse (cdr rev))
                      (car rev))))

  ;; dot-notation : (listof symbol) -> string
  (define (dot-notation los)
    (string-join (map symbol->string los) "." 'infix))

  (define (type-name->string name)
    (string-append
     (dot-notation (type-name-package name))
     "."
     (symbol->string (type-name-type name))))

  (provide/contract
   [build-type-name ((listof symbol?) . -> . type-name?)]
   [dot-notation ((listof symbol?) . -> . string?)]
   [type-name->string (type-name? . -> . string?)])

  ;; TODO: I can't give these contracts because of cyclic module dependencies!

  ;; lookup-package : (listof symbol) -> (optional package%)
  (define (lookup-package name)
    (send (current-class-resolver) resolve-package name))

  ;; lookup-type : type-name -> type<%>
  (define (lookup-type name)
    (send (current-class-resolver) resolve-type name))

  (provide current-class-resolver class-resolver<%> lookup-package lookup-type))