(import (scheme base)
        (only (csc format)
          sprintf)
        (only (csc loop)
          loop
          return)
        (only (csc sort) sort)
        (only (csc testing)
              assert-equal
              assert-raises
              test)
        (csc hash-map))


(define (alist->map->alist l)
  (map->alist (alist->map compare-symbols l)))


(test map->alist-singleton
  (assert-equal
    '((a . 1))
    (alist->map->alist '((a . 1)))))


(test map->alist-two
  (assert-equal
    '((a . 1) (b . 2))
    (alist->map->alist '((a . 1) (b . 2))))


(test map->alist-longer
  (assert-equal
    '((a . 1) (b . 2) (c . 3) (d . 4) (e . 5) (f . 6))
    (alist->map->alist '((a . 1) (b . 2) (c . 3) (d . 4) (e . 5) (f . 6))))))


(test map->alist-larger
  (assert-equal
    '((f . 5) (m . 1) (n . 7) (q . 3) (x . 8))
    (alist->map->alist '((m . 1) (n . 2) (q . 3) (f . 5) (n . 7) (x . 8)))))


(test map->alist-in-order
  (assert-equal
    '((a . ()) (b . ()) (c . ()) (d . ()) (e . ()) (f . ()) (g . ()) (h . ()))
    (alist->map->alist '((a . ()) (b . ()) (c . ()) (d . ()) (e . ()) (f . ()) (g . ()) (h . ())))))


(test map->alist-reversed
  (assert-equal
    '((h . ()) (g . ()) (f . ()) (e . ()) (d . ()) (c . ()) (b . ()) (a . ()))
    (alist->map->alist '((a . ()) (b . ()) (c . ()) (d . ()) (e . ()) (f . ()) (g . ()) (h . ())))))


(test map->alist-overwrite
  (assert-equal
    '((a . 2))
    (alist->map->alist '((a . 1) (a . 2)))))


(test map->alist-alternating
  (assert-equal
    '((h . ()) (g . ()) (i . ()) (f . ()) (j . ()) (e . ()) (k . ()) (d . ()) (l . ()) (c . ()))
    (alist->map->alist '((c . ()) (d . ()) (e . ()) (f . ()) (g . ()) (h . ()) (i . ()) (j . ()) (k . ()) (l . ())))))


(test lookup
  (assert-equal
    2
    (lookup (alist->map compare-symbols '((a . 1) (b . 2) (c . 3))) 'b)))


(test lookup-notfound
  (assert-raises key-not-found-error?
    (lookup (alist->map compare-symbols '((a . 1) (b . 2) (c . 3))) 'd)))


(test lookup-default
  (assert-equal
    #f
    (lookup (alist->map compare-symbols '((a . #t) (b . #t))) 'c #f)))


(define transform-map
  (list
    (cons map? map->alist)))


(define (test-map . bindings)
  (alist->map compare-symbols bindings))


(test merge
  (assert-equal
    '((a . 1) (b . 2) (c . 3) (d . 4))
    (merge
      (test-map '(a . 1) '(b . 2))
      (test-map '(c . 3) '(d . 4)))
    transform-map))


(test delete
  (assert-equal
    '((a . 1) (b . 2) (d . 4))
    (delete
      (test-map '(a . 1) '(b . 2) '(c . 3) '(d . 4))
      'c)
    transform-map))


(test delete-only
  (assert-equal
    '()
    (delete
      (test-map '(a . 1))
      'a)
    transform-map))


(test delete-first
  (assert-equal
    '((b . 2) (c . 3) (d . 4))
    (delete
      (test-map '(a . 1) '(b . 2) '(c . 3) '(d . 4))
      'a)
    transform-map))


(test delete-last
  (assert-equal
    '((a . 1) (b . 2) (c . 3))
    (delete
      (test-map '(a . 1) '(b . 2) '(c . 3) '(d . 4))
      'd)
    transform-map))


(test delete-many
  (assert-equal
    '()
    (loop with m = (loop with m = (test-map)
                         for i from 1 to 100
                         do (set! m (insert m (string->symbol (sprintf "key{}" i)) i))
                         finally (return m))
          for i from 1 to 100
          do (set! m (delete m (string->symbol (sprintf "key{}" i))))
          finally (return m))
    transform-map))