(defvar sibilant (require "../lib/sibilant")
        sys      (require 'sys)
        inspect  sys.inspect
        passes   0
        fails    0)

(set sibilant
     'dir (meta (macros.quote sibilant.dir)))

(delmacro inspect)

(console.log (concat "Testing " (sibilant.version-string)))

(defun green (&rest args)
  (concat "\033[32m" (join "" args) "\033[0m"))

(defun red (&rest args)
  (concat "\033[31m" (join "" args) "\033[0m"))

(defun trim (string)
  (if string (string.trim) ""))

(defun pass () (incr passes) (sys.print (green ".")))

(defun fail (&optional message)
  (incr fails)
  (sys.print (concat (red "F") "\n" (+ passes fails) ": "
          (or message "")
          (chain (get (new (Error)) 'stack)
            (replace /Error.*/ ""))
          "\n")))

(defun assert (thing &optional message)
  (if thing (pass) (fail message)))

(defun assert-equal (expected actual &optional message)
  (assert (= expected actual)
          (concat (if message (concat message "\n") "")
                  "\n  expected " (green (inspect expected))
                  "\n   but got " (red (inspect actual)) "\n")))

(defun assert-match (regex thing &optional message)
  (assert (regex.test thing)
          (concat (if message (concat message "\n\n") "")
                  "expected "
                  (inspect thing) " to match "
                  (inspect regex) " but it did not.")))

(defun assert-translation (sibilant-code js-code)
  (assert-equal (trim js-code)
		(trim (try (sibilant.translate-all sibilant-code)))))

(defun assert-throws (block &optional message)
  (try (progn (block)
              (fail (concat "expected to catch "
                                   (if message (concat "`" message "'") "an error")
                                   " but caught nothing")))
       (if message
         (assert-equal (trim message) (trim (e.to-string)))
         (pass))))

(defun assert-translation-error (sibilant-code error-text)
  (assert-throws (thunk (sibilant.translate-all (trim sibilant-code))) error-text))

(defun assert-true (&rest args)
  (args.unshift true)
  (apply assert-equal args))

(defun assert-false (&rest args)
  (args.unshift false)
  (apply assert-equal args))

(defun assert-deep-equal (expected actual)
  (each (item index) expected
            (assert-equal item (get actual index))))

(process.next-tick (lambda ()
                     (console.log (concat "\n\n" (+ passes fails) " total tests, "
                                          (green passes " passed") ", " (red fails " failed")))
                     (when (> fails 0) (process.exit 1))))